From 6b7d02e5ae0bb6a3d3ba0fe30da942200a171f70 Mon Sep 17 00:00:00 2001 From: "Tobin C. Harding" Date: Tue, 11 Jun 2024 12:39:49 +1000 Subject: [PATCH 1/2] Add inherent functions to hashes Currently we have a trait `Hash` that is required for `Hmac`, `Hkdf`, and other use cases. However, it is unegonomic for users who just want to do a simple hash to have to import the trait. Add inherent functions to all hash types including those created with the new wrapper type macros. This patch introduces some duplicate code but we are trying to make progress in the hashes API re-write. We can come back and de-dublicate later. Includes making `to_byte_array`,`from_byte_array`, `as_byte_array`, and `all_zeros` const where easily possible. --- base58/src/lib.rs | 2 +- bitcoin/examples/ecdsa-psbt-simple.rs | 1 - bitcoin/examples/sign-tx-segwit-v0.rs | 1 - bitcoin/examples/sign-tx-taproot.rs | 1 - bitcoin/examples/taproot-psbt-simple.rs | 1 - bitcoin/src/address/mod.rs | 2 +- bitcoin/src/bip152.rs | 2 +- bitcoin/src/bip158.rs | 2 +- bitcoin/src/blockdata/block.rs | 2 +- bitcoin/src/blockdata/constants.rs | 2 +- bitcoin/src/blockdata/script/borrowed.rs | 1 - bitcoin/src/blockdata/script/tests.rs | 1 - .../src/blockdata/script/witness_program.rs | 1 - bitcoin/src/blockdata/transaction.rs | 2 +- bitcoin/src/crypto/key.rs | 2 +- bitcoin/src/crypto/sighash.rs | 2 +- bitcoin/src/hash_types.rs | 1 - bitcoin/src/internal_macros.rs | 3 - bitcoin/src/merkle_tree/block.rs | 1 - bitcoin/src/p2p/message.rs | 2 +- bitcoin/src/p2p/message_blockdata.rs | 3 +- bitcoin/src/pow.rs | 7 -- bitcoin/src/psbt/mod.rs | 2 +- bitcoin/src/psbt/serialize.rs | 2 +- bitcoin/src/sign_message.rs | 4 +- bitcoin/src/taproot/mod.rs | 2 +- bitcoin/tests/serde.rs | 2 +- fuzz/fuzz_targets/hashes/ripemd160.rs | 2 +- fuzz/fuzz_targets/hashes/sha1.rs | 2 +- fuzz/fuzz_targets/hashes/sha256.rs | 2 +- fuzz/fuzz_targets/hashes/sha512.rs | 2 +- fuzz/fuzz_targets/hashes/sha512_256.rs | 2 +- hashes/src/hash160.rs | 4 +- hashes/src/internal_macros.rs | 107 ++++++++++++------ hashes/src/lib.rs | 2 +- hashes/src/ripemd160.rs | 4 +- hashes/src/sha1.rs | 4 +- hashes/src/sha256.rs | 4 +- hashes/src/sha256d.rs | 4 +- hashes/src/sha256t.rs | 70 ++++++++++-- hashes/src/sha384.rs | 2 +- hashes/src/sha512.rs | 4 +- hashes/src/sha512_256.rs | 2 +- hashes/src/siphash24.rs | 2 +- hashes/src/util.rs | 106 ++++++++++++----- 45 files changed, 248 insertions(+), 131 deletions(-) diff --git a/base58/src/lib.rs b/base58/src/lib.rs index 05544c436..d2ce2de5f 100644 --- a/base58/src/lib.rs +++ b/base58/src/lib.rs @@ -35,7 +35,7 @@ use core::{fmt, str}; #[cfg(feature = "std")] pub use std::{string::String, vec::Vec}; -use hashes::{sha256d, Hash}; +use hashes::sha256d; use crate::error::{IncorrectChecksumError, TooShortError}; diff --git a/bitcoin/examples/ecdsa-psbt-simple.rs b/bitcoin/examples/ecdsa-psbt-simple.rs index ac2c17f81..f9ed0feb9 100644 --- a/bitcoin/examples/ecdsa-psbt-simple.rs +++ b/bitcoin/examples/ecdsa-psbt-simple.rs @@ -26,7 +26,6 @@ use std::collections::BTreeMap; use std::str::FromStr; use bitcoin::bip32::{ChildNumber, DerivationPath, Fingerprint, IntoDerivationPath, Xpriv, Xpub}; -use bitcoin::hashes::Hash; use bitcoin::locktime::absolute; use bitcoin::psbt::Input; use bitcoin::secp256k1::{Secp256k1, Signing}; diff --git a/bitcoin/examples/sign-tx-segwit-v0.rs b/bitcoin/examples/sign-tx-segwit-v0.rs index 73507f1f7..f861ce21d 100644 --- a/bitcoin/examples/sign-tx-segwit-v0.rs +++ b/bitcoin/examples/sign-tx-segwit-v0.rs @@ -4,7 +4,6 @@ use std::str::FromStr; -use bitcoin::hashes::Hash; use bitcoin::locktime::absolute; use bitcoin::secp256k1::{rand, Message, Secp256k1, SecretKey, Signing}; use bitcoin::sighash::{EcdsaSighashType, SighashCache}; diff --git a/bitcoin/examples/sign-tx-taproot.rs b/bitcoin/examples/sign-tx-taproot.rs index 3221c560c..151bd5639 100644 --- a/bitcoin/examples/sign-tx-taproot.rs +++ b/bitcoin/examples/sign-tx-taproot.rs @@ -4,7 +4,6 @@ use std::str::FromStr; -use bitcoin::hashes::Hash; use bitcoin::key::{Keypair, TapTweak, TweakedKeypair, UntweakedPublicKey}; use bitcoin::locktime::absolute; use bitcoin::secp256k1::{rand, Message, Secp256k1, SecretKey, Signing, Verification}; diff --git a/bitcoin/examples/taproot-psbt-simple.rs b/bitcoin/examples/taproot-psbt-simple.rs index 48b9cc0a7..7ea13d443 100644 --- a/bitcoin/examples/taproot-psbt-simple.rs +++ b/bitcoin/examples/taproot-psbt-simple.rs @@ -24,7 +24,6 @@ use std::collections::BTreeMap; use std::str::FromStr; use bitcoin::bip32::{ChildNumber, DerivationPath, Fingerprint, IntoDerivationPath, Xpriv, Xpub}; -use bitcoin::hashes::Hash; use bitcoin::key::UntweakedPublicKey; use bitcoin::locktime::absolute; use bitcoin::psbt::Input; diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs index 9eee27a6e..115d0d90b 100644 --- a/bitcoin/src/address/mod.rs +++ b/bitcoin/src/address/mod.rs @@ -33,7 +33,7 @@ use core::marker::PhantomData; use core::str::FromStr; use bech32::primitives::hrp::Hrp; -use hashes::{sha256, Hash, HashEngine}; +use hashes::{sha256, HashEngine}; use secp256k1::{Secp256k1, Verification, XOnlyPublicKey}; use crate::blockdata::constants::{ diff --git a/bitcoin/src/bip152.rs b/bitcoin/src/bip152.rs index b20fb8b22..766a82e0e 100644 --- a/bitcoin/src/bip152.rs +++ b/bitcoin/src/bip152.rs @@ -8,7 +8,7 @@ use core::{convert, fmt, mem}; #[cfg(feature = "std")] use std::error; -use hashes::{sha256, siphash24, Hash}; +use hashes::{sha256, siphash24}; use internals::impl_array_newtype; use io::{BufRead, Write}; diff --git a/bitcoin/src/bip158.rs b/bitcoin/src/bip158.rs index 7e54b810c..ee027d7ce 100644 --- a/bitcoin/src/bip158.rs +++ b/bitcoin/src/bip158.rs @@ -40,7 +40,7 @@ use core::cmp::{self, Ordering}; use core::fmt::{self, Display, Formatter}; -use hashes::{sha256d, siphash24, Hash}; +use hashes::{sha256d, siphash24}; use internals::write_err; use io::{BufRead, Write}; diff --git a/bitcoin/src/blockdata/block.rs b/bitcoin/src/blockdata/block.rs index 9d194d625..2e61ec0f9 100644 --- a/bitcoin/src/blockdata/block.rs +++ b/bitcoin/src/blockdata/block.rs @@ -9,7 +9,7 @@ use core::fmt; -use hashes::{sha256d, Hash, HashEngine}; +use hashes::{sha256d, HashEngine}; use io::{BufRead, Write}; use super::Weight; diff --git a/bitcoin/src/blockdata/constants.rs b/bitcoin/src/blockdata/constants.rs index c652c4bf3..8aa42d22c 100644 --- a/bitcoin/src/blockdata/constants.rs +++ b/bitcoin/src/blockdata/constants.rs @@ -6,7 +6,7 @@ //! consensus code. In particular, it defines the genesis block and its //! single transaction. -use hashes::{sha256d, Hash}; +use hashes::sha256d; use internals::impl_array_newtype; use crate::blockdata::block::{self, Block}; diff --git a/bitcoin/src/blockdata/script/borrowed.rs b/bitcoin/src/blockdata/script/borrowed.rs index f07858d21..050e0c578 100644 --- a/bitcoin/src/blockdata/script/borrowed.rs +++ b/bitcoin/src/blockdata/script/borrowed.rs @@ -5,7 +5,6 @@ use core::ops::{ Bound, Index, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive, }; -use hashes::Hash; use secp256k1::{Secp256k1, Verification}; use super::PushBytes; diff --git a/bitcoin/src/blockdata/script/tests.rs b/bitcoin/src/blockdata/script/tests.rs index 965e61890..5fb6da4d6 100644 --- a/bitcoin/src/blockdata/script/tests.rs +++ b/bitcoin/src/blockdata/script/tests.rs @@ -2,7 +2,6 @@ use core::str::FromStr; -use hashes::Hash; use hex_lit::hex; use super::*; diff --git a/bitcoin/src/blockdata/script/witness_program.rs b/bitcoin/src/blockdata/script/witness_program.rs index 9b76becc8..710753acc 100644 --- a/bitcoin/src/blockdata/script/witness_program.rs +++ b/bitcoin/src/blockdata/script/witness_program.rs @@ -9,7 +9,6 @@ use core::fmt; -use hashes::Hash as _; use internals::array_vec::ArrayVec; use secp256k1::{Secp256k1, Verification}; diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs index 26948bbe3..132d7a71d 100644 --- a/bitcoin/src/blockdata/transaction.rs +++ b/bitcoin/src/blockdata/transaction.rs @@ -12,7 +12,7 @@ use core::{cmp, fmt, str}; -use hashes::{sha256d, Hash}; +use hashes::sha256d; use internals::write_err; use io::{BufRead, Write}; use units::parse::{self, PrefixedHexError, UnprefixedHexError}; diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs index 01a7f7f18..8e5127df3 100644 --- a/bitcoin/src/crypto/key.rs +++ b/bitcoin/src/crypto/key.rs @@ -9,7 +9,7 @@ use core::fmt::{self, Write as _}; use core::ops; use core::str::FromStr; -use hashes::{hash160, Hash}; +use hashes::hash160; use hex::{FromHex, HexToArrayError}; use internals::array_vec::ArrayVec; use internals::write_err; diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs index a11c770de..f68fb56bc 100644 --- a/bitcoin/src/crypto/sighash.rs +++ b/bitcoin/src/crypto/sighash.rs @@ -13,7 +13,7 @@ use core::{fmt, str}; -use hashes::{hash_newtype, sha256, sha256d, sha256t_hash_newtype, Hash}; +use hashes::{hash_newtype, sha256, sha256d, sha256t_hash_newtype}; use internals::write_err; use io::Write; diff --git a/bitcoin/src/hash_types.rs b/bitcoin/src/hash_types.rs index a7014583a..58c008a7f 100644 --- a/bitcoin/src/hash_types.rs +++ b/bitcoin/src/hash_types.rs @@ -13,7 +13,6 @@ pub use crate::{ #[cfg(test)] mod tests { use super::*; - use crate::hashes::Hash; use crate::{ LegacySighash, PubkeyHash, ScriptHash, SegwitV0Sighash, TapSighash, WPubkeyHash, WScriptHash, XKeyIdentifier, diff --git a/bitcoin/src/internal_macros.rs b/bitcoin/src/internal_macros.rs index b33ac5fc5..2429009fe 100644 --- a/bitcoin/src/internal_macros.rs +++ b/bitcoin/src/internal_macros.rs @@ -185,7 +185,6 @@ macro_rules! impl_hashencode { impl $crate::consensus::Decodable for $hashtype { fn consensus_decode(r: &mut R) -> core::result::Result { - use $crate::hashes::Hash; Ok(Self::from_byte_array(<<$hashtype as $crate::hashes::Hash>::Bytes>::consensus_decode(r)?)) } } @@ -199,14 +198,12 @@ macro_rules! impl_asref_push_bytes { $( impl AsRef<$crate::blockdata::script::PushBytes> for $hashtype { fn as_ref(&self) -> &$crate::blockdata::script::PushBytes { - use $crate::hashes::Hash; self.as_byte_array().into() } } impl From<$hashtype> for $crate::blockdata::script::PushBytesBuf { fn from(hash: $hashtype) -> Self { - use $crate::hashes::Hash; hash.as_byte_array().into() } } diff --git a/bitcoin/src/merkle_tree/block.rs b/bitcoin/src/merkle_tree/block.rs index ed8f26dc7..09915eb6b 100644 --- a/bitcoin/src/merkle_tree/block.rs +++ b/bitcoin/src/merkle_tree/block.rs @@ -40,7 +40,6 @@ use core::fmt; -use hashes::Hash; use io::{BufRead, Write}; use self::MerkleBlockError::*; diff --git a/bitcoin/src/p2p/message.rs b/bitcoin/src/p2p/message.rs index 239ba91c8..829e12114 100644 --- a/bitcoin/src/p2p/message.rs +++ b/bitcoin/src/p2p/message.rs @@ -7,7 +7,7 @@ use core::{fmt, iter}; -use hashes::{sha256d, Hash}; +use hashes::sha256d; use io::{BufRead, Write}; use crate::blockdata::{block, transaction}; diff --git a/bitcoin/src/p2p/message_blockdata.rs b/bitcoin/src/p2p/message_blockdata.rs index 05c4d4e01..c61421506 100644 --- a/bitcoin/src/p2p/message_blockdata.rs +++ b/bitcoin/src/p2p/message_blockdata.rs @@ -5,7 +5,7 @@ //! This module describes network messages which are used for passing //! Bitcoin data (blocks and transactions) around. -use hashes::{sha256d, Hash as _}; +use hashes::sha256d; use io::{BufRead, Write}; use crate::blockdata::block::BlockHash; @@ -144,7 +144,6 @@ impl_consensus_encoding!(GetHeadersMessage, version, locator_hashes, stop_hash); #[cfg(test)] mod tests { - use hashes::Hash; use hex::test_hex_unwrap as hex; use super::*; diff --git a/bitcoin/src/pow.rs b/bitcoin/src/pow.rs index eab1f9e3e..b936644d3 100644 --- a/bitcoin/src/pow.rs +++ b/bitcoin/src/pow.rs @@ -217,7 +217,6 @@ impl Target { /// to the target. #[cfg_attr(all(test, mutate), mutate)] pub fn is_met_by(&self, hash: BlockHash) -> bool { - use hashes::Hash; let hash = U256::from_le_bytes(hash.to_byte_array()); hash <= self.0 } @@ -1784,8 +1783,6 @@ mod tests { #[test] fn compact_target_from_upwards_difficulty_adjustment_using_headers() { - use hashes::Hash; - use crate::block::Version; use crate::constants::genesis_block; use crate::TxMerkleNode; @@ -1809,8 +1806,6 @@ mod tests { #[test] fn compact_target_from_downwards_difficulty_adjustment_using_headers() { - use hashes::Hash; - use crate::block::Version; use crate::TxMerkleNode; let params = Params::new(crate::Network::Signet); @@ -1896,8 +1891,6 @@ mod tests { fn target_is_met_by_for_target_equals_hash() { use std::str::FromStr; - use hashes::Hash; - let hash = BlockHash::from_str("ef537f25c895bfa782526529a9b63d97aa631564d5d789c2b765448c8635fb6c") .expect("failed to parse block hash"); diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs index 86f1f9b47..1f12a053e 100644 --- a/bitcoin/src/psbt/mod.rs +++ b/bitcoin/src/psbt/mod.rs @@ -1205,7 +1205,7 @@ pub use self::display_from_str::PsbtParseError; #[cfg(test)] mod tests { - use hashes::{hash160, ripemd160, sha256, Hash}; + use hashes::{hash160, ripemd160, sha256}; use hex::{test_hex_unwrap as hex, FromHex}; #[cfg(feature = "rand-std")] use secp256k1::{All, SecretKey}; diff --git a/bitcoin/src/psbt/serialize.rs b/bitcoin/src/psbt/serialize.rs index 25e7890fb..972c93a97 100644 --- a/bitcoin/src/psbt/serialize.rs +++ b/bitcoin/src/psbt/serialize.rs @@ -5,7 +5,7 @@ //! Traits to serialize PSBT values to and from raw bytes //! according to the BIP-174 specification. -use hashes::{hash160, ripemd160, sha256, sha256d, Hash}; +use hashes::{hash160, ripemd160, sha256, sha256d}; use secp256k1::XOnlyPublicKey; use super::map::{Input, Map, Output, PsbtSighashType}; diff --git a/bitcoin/src/sign_message.rs b/bitcoin/src/sign_message.rs index 9f7bb524d..3e85a7a8c 100644 --- a/bitcoin/src/sign_message.rs +++ b/bitcoin/src/sign_message.rs @@ -5,7 +5,7 @@ //! This module provides signature related functions including secp256k1 signature recovery when //! library is used with the `secp-recovery` feature. -use hashes::{sha256d, Hash, HashEngine}; +use hashes::{sha256d, HashEngine}; use crate::consensus::{encode, Encodable}; @@ -21,7 +21,7 @@ pub const BITCOIN_SIGNED_MSG_PREFIX: &[u8] = b"\x18Bitcoin Signed Message:\n"; mod message_signing { use core::fmt; - use hashes::{sha256d, Hash}; + use hashes::sha256d; use internals::write_err; use secp256k1::ecdsa::{RecoverableSignature, RecoveryId}; diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs index 138c391ce..5fe0a16b1 100644 --- a/bitcoin/src/taproot/mod.rs +++ b/bitcoin/src/taproot/mod.rs @@ -11,7 +11,7 @@ use core::cmp::Reverse; use core::fmt; use core::iter::FusedIterator; -use hashes::{sha256t_hash_newtype, Hash, HashEngine}; +use hashes::{sha256t_hash_newtype, HashEngine}; use internals::write_err; use io::Write; use secp256k1::{Scalar, Secp256k1}; diff --git a/bitcoin/tests/serde.rs b/bitcoin/tests/serde.rs index 014012fd3..6bd400bcc 100644 --- a/bitcoin/tests/serde.rs +++ b/bitcoin/tests/serde.rs @@ -30,7 +30,7 @@ use bitcoin::bip32::{ChildNumber, KeySource, Xpriv, Xpub}; use bitcoin::blockdata::locktime::{absolute, relative}; use bitcoin::blockdata::witness::Witness; use bitcoin::consensus::encode::deserialize; -use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash}; +use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d}; use bitcoin::hex::FromHex; use bitcoin::psbt::raw::{self, Key, Pair, ProprietaryKey}; use bitcoin::psbt::{Input, Output, Psbt, PsbtSighashType}; diff --git a/fuzz/fuzz_targets/hashes/ripemd160.rs b/fuzz/fuzz_targets/hashes/ripemd160.rs index f311a9b5b..9b0e338ec 100644 --- a/fuzz/fuzz_targets/hashes/ripemd160.rs +++ b/fuzz/fuzz_targets/hashes/ripemd160.rs @@ -1,4 +1,4 @@ -use bitcoin::hashes::{ripemd160, Hash, HashEngine}; +use bitcoin::hashes::{ripemd160, HashEngine}; use honggfuzz::fuzz; fn do_test(data: &[u8]) { diff --git a/fuzz/fuzz_targets/hashes/sha1.rs b/fuzz/fuzz_targets/hashes/sha1.rs index 81b0a2c7f..ab72db64e 100644 --- a/fuzz/fuzz_targets/hashes/sha1.rs +++ b/fuzz/fuzz_targets/hashes/sha1.rs @@ -1,4 +1,4 @@ -use bitcoin::hashes::{sha1, Hash, HashEngine}; +use bitcoin::hashes::{sha1, HashEngine}; use honggfuzz::fuzz; fn do_test(data: &[u8]) { diff --git a/fuzz/fuzz_targets/hashes/sha256.rs b/fuzz/fuzz_targets/hashes/sha256.rs index a81a31e9e..c2397f193 100644 --- a/fuzz/fuzz_targets/hashes/sha256.rs +++ b/fuzz/fuzz_targets/hashes/sha256.rs @@ -1,4 +1,4 @@ -use bitcoin::hashes::{sha256, Hash, HashEngine}; +use bitcoin::hashes::{sha256, HashEngine}; use honggfuzz::fuzz; fn do_test(data: &[u8]) { diff --git a/fuzz/fuzz_targets/hashes/sha512.rs b/fuzz/fuzz_targets/hashes/sha512.rs index b49ef7934..32b1d879b 100644 --- a/fuzz/fuzz_targets/hashes/sha512.rs +++ b/fuzz/fuzz_targets/hashes/sha512.rs @@ -1,4 +1,4 @@ -use bitcoin::hashes::{sha512, Hash, HashEngine}; +use bitcoin::hashes::{sha512, HashEngine}; use honggfuzz::fuzz; fn do_test(data: &[u8]) { diff --git a/fuzz/fuzz_targets/hashes/sha512_256.rs b/fuzz/fuzz_targets/hashes/sha512_256.rs index 30f09302d..44c90960d 100644 --- a/fuzz/fuzz_targets/hashes/sha512_256.rs +++ b/fuzz/fuzz_targets/hashes/sha512_256.rs @@ -1,4 +1,4 @@ -use bitcoin::hashes::{sha512_256, Hash, HashEngine}; +use bitcoin::hashes::{sha512_256, HashEngine}; use honggfuzz::fuzz; fn do_test(data: &[u8]) { diff --git a/hashes/src/hash160.rs b/hashes/src/hash160.rs index df1efc922..6f2da18fd 100644 --- a/hashes/src/hash160.rs +++ b/hashes/src/hash160.rs @@ -21,8 +21,6 @@ crate::internal_macros::hash_type! { type HashEngine = sha256::HashEngine; fn from_engine(e: HashEngine) -> Hash { - use crate::Hash as _; - let sha2 = sha256::Hash::from_engine(e); let rmd = ripemd160::Hash::hash(&sha2[..]); @@ -92,7 +90,7 @@ mod tests { fn ripemd_serde() { use serde_test::{assert_tokens, Configure, Token}; - use crate::{hash160, Hash}; + use crate::hash160; #[rustfmt::skip] static HASH_BYTES: [u8; 20] = [ diff --git a/hashes/src/internal_macros.rs b/hashes/src/internal_macros.rs index bbe40c0a4..2a52157ed 100644 --- a/hashes/src/internal_macros.rs +++ b/hashes/src/internal_macros.rs @@ -63,17 +63,14 @@ pub(crate) use arr_newtype_fmt_impl; /// /// * There must be a free-standing `fn from_engine(HashEngine) -> Hash` in the scope /// * `fn internal_new([u8; $bits / 8]) -> Self` must exist on `Hash` -/// * `fn internal_engine() -> HashEngine` must exist on `Hash` /// /// `from_engine` obviously implements the finalization algorithm. -/// `internal_new` is required so that types with more than one field are constructible. -/// `internal_engine` is required to initialize the engine for given hash type. macro_rules! hash_trait_impls { ($bits:expr, $reverse:expr $(, $gen:ident: $gent:ident)*) => { impl<$($gen: $gent),*> $crate::_export::_core::str::FromStr for Hash<$($gen),*> { type Err = $crate::hex::HexToArrayError; fn from_str(s: &str) -> $crate::_export::_core::result::Result { - use $crate::{Hash, hex::{FromHex}}; + use $crate::{hex::{FromHex}}; let mut bytes = <[u8; $bits / 8]>::from_hex(s)?; if $reverse { @@ -109,39 +106,21 @@ macro_rules! hash_trait_impls { const LEN: usize = $bits / 8; const DISPLAY_BACKWARD: bool = $reverse; - fn engine() -> Self::Engine { - Self::internal_engine() - } + fn engine() -> HashEngine { Self::engine() } - fn from_engine(e: HashEngine) -> Hash<$($gen),*> { - from_engine(e) - } + fn from_engine(e: HashEngine) -> Hash<$($gen),*> { Self::from_engine(e) } fn from_slice(sl: &[u8]) -> $crate::_export::_core::result::Result, FromSliceError> { - if sl.len() != $bits / 8 { - Err(FromSliceError{expected: Self::LEN, got: sl.len()}) - } else { - let mut ret = [0; $bits / 8]; - ret.copy_from_slice(sl); - Ok(Self::internal_new(ret)) - } + Self::from_slice(sl) } - fn to_byte_array(self) -> Self::Bytes { - self.0 - } + fn to_byte_array(self) -> Self::Bytes { self.to_byte_array() } - fn as_byte_array(&self) -> &Self::Bytes { - &self.0 - } + fn as_byte_array(&self) -> &Self::Bytes { self.as_byte_array() } - fn from_byte_array(bytes: Self::Bytes) -> Self { - Self::internal_new(bytes) - } + fn from_byte_array(bytes: Self::Bytes) -> Self { Self::from_byte_array(bytes) } - fn all_zeros() -> Self { - Hash::internal_new([0x00; $bits / 8]) - } + fn all_zeros() -> Self { Self::all_zeros() } } } } @@ -149,8 +128,8 @@ pub(crate) use hash_trait_impls; /// Creates a type called `Hash` and implements standard interface for it. /// -/// The created type will have all standard derives, `Hash` impl and implementation of -/// `internal_engine` returning default. The created type has a single field. +/// The created type has a single field and will have all standard derives as well as an +/// implementation of [`crate::Hash`]. /// /// Arguments: /// @@ -169,9 +148,7 @@ macro_rules! hash_type { pub struct Hash([u8; $bits / 8]); impl Hash { - fn internal_new(arr: [u8; $bits / 8]) -> Self { Hash(arr) } - - fn internal_engine() -> HashEngine { Default::default() } + const fn internal_new(arr: [u8; $bits / 8]) -> Self { Hash(arr) } /// Zero cost conversion between a fixed length byte array shared reference and /// a shared reference to this Hash type. @@ -186,6 +163,68 @@ macro_rules! hash_type { // Safety: Sound because Self is #[repr(transparent)] containing [u8; $bits / 8] unsafe { &mut *(bytes as *mut _ as *mut Self) } } + + /// Constructs a new engine. + pub fn engine() -> HashEngine { Default::default() } + + /// Produces a hash from the current state of a given engine. + pub fn from_engine(e: HashEngine) -> Hash { from_engine(e) } + + /// Copies a byte slice into a hash object. + pub fn from_slice(sl: &[u8]) -> $crate::_export::_core::result::Result { + if sl.len() != $bits / 8 { + Err(FromSliceError{expected: $bits / 8, got: sl.len()}) + } else { + let mut ret = [0; $bits / 8]; + ret.copy_from_slice(sl); + Ok(Self::internal_new(ret)) + } + } + + /// Hashes some bytes. + #[allow(clippy::self_named_constructors)] // Hash is a noun and a verb. + pub fn hash(data: &[u8]) -> Self { + use $crate::HashEngine; + + let mut engine = Self::engine(); + engine.input(data); + Self::from_engine(engine) + } + + /// Hashes all the byte slices retrieved from the iterator together. + pub fn hash_byte_chunks(byte_slices: I) -> Self + where + B: AsRef<[u8]>, + I: IntoIterator, + { + use $crate::HashEngine; + + let mut engine = Self::engine(); + for slice in byte_slices { + engine.input(slice.as_ref()); + } + Self::from_engine(engine) + } + + /// Returns the underlying byte array. + pub const fn to_byte_array(self) -> [u8; $bits / 8] { self.0 } + + /// Returns a reference to the underlying byte array. + pub const fn as_byte_array(&self) -> &[u8; $bits / 8] { &self.0 } + + /// Constructs a hash from the underlying byte array. + pub const fn from_byte_array(bytes: [u8; $bits / 8]) -> Self { + Self::internal_new(bytes) + } + + /// Returns an all zero hash. + /// + /// An all zeros hash is a made up construct because there is not a known input that can create + /// it, however it is used in various places in Bitcoin e.g., the Bitcoin genesis block's + /// previous blockhash and the coinbase transaction's outpoint txid. + pub const fn all_zeros() -> Self { + Hash::internal_new([0x00; $bits / 8]) + } } #[cfg(feature = "schemars")] diff --git a/hashes/src/lib.rs b/hashes/src/lib.rs index ae7c01a1b..df3325bd1 100644 --- a/hashes/src/lib.rs +++ b/hashes/src/lib.rs @@ -249,7 +249,7 @@ impl std::error::Error for FromSliceError {} #[cfg(test)] mod tests { - use crate::{sha256d, Hash}; + use crate::sha256d; hash_newtype! { /// A test newtype diff --git a/hashes/src/ripemd160.rs b/hashes/src/ripemd160.rs index 0a2b2d7cc..4ad076090 100644 --- a/hashes/src/ripemd160.rs +++ b/hashes/src/ripemd160.rs @@ -412,7 +412,7 @@ mod tests { fn test() { use std::convert::TryFrom; - use crate::{ripemd160, Hash, HashEngine}; + use crate::{ripemd160, HashEngine}; #[derive(Clone)] struct Test { @@ -507,7 +507,7 @@ mod tests { fn ripemd_serde() { use serde_test::{assert_tokens, Configure, Token}; - use crate::{ripemd160, Hash}; + use crate::ripemd160; #[rustfmt::skip] static HASH_BYTES: [u8; 20] = [ diff --git a/hashes/src/sha1.rs b/hashes/src/sha1.rs index c2584f9ca..221666301 100644 --- a/hashes/src/sha1.rs +++ b/hashes/src/sha1.rs @@ -129,7 +129,7 @@ mod tests { #[test] #[cfg(feature = "alloc")] fn test() { - use crate::{sha1, Hash, HashEngine}; + use crate::{sha1, HashEngine}; #[derive(Clone)] struct Test { @@ -199,7 +199,7 @@ mod tests { fn sha1_serde() { use serde_test::{assert_tokens, Configure, Token}; - use crate::{sha1, Hash}; + use crate::sha1; #[rustfmt::skip] static HASH_BYTES: [u8; 20] = [ diff --git a/hashes/src/sha256.rs b/hashes/src/sha256.rs index 8c26ff9ec..37be2ff8b 100644 --- a/hashes/src/sha256.rs +++ b/hashes/src/sha256.rs @@ -154,7 +154,7 @@ impl Midstate { } /// Unwraps the [`Midstate`] and returns the underlying byte array. - pub fn to_byte_array(self) -> [u8; 32] { self.0 } + pub const fn to_byte_array(self) -> [u8; 32] { self.0 } /// Creates midstate for tagged hashes. /// @@ -815,7 +815,7 @@ impl HashEngine { #[cfg(test)] mod tests { use super::*; - use crate::{sha256, Hash as _, HashEngine}; + use crate::{sha256, HashEngine}; #[test] #[cfg(feature = "alloc")] diff --git a/hashes/src/sha256d.rs b/hashes/src/sha256d.rs index 3d3ad5b9b..87a4cde35 100644 --- a/hashes/src/sha256d.rs +++ b/hashes/src/sha256d.rs @@ -16,8 +16,6 @@ crate::internal_macros::hash_type! { type HashEngine = sha256::HashEngine; fn from_engine(e: sha256::HashEngine) -> Hash { - use crate::Hash as _; - let sha2 = sha256::Hash::from_engine(e); let sha2d = sha256::Hash::hash(&sha2[..]); @@ -28,7 +26,7 @@ fn from_engine(e: sha256::HashEngine) -> Hash { #[cfg(test)] mod tests { - use crate::{sha256d, Hash as _}; + use crate::sha256d; #[test] #[cfg(feature = "alloc")] diff --git a/hashes/src/sha256t.rs b/hashes/src/sha256t.rs index b4be1db90..0678f3dab 100644 --- a/hashes/src/sha256t.rs +++ b/hashes/src/sha256t.rs @@ -7,7 +7,7 @@ use core::marker::PhantomData; use core::ops::Index; use core::slice::SliceIndex; -use crate::{sha256, FromSliceError}; +use crate::{sha256, FromSliceError, HashEngine as _}; type HashEngine = sha256::HashEngine; @@ -39,8 +39,6 @@ impl schemars::JsonSchema for Hash { impl Hash { fn internal_new(arr: [u8; 32]) -> Self { Hash(arr, Default::default()) } - fn internal_engine() -> HashEngine { T::engine() } - /// Zero cost conversion between a fixed length byte array shared reference and /// a shared reference to this Hash type. pub fn from_bytes_ref(bytes: &[u8; 32]) -> &Self { @@ -54,6 +52,68 @@ impl Hash { // Safety: Sound because Self is #[repr(transparent)] containing [u8; 32] unsafe { &mut *(bytes as *mut _ as *mut Self) } } + + /// Constructs a new engine. + pub fn engine() -> HashEngine { T::engine() } + + /// Produces a hash from the current state of a given engine. + pub fn from_engine(e: HashEngine) -> Hash { + from_engine(e) + } + + /// Copies a byte slice into a hash object. + pub fn from_slice(sl: &[u8]) -> Result, FromSliceError> { + if sl.len() != 32 { + Err(FromSliceError{expected: 32, got: sl.len()}) + } else { + let mut ret = [0; 32]; + ret.copy_from_slice(sl); + Ok(Self::internal_new(ret)) + } + } + + /// Hashes some bytes. + #[allow(clippy::self_named_constructors)] // Hash is a noun and a verb. + pub fn hash(data: &[u8]) -> Self { + use crate::HashEngine; + + let mut engine = Self::engine(); + engine.input(data); + Self::from_engine(engine) + } + + /// Hashes all the byte slices retrieved from the iterator together. + pub fn hash_byte_chunks(byte_slices: I) -> Self + where + B: AsRef<[u8]>, + I: IntoIterator, + { + let mut engine = Self::engine(); + for slice in byte_slices { + engine.input(slice.as_ref()); + } + Self::from_engine(engine) + } + + /// Returns the underlying byte array. + pub fn to_byte_array(self) -> [u8; 32] { self.0 } + + /// Returns a reference to the underlying byte array. + pub fn as_byte_array(&self) -> &[u8; 32] { &self.0 } + + /// Constructs a hash from the underlying byte array. + pub fn from_byte_array(bytes: [u8; 32]) -> Self { + Self::internal_new(bytes) + } + + /// Returns an all zero hash. + /// + /// An all zeros hash is a made up construct because there is not a known input that can create + /// it, however it is used in various places in Bitcoin e.g., the Bitcoin genesis block's + /// previous blockhash and the coinbase transaction's outpoint txid. + pub fn all_zeros() -> Self { + Hash::internal_new([0x00; 32]) + } } impl Copy for Hash {} @@ -82,8 +142,6 @@ impl core::hash::Hash for Hash { crate::internal_macros::hash_trait_impls!(256, false, T: Tag); fn from_engine(e: sha256::HashEngine) -> Hash { - use crate::Hash as _; - Hash::from_byte_array(sha256::Hash::from_engine(e).to_byte_array()) } @@ -176,8 +234,6 @@ macro_rules! sha256t_hash_newtype_tag_constructor { #[cfg(test)] mod tests { - #[cfg(feature = "alloc")] - use crate::Hash; use crate::{sha256, sha256t}; const TEST_MIDSTATE: [u8; 32] = [ diff --git a/hashes/src/sha384.rs b/hashes/src/sha384.rs index ce23c3118..ed675ce78 100644 --- a/hashes/src/sha384.rs +++ b/hashes/src/sha384.rs @@ -47,7 +47,7 @@ mod tests { #[test] #[cfg(feature = "alloc")] fn test() { - use crate::{sha384, Hash, HashEngine}; + use crate::{sha384, HashEngine}; #[derive(Clone)] struct Test { diff --git a/hashes/src/sha512.rs b/hashes/src/sha512.rs index 904bb4d65..fb3ab5433 100644 --- a/hashes/src/sha512.rs +++ b/hashes/src/sha512.rs @@ -307,7 +307,7 @@ mod tests { #[test] #[cfg(feature = "alloc")] fn test() { - use crate::{sha512, Hash, HashEngine}; + use crate::{sha512, HashEngine}; #[derive(Clone)] struct Test { @@ -386,7 +386,7 @@ mod tests { fn sha512_serde() { use serde_test::{assert_tokens, Configure, Token}; - use crate::{sha512, Hash}; + use crate::sha512; #[rustfmt::skip] static HASH_BYTES: [u8; 64] = [ diff --git a/hashes/src/sha512_256.rs b/hashes/src/sha512_256.rs index bcaee9216..73d871621 100644 --- a/hashes/src/sha512_256.rs +++ b/hashes/src/sha512_256.rs @@ -57,7 +57,7 @@ mod tests { #[test] #[cfg(feature = "alloc")] fn test() { - use crate::{sha512_256, Hash, HashEngine}; + use crate::{sha512_256, HashEngine}; #[derive(Clone)] struct Test { diff --git a/hashes/src/siphash24.rs b/hashes/src/siphash24.rs index 048ab94ff..ce45cbb37 100644 --- a/hashes/src/siphash24.rs +++ b/hashes/src/siphash24.rs @@ -6,7 +6,7 @@ use core::ops::Index; use core::slice::SliceIndex; use core::{cmp, mem, ptr}; -use crate::{FromSliceError, Hash as _, HashEngine as _}; +use crate::{FromSliceError, HashEngine as _}; crate::internal_macros::hash_type! { 64, diff --git a/hashes/src/util.rs b/hashes/src/util.rs index 79ac4d052..f778f098f 100644 --- a/hashes/src/util.rs +++ b/hashes/src/util.rs @@ -192,24 +192,88 @@ macro_rules! hash_newtype { $crate::serde_impl!($newtype, <$newtype as $crate::Hash>::LEN); $crate::borrow_slice_impl!($newtype); + #[allow(unused)] // Private wrapper types may not need all functions. impl $newtype { /// Creates this wrapper type from the inner hash type. - #[allow(unused)] // the user of macro may not need this pub fn from_raw_hash(inner: $hash) -> $newtype { $newtype(inner) } /// Returns the inner hash (sha256, sh256d etc.). - #[allow(unused)] // the user of macro may not need this pub fn to_raw_hash(self) -> $hash { self.0 } /// Returns a reference to the inner hash (sha256, sh256d etc.). - #[allow(unused)] // the user of macro may not need this pub fn as_raw_hash(&self) -> &$hash { &self.0 } + + /// Constructs a new engine. + pub fn engine() -> <$hash as $crate::Hash>::Engine { + <$hash as $crate::Hash>::engine() + } + + /// Produces a hash from the current state of a given engine. + pub fn from_engine(e: <$hash as $crate::Hash>::Engine) -> Self { + Self::from(<$hash as $crate::Hash>::from_engine(e)) + } + + /// Copies a byte slice into a hash object. + pub fn from_slice(sl: &[u8]) -> $crate::_export::_core::result::Result<$newtype, $crate::FromSliceError> { + Ok($newtype(<$hash as $crate::Hash>::from_slice(sl)?)) + } + + /// Hashes some bytes. + #[allow(unused)] // the user of macro may not need this + pub fn hash(data: &[u8]) -> Self { + use $crate::HashEngine; + + let mut engine = Self::engine(); + engine.input(data); + Self::from_engine(engine) + } + + /// Hashes all the byte slices retrieved from the iterator together. + pub fn hash_byte_chunks(byte_slices: I) -> Self + where + B: AsRef<[u8]>, + I: IntoIterator, + { + use $crate::HashEngine; + + let mut engine = Self::engine(); + for slice in byte_slices { + engine.input(slice.as_ref()); + } + Self::from_engine(engine) + } + + /// Returns the underlying byte array. + pub fn to_byte_array(self) -> <$hash as $crate::Hash>::Bytes { + self.0.to_byte_array() + } + + /// Returns a reference to the underlying byte array. + pub fn as_byte_array(&self) -> &<$hash as $crate::Hash>::Bytes { + self.0.as_byte_array() + } + + /// Constructs a hash from the underlying byte array. + pub fn from_byte_array(bytes: <$hash as $crate::Hash>::Bytes) -> Self { + $newtype(<$hash as $crate::Hash>::from_byte_array(bytes)) + } + + /// Returns an all zero hash. + /// + /// An all zeros hash is a made up construct because there is not a known input that can create + /// it, however it is used in various places in Bitcoin e.g., the Bitcoin genesis block's + /// previous blockhash and the coinbase transaction's outpoint txid. + pub fn all_zeros() -> Self { + let zeros = <$hash>::all_zeros(); + $newtype(zeros) + } + } impl $crate::_export::_core::convert::From<$hash> for $newtype { @@ -232,45 +296,27 @@ macro_rules! hash_newtype { const LEN: usize = <$hash as $crate::Hash>::LEN; const DISPLAY_BACKWARD: bool = $crate::hash_newtype_get_direction!($hash, $(#[$($type_attrs)*])*); - fn engine() -> Self::Engine { - <$hash as $crate::Hash>::engine() - } + fn engine() -> <$hash as $crate::Hash>::Engine { Self::engine() } - fn from_engine(e: Self::Engine) -> Self { - Self::from(<$hash as $crate::Hash>::from_engine(e)) - } + fn from_engine(e: <$hash as $crate::Hash>::Engine) -> $newtype { Self::from_engine(e) } - #[inline] fn from_slice(sl: &[u8]) -> $crate::_export::_core::result::Result<$newtype, $crate::FromSliceError> { - Ok($newtype(<$hash as $crate::Hash>::from_slice(sl)?)) + Self::from_slice(sl) } - #[inline] - fn from_byte_array(bytes: Self::Bytes) -> Self { - $newtype(<$hash as $crate::Hash>::from_byte_array(bytes)) - } + fn to_byte_array(self) -> Self::Bytes { self.to_byte_array() } - #[inline] - fn to_byte_array(self) -> Self::Bytes { - self.0.to_byte_array() - } + fn as_byte_array(&self) -> &Self::Bytes { self.as_byte_array() } - #[inline] - fn as_byte_array(&self) -> &Self::Bytes { - self.0.as_byte_array() - } + fn from_byte_array(bytes: Self::Bytes) -> Self { Self::from_byte_array(bytes) } - #[inline] - fn all_zeros() -> Self { - let zeros = <$hash>::all_zeros(); - $newtype(zeros) - } + fn all_zeros() -> Self { Self::all_zeros() } } impl $crate::_export::_core::str::FromStr for $newtype { type Err = $crate::hex::HexToArrayError; fn from_str(s: &str) -> $crate::_export::_core::result::Result<$newtype, Self::Err> { - use $crate::{Hash, hex::FromHex}; + use $crate::{hex::FromHex}; let mut bytes = <[u8; ::LEN]>::from_hex(s)?; if ::DISPLAY_BACKWARD { @@ -386,7 +432,7 @@ macro_rules! hash_newtype_known_attrs { #[cfg(test)] mod test { - use crate::{sha256, Hash}; + use crate::sha256; #[test] fn hash_as_ref_array() { From 18b2788a5ac8d052624cd23687d9628ecc557615 Mon Sep 17 00:00:00 2001 From: "Tobin C. Harding" Date: Fri, 14 Jun 2024 10:16:03 +1000 Subject: [PATCH 2/2] api: Run just check-api --- api/bitcoin/all-features.txt | 190 ++++++++++++++++++++++++------- api/bitcoin/default-features.txt | 190 ++++++++++++++++++++++++------- api/bitcoin/no-features.txt | 190 ++++++++++++++++++++++++------- api/hashes/all-features.txt | 81 +++++++++++-- api/hashes/alloc-only.txt | 81 +++++++++++-- api/hashes/no-features.txt | 81 +++++++++++-- 6 files changed, 666 insertions(+), 147 deletions(-) diff --git a/api/bitcoin/all-features.txt b/api/bitcoin/all-features.txt index d9ad3d9b6..7d4d4fa72 100644 --- a/api/bitcoin/all-features.txt +++ b/api/bitcoin/all-features.txt @@ -6876,6 +6876,7 @@ pub fn bitcoin::EcdsaSighashType::hash<__H: core::hash::Hasher>(&self, state: &m pub fn bitcoin::EcdsaSighashType::serialize(&self, serializer: S) -> core::result::Result<::Ok, ::Error> where S: serde::ser::Serializer pub fn bitcoin::EcdsaSighashType::to_u32(self) -> u32 pub fn bitcoin::LegacySighash::all_zeros() -> Self +pub fn bitcoin::LegacySighash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::LegacySighash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::LegacySighash::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::LegacySighash::as_ref(&self) -> &[u8; 32] @@ -6884,20 +6885,25 @@ pub fn bitcoin::LegacySighash::borrow(&self) -> &[u8] pub fn bitcoin::LegacySighash::clone(&self) -> bitcoin::LegacySighash pub fn bitcoin::LegacySighash::cmp(&self, other: &bitcoin::LegacySighash) -> core::cmp::Ordering pub fn bitcoin::LegacySighash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::LegacySighash::engine() -> Self::Engine +pub fn bitcoin::LegacySighash::engine() -> ::Engine pub fn bitcoin::LegacySighash::eq(&self, other: &bitcoin::LegacySighash) -> bool pub fn bitcoin::LegacySighash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::LegacySighash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::LegacySighash +pub fn bitcoin::LegacySighash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::LegacySighash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::LegacySighash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::LegacySighash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::LegacySighash::from_engine(e: ::Engine) -> bitcoin::LegacySighash pub fn bitcoin::LegacySighash::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::LegacySighash pub fn bitcoin::LegacySighash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::LegacySighash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::LegacySighash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::LegacySighash::hash(data: &[u8]) -> Self pub fn bitcoin::LegacySighash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::LegacySighash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::LegacySighash::index(&self, index: I) -> &Self::Output pub fn bitcoin::LegacySighash::partial_cmp(&self, other: &bitcoin::LegacySighash) -> core::option::Option pub fn bitcoin::LegacySighash::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::LegacySighash::to_byte_array(self) -> ::Bytes pub fn bitcoin::LegacySighash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::LegacySighash::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::MerkleBlock::clone(&self) -> bitcoin::MerkleBlock @@ -6925,6 +6931,7 @@ pub fn bitcoin::PrivateKey::serialize(&self, s: S) -> pub fn bitcoin::PrivateKey::to_bytes(self) -> alloc::vec::Vec pub fn bitcoin::PrivateKey::to_wif(self) -> alloc::string::String pub fn bitcoin::PubkeyHash::all_zeros() -> Self +pub fn bitcoin::PubkeyHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::PubkeyHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::PubkeyHash::as_raw_hash(&self) -> &bitcoin_hashes::hash160::Hash pub fn bitcoin::PubkeyHash::as_ref(&self) -> &[u8; 20] @@ -6934,7 +6941,7 @@ pub fn bitcoin::PubkeyHash::borrow(&self) -> &[u8] pub fn bitcoin::PubkeyHash::clone(&self) -> bitcoin::PubkeyHash pub fn bitcoin::PubkeyHash::cmp(&self, other: &bitcoin::PubkeyHash) -> core::cmp::Ordering pub fn bitcoin::PubkeyHash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::PubkeyHash::engine() -> Self::Engine +pub fn bitcoin::PubkeyHash::engine() -> ::Engine pub fn bitcoin::PubkeyHash::eq(&self, other: &bitcoin::PubkeyHash) -> bool pub fn bitcoin::PubkeyHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::PubkeyHash::from(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::PubkeyHash @@ -6942,16 +6949,21 @@ pub fn bitcoin::PubkeyHash::from(key: &bitcoin::CompressedPublicKey) -> Self pub fn bitcoin::PubkeyHash::from(key: &bitcoin::PublicKey) -> bitcoin::PubkeyHash pub fn bitcoin::PubkeyHash::from(key: bitcoin::CompressedPublicKey) -> Self pub fn bitcoin::PubkeyHash::from(key: bitcoin::PublicKey) -> bitcoin::PubkeyHash +pub fn bitcoin::PubkeyHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::PubkeyHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::PubkeyHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::PubkeyHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::PubkeyHash::from_engine(e: ::Engine) -> bitcoin::PubkeyHash pub fn bitcoin::PubkeyHash::from_raw_hash(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::PubkeyHash pub fn bitcoin::PubkeyHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::PubkeyHash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::PubkeyHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::PubkeyHash::hash(data: &[u8]) -> Self pub fn bitcoin::PubkeyHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::PubkeyHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::PubkeyHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::PubkeyHash::partial_cmp(&self, other: &bitcoin::PubkeyHash) -> core::option::Option pub fn bitcoin::PubkeyHash::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::PubkeyHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::PubkeyHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::PubkeyHash::to_raw_hash(self) -> bitcoin_hashes::hash160::Hash pub fn bitcoin::PublicKey::clone(&self) -> bitcoin::PublicKey @@ -6978,6 +6990,7 @@ pub fn bitcoin::PublicKey::verify(&self, se pub fn bitcoin::PublicKey::wpubkey_hash(&self) -> core::result::Result pub fn bitcoin::PublicKey::write_into(&self, writer: &mut W) -> core::result::Result<(), bitcoin_io::error::Error> pub fn bitcoin::SegwitV0Sighash::all_zeros() -> Self +pub fn bitcoin::SegwitV0Sighash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::SegwitV0Sighash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::SegwitV0Sighash::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::SegwitV0Sighash::as_ref(&self) -> &[u8; 32] @@ -6986,23 +6999,29 @@ pub fn bitcoin::SegwitV0Sighash::borrow(&self) -> &[u8] pub fn bitcoin::SegwitV0Sighash::clone(&self) -> bitcoin::SegwitV0Sighash pub fn bitcoin::SegwitV0Sighash::cmp(&self, other: &bitcoin::SegwitV0Sighash) -> core::cmp::Ordering pub fn bitcoin::SegwitV0Sighash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::SegwitV0Sighash::engine() -> Self::Engine +pub fn bitcoin::SegwitV0Sighash::engine() -> ::Engine pub fn bitcoin::SegwitV0Sighash::eq(&self, other: &bitcoin::SegwitV0Sighash) -> bool pub fn bitcoin::SegwitV0Sighash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::SegwitV0Sighash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::SegwitV0Sighash +pub fn bitcoin::SegwitV0Sighash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::SegwitV0Sighash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::SegwitV0Sighash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::SegwitV0Sighash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::SegwitV0Sighash::from_engine(e: ::Engine) -> bitcoin::SegwitV0Sighash pub fn bitcoin::SegwitV0Sighash::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::SegwitV0Sighash pub fn bitcoin::SegwitV0Sighash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::SegwitV0Sighash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::SegwitV0Sighash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::SegwitV0Sighash::hash(data: &[u8]) -> Self pub fn bitcoin::SegwitV0Sighash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::SegwitV0Sighash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::SegwitV0Sighash::index(&self, index: I) -> &Self::Output pub fn bitcoin::SegwitV0Sighash::partial_cmp(&self, other: &bitcoin::SegwitV0Sighash) -> core::option::Option pub fn bitcoin::SegwitV0Sighash::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::SegwitV0Sighash::to_byte_array(self) -> ::Bytes pub fn bitcoin::SegwitV0Sighash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::SegwitV0Sighash::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::TapSighash::all_zeros() -> Self +pub fn bitcoin::TapSighash::as_byte_array(&self) -> & as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::TapSighash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::TapSighash::as_raw_hash(&self) -> &bitcoin_hashes::sha256t::Hash pub fn bitcoin::TapSighash::as_ref(&self) -> &[u8; 32] @@ -7011,20 +7030,25 @@ pub fn bitcoin::TapSighash::borrow(&self) -> &[u8] pub fn bitcoin::TapSighash::clone(&self) -> bitcoin::TapSighash pub fn bitcoin::TapSighash::cmp(&self, other: &bitcoin::TapSighash) -> core::cmp::Ordering pub fn bitcoin::TapSighash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::TapSighash::engine() -> Self::Engine +pub fn bitcoin::TapSighash::engine() -> as bitcoin_hashes::Hash>::Engine pub fn bitcoin::TapSighash::eq(&self, other: &bitcoin::TapSighash) -> bool pub fn bitcoin::TapSighash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::TapSighash::from(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::TapSighash +pub fn bitcoin::TapSighash::from_byte_array(bytes: as bitcoin_hashes::Hash>::Bytes) -> Self pub fn bitcoin::TapSighash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::TapSighash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::TapSighash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> Self +pub fn bitcoin::TapSighash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> bitcoin::TapSighash pub fn bitcoin::TapSighash::from_raw_hash(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::TapSighash pub fn bitcoin::TapSighash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::TapSighash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::TapSighash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::TapSighash::hash(data: &[u8]) -> Self pub fn bitcoin::TapSighash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::TapSighash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::TapSighash::index(&self, index: I) -> &Self::Output pub fn bitcoin::TapSighash::partial_cmp(&self, other: &bitcoin::TapSighash) -> core::option::Option pub fn bitcoin::TapSighash::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::TapSighash::to_byte_array(self) -> as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::TapSighash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::TapSighash::to_raw_hash(self) -> bitcoin_hashes::sha256t::Hash pub fn bitcoin::TapSighashTag::clone(&self) -> bitcoin::TapSighashTag @@ -7046,6 +7070,7 @@ pub fn bitcoin::TapSighashType::hash<__H: core::hash::Hasher>(&self, state: &mut pub fn bitcoin::TapSighashType::partial_cmp(&self, other: &bitcoin::TapSighashType) -> core::option::Option pub fn bitcoin::TapSighashType::serialize(&self, serializer: S) -> core::result::Result<::Ok, ::Error> where S: serde::ser::Serializer pub fn bitcoin::WPubkeyHash::all_zeros() -> Self +pub fn bitcoin::WPubkeyHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::WPubkeyHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::WPubkeyHash::as_raw_hash(&self) -> &bitcoin_hashes::hash160::Hash pub fn bitcoin::WPubkeyHash::as_ref(&self) -> &[u8; 20] @@ -7055,22 +7080,27 @@ pub fn bitcoin::WPubkeyHash::borrow(&self) -> &[u8] pub fn bitcoin::WPubkeyHash::clone(&self) -> bitcoin::WPubkeyHash pub fn bitcoin::WPubkeyHash::cmp(&self, other: &bitcoin::WPubkeyHash) -> core::cmp::Ordering pub fn bitcoin::WPubkeyHash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::WPubkeyHash::engine() -> Self::Engine +pub fn bitcoin::WPubkeyHash::engine() -> ::Engine pub fn bitcoin::WPubkeyHash::eq(&self, other: &bitcoin::WPubkeyHash) -> bool pub fn bitcoin::WPubkeyHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::WPubkeyHash::from(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::WPubkeyHash pub fn bitcoin::WPubkeyHash::from(key: &bitcoin::CompressedPublicKey) -> Self pub fn bitcoin::WPubkeyHash::from(key: bitcoin::CompressedPublicKey) -> Self +pub fn bitcoin::WPubkeyHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::WPubkeyHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::WPubkeyHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::WPubkeyHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::WPubkeyHash::from_engine(e: ::Engine) -> bitcoin::WPubkeyHash pub fn bitcoin::WPubkeyHash::from_raw_hash(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::WPubkeyHash pub fn bitcoin::WPubkeyHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::WPubkeyHash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::WPubkeyHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::WPubkeyHash::hash(data: &[u8]) -> Self pub fn bitcoin::WPubkeyHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::WPubkeyHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::WPubkeyHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::WPubkeyHash::partial_cmp(&self, other: &bitcoin::WPubkeyHash) -> core::option::Option pub fn bitcoin::WPubkeyHash::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::WPubkeyHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::WPubkeyHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::WPubkeyHash::to_raw_hash(self) -> bitcoin_hashes::hash160::Hash pub fn bitcoin::address::Address::address_type(&self) -> core::option::Option @@ -7299,6 +7329,7 @@ pub fn bitcoin::bip158::Error::from(io: bitcoin_io::error::Error) -> Self pub fn bitcoin::bip158::Error::from(never: core::convert::Infallible) -> Self pub fn bitcoin::bip158::Error::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> pub fn bitcoin::bip158::FilterHash::all_zeros() -> Self +pub fn bitcoin::bip158::FilterHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::bip158::FilterHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::bip158::FilterHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::bip158::FilterHash::as_ref(&self) -> &[u8; 32] @@ -7309,24 +7340,30 @@ pub fn bitcoin::bip158::FilterHash::cmp(&self, other: &bitcoin::bip158::FilterHa pub fn bitcoin::bip158::FilterHash::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::bip158::FilterHash::consensus_encode(&self, w: &mut W) -> core::result::Result pub fn bitcoin::bip158::FilterHash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::bip158::FilterHash::engine() -> Self::Engine +pub fn bitcoin::bip158::FilterHash::engine() -> ::Engine pub fn bitcoin::bip158::FilterHash::eq(&self, other: &bitcoin::bip158::FilterHash) -> bool pub fn bitcoin::bip158::FilterHash::filter_header(&self, previous_filter_header: &bitcoin::bip158::FilterHeader) -> bitcoin::bip158::FilterHeader pub fn bitcoin::bip158::FilterHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::bip158::FilterHash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::bip158::FilterHash +pub fn bitcoin::bip158::FilterHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::bip158::FilterHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::bip158::FilterHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::bip158::FilterHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::bip158::FilterHash::from_engine(e: ::Engine) -> bitcoin::bip158::FilterHash pub fn bitcoin::bip158::FilterHash::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::bip158::FilterHash pub fn bitcoin::bip158::FilterHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::bip158::FilterHash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::bip158::FilterHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::bip158::FilterHash::hash(data: &[u8]) -> Self pub fn bitcoin::bip158::FilterHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::bip158::FilterHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::bip158::FilterHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::bip158::FilterHash::partial_cmp(&self, other: &bitcoin::bip158::FilterHash) -> core::option::Option pub fn bitcoin::bip158::FilterHash::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::bip158::FilterHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::bip158::FilterHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::bip158::FilterHash::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::bip158::FilterHeader::all_zeros() -> Self +pub fn bitcoin::bip158::FilterHeader::as_byte_array(&self) -> &::Bytes pub fn bitcoin::bip158::FilterHeader::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::bip158::FilterHeader::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::bip158::FilterHeader::as_ref(&self) -> &[u8; 32] @@ -7337,20 +7374,25 @@ pub fn bitcoin::bip158::FilterHeader::cmp(&self, other: &bitcoin::bip158::Filter pub fn bitcoin::bip158::FilterHeader::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::bip158::FilterHeader::consensus_encode(&self, w: &mut W) -> core::result::Result pub fn bitcoin::bip158::FilterHeader::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::bip158::FilterHeader::engine() -> Self::Engine +pub fn bitcoin::bip158::FilterHeader::engine() -> ::Engine pub fn bitcoin::bip158::FilterHeader::eq(&self, other: &bitcoin::bip158::FilterHeader) -> bool pub fn bitcoin::bip158::FilterHeader::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::bip158::FilterHeader::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::bip158::FilterHeader +pub fn bitcoin::bip158::FilterHeader::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::bip158::FilterHeader::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::bip158::FilterHeader::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::bip158::FilterHeader::from_engine(e: ::Engine) -> Self +pub fn bitcoin::bip158::FilterHeader::from_engine(e: ::Engine) -> bitcoin::bip158::FilterHeader pub fn bitcoin::bip158::FilterHeader::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::bip158::FilterHeader pub fn bitcoin::bip158::FilterHeader::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::bip158::FilterHeader::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::bip158::FilterHeader::from_str(s: &str) -> core::result::Result +pub fn bitcoin::bip158::FilterHeader::hash(data: &[u8]) -> Self pub fn bitcoin::bip158::FilterHeader::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::bip158::FilterHeader::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::bip158::FilterHeader::index(&self, index: I) -> &Self::Output pub fn bitcoin::bip158::FilterHeader::partial_cmp(&self, other: &bitcoin::bip158::FilterHeader) -> core::option::Option pub fn bitcoin::bip158::FilterHeader::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::bip158::FilterHeader::to_byte_array(self) -> ::Bytes pub fn bitcoin::bip158::FilterHeader::to_byte_array(self) -> Self::Bytes pub fn bitcoin::bip158::FilterHeader::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::bip158::GcsFilterReader::match_all(&self, reader: &mut R, query: I) -> core::result::Result where I: core::iter::traits::iterator::Iterator, ::Item: core::borrow::Borrow<[u8]>, R: bitcoin_io::BufRead + core::marker::Sized @@ -7478,6 +7520,7 @@ pub fn bitcoin::bip32::InvalidBase58PayloadLengthError::eq(&self, other: &bitcoi pub fn bitcoin::bip32::InvalidBase58PayloadLengthError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::bip32::InvalidBase58PayloadLengthError::invalid_base58_payload_length(&self) -> usize pub fn bitcoin::bip32::XKeyIdentifier::all_zeros() -> Self +pub fn bitcoin::bip32::XKeyIdentifier::as_byte_array(&self) -> &::Bytes pub fn bitcoin::bip32::XKeyIdentifier::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::bip32::XKeyIdentifier::as_raw_hash(&self) -> &bitcoin_hashes::hash160::Hash pub fn bitcoin::bip32::XKeyIdentifier::as_ref(&self) -> &[u8; 20] @@ -7486,22 +7529,27 @@ pub fn bitcoin::bip32::XKeyIdentifier::borrow(&self) -> &[u8] pub fn bitcoin::bip32::XKeyIdentifier::clone(&self) -> bitcoin::bip32::XKeyIdentifier pub fn bitcoin::bip32::XKeyIdentifier::cmp(&self, other: &bitcoin::bip32::XKeyIdentifier) -> core::cmp::Ordering pub fn bitcoin::bip32::XKeyIdentifier::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::bip32::XKeyIdentifier::engine() -> Self::Engine +pub fn bitcoin::bip32::XKeyIdentifier::engine() -> ::Engine pub fn bitcoin::bip32::XKeyIdentifier::eq(&self, other: &bitcoin::bip32::XKeyIdentifier) -> bool pub fn bitcoin::bip32::XKeyIdentifier::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::bip32::XKeyIdentifier::from(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::bip32::XKeyIdentifier pub fn bitcoin::bip32::XKeyIdentifier::from(key: &bitcoin::bip32::Xpub) -> bitcoin::bip32::XKeyIdentifier pub fn bitcoin::bip32::XKeyIdentifier::from(key: bitcoin::bip32::Xpub) -> bitcoin::bip32::XKeyIdentifier +pub fn bitcoin::bip32::XKeyIdentifier::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::bip32::XKeyIdentifier::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::bip32::XKeyIdentifier::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::bip32::XKeyIdentifier::from_engine(e: ::Engine) -> Self +pub fn bitcoin::bip32::XKeyIdentifier::from_engine(e: ::Engine) -> bitcoin::bip32::XKeyIdentifier pub fn bitcoin::bip32::XKeyIdentifier::from_raw_hash(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::bip32::XKeyIdentifier pub fn bitcoin::bip32::XKeyIdentifier::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::bip32::XKeyIdentifier::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::bip32::XKeyIdentifier::from_str(s: &str) -> core::result::Result +pub fn bitcoin::bip32::XKeyIdentifier::hash(data: &[u8]) -> Self pub fn bitcoin::bip32::XKeyIdentifier::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::bip32::XKeyIdentifier::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::bip32::XKeyIdentifier::index(&self, index: I) -> &Self::Output pub fn bitcoin::bip32::XKeyIdentifier::partial_cmp(&self, other: &bitcoin::bip32::XKeyIdentifier) -> core::option::Option pub fn bitcoin::bip32::XKeyIdentifier::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::bip32::XKeyIdentifier::to_byte_array(self) -> ::Bytes pub fn bitcoin::bip32::XKeyIdentifier::to_byte_array(self) -> Self::Bytes pub fn bitcoin::bip32::XKeyIdentifier::to_raw_hash(self) -> bitcoin_hashes::hash160::Hash pub fn bitcoin::bip32::Xpriv::clone(&self) -> bitcoin::bip32::Xpriv @@ -7564,6 +7612,7 @@ pub fn bitcoin::blockdata::block::Block::total_size(&self) -> usize pub fn bitcoin::blockdata::block::Block::weight(&self) -> bitcoin_units::weight::Weight pub fn bitcoin::blockdata::block::Block::witness_root(&self) -> core::option::Option pub fn bitcoin::blockdata::block::BlockHash::all_zeros() -> Self +pub fn bitcoin::blockdata::block::BlockHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::block::BlockHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::block::BlockHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::BlockHash::as_ref(&self) -> &[u8; 32] @@ -7574,7 +7623,7 @@ pub fn bitcoin::blockdata::block::BlockHash::cmp(&self, other: &bitcoin::blockda pub fn bitcoin::blockdata::block::BlockHash::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::blockdata::block::BlockHash::consensus_encode(&self, w: &mut W) -> core::result::Result pub fn bitcoin::blockdata::block::BlockHash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::blockdata::block::BlockHash::engine() -> Self::Engine +pub fn bitcoin::blockdata::block::BlockHash::engine() -> ::Engine pub fn bitcoin::blockdata::block::BlockHash::eq(&self, other: &bitcoin::blockdata::block::BlockHash) -> bool pub fn bitcoin::blockdata::block::BlockHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::block::BlockHash::from(block: &bitcoin::blockdata::block::Block) -> bitcoin::blockdata::block::BlockHash @@ -7582,16 +7631,21 @@ pub fn bitcoin::blockdata::block::BlockHash::from(block: bitcoin::blockdata::blo pub fn bitcoin::blockdata::block::BlockHash::from(header: &bitcoin::blockdata::block::Header) -> bitcoin::blockdata::block::BlockHash pub fn bitcoin::blockdata::block::BlockHash::from(header: bitcoin::blockdata::block::Header) -> bitcoin::blockdata::block::BlockHash pub fn bitcoin::blockdata::block::BlockHash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::BlockHash +pub fn bitcoin::blockdata::block::BlockHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::block::BlockHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::block::BlockHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::block::BlockHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::block::BlockHash::from_engine(e: ::Engine) -> bitcoin::blockdata::block::BlockHash pub fn bitcoin::blockdata::block::BlockHash::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::BlockHash pub fn bitcoin::blockdata::block::BlockHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::block::BlockHash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::block::BlockHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::block::BlockHash::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::block::BlockHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::block::BlockHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::block::BlockHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::block::BlockHash::partial_cmp(&self, other: &bitcoin::blockdata::block::BlockHash) -> core::option::Option pub fn bitcoin::blockdata::block::BlockHash::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::blockdata::block::BlockHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::block::BlockHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::block::BlockHash::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::Header::block_hash(&self) -> bitcoin::blockdata::block::BlockHash @@ -7612,6 +7666,7 @@ pub fn bitcoin::blockdata::block::Header::target(&self) -> bitcoin::pow::Target pub fn bitcoin::blockdata::block::Header::validate_pow(&self, required_target: bitcoin::pow::Target) -> core::result::Result pub fn bitcoin::blockdata::block::Header::work(&self) -> bitcoin::pow::Work pub fn bitcoin::blockdata::block::TxMerkleNode::all_zeros() -> Self +pub fn bitcoin::blockdata::block::TxMerkleNode::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::block::TxMerkleNode::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::block::TxMerkleNode::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::TxMerkleNode::as_ref(&self) -> &[u8; 32] @@ -7622,21 +7677,26 @@ pub fn bitcoin::blockdata::block::TxMerkleNode::cmp(&self, other: &bitcoin::bloc pub fn bitcoin::blockdata::block::TxMerkleNode::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::blockdata::block::TxMerkleNode::consensus_encode(&self, w: &mut W) -> core::result::Result pub fn bitcoin::blockdata::block::TxMerkleNode::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::blockdata::block::TxMerkleNode::engine() -> Self::Engine +pub fn bitcoin::blockdata::block::TxMerkleNode::engine() -> ::Engine pub fn bitcoin::blockdata::block::TxMerkleNode::eq(&self, other: &bitcoin::blockdata::block::TxMerkleNode) -> bool pub fn bitcoin::blockdata::block::TxMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::block::TxMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::TxMerkleNode pub fn bitcoin::blockdata::block::TxMerkleNode::from(txid: bitcoin::blockdata::transaction::Txid) -> Self +pub fn bitcoin::blockdata::block::TxMerkleNode::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::block::TxMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::block::TxMerkleNode::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::block::TxMerkleNode::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::block::TxMerkleNode::from_engine(e: ::Engine) -> bitcoin::blockdata::block::TxMerkleNode pub fn bitcoin::blockdata::block::TxMerkleNode::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::TxMerkleNode pub fn bitcoin::blockdata::block::TxMerkleNode::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::block::TxMerkleNode::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::block::TxMerkleNode::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::block::TxMerkleNode::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::block::TxMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::block::TxMerkleNode::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::block::TxMerkleNode::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::block::TxMerkleNode::partial_cmp(&self, other: &bitcoin::blockdata::block::TxMerkleNode) -> core::option::Option pub fn bitcoin::blockdata::block::TxMerkleNode::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::blockdata::block::TxMerkleNode::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::block::TxMerkleNode::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::block::TxMerkleNode::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::ValidationError::clone(&self) -> bitcoin::blockdata::block::ValidationError @@ -7658,6 +7718,7 @@ pub fn bitcoin::blockdata::block::Version::partial_cmp(&self, other: &bitcoin::b pub fn bitcoin::blockdata::block::Version::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer pub fn bitcoin::blockdata::block::Version::to_consensus(self) -> i32 pub fn bitcoin::blockdata::block::WitnessCommitment::all_zeros() -> Self +pub fn bitcoin::blockdata::block::WitnessCommitment::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::block::WitnessCommitment::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::block::WitnessCommitment::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::WitnessCommitment::as_ref(&self) -> &[u8; 32] @@ -7666,23 +7727,29 @@ pub fn bitcoin::blockdata::block::WitnessCommitment::borrow(&self) -> &[u8] pub fn bitcoin::blockdata::block::WitnessCommitment::clone(&self) -> bitcoin::blockdata::block::WitnessCommitment pub fn bitcoin::blockdata::block::WitnessCommitment::cmp(&self, other: &bitcoin::blockdata::block::WitnessCommitment) -> core::cmp::Ordering pub fn bitcoin::blockdata::block::WitnessCommitment::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::blockdata::block::WitnessCommitment::engine() -> Self::Engine +pub fn bitcoin::blockdata::block::WitnessCommitment::engine() -> ::Engine pub fn bitcoin::blockdata::block::WitnessCommitment::eq(&self, other: &bitcoin::blockdata::block::WitnessCommitment) -> bool pub fn bitcoin::blockdata::block::WitnessCommitment::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::block::WitnessCommitment::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::WitnessCommitment +pub fn bitcoin::blockdata::block::WitnessCommitment::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::block::WitnessCommitment::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::block::WitnessCommitment::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::block::WitnessCommitment::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::block::WitnessCommitment::from_engine(e: ::Engine) -> bitcoin::blockdata::block::WitnessCommitment pub fn bitcoin::blockdata::block::WitnessCommitment::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::WitnessCommitment pub fn bitcoin::blockdata::block::WitnessCommitment::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::block::WitnessCommitment::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::block::WitnessCommitment::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::block::WitnessCommitment::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::block::WitnessCommitment::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::block::WitnessCommitment::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::block::WitnessCommitment::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::block::WitnessCommitment::partial_cmp(&self, other: &bitcoin::blockdata::block::WitnessCommitment) -> core::option::Option pub fn bitcoin::blockdata::block::WitnessCommitment::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::blockdata::block::WitnessCommitment::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::block::WitnessCommitment::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::block::WitnessCommitment::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::WitnessMerkleNode::all_zeros() -> Self +pub fn bitcoin::blockdata::block::WitnessMerkleNode::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::block::WitnessMerkleNode::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::block::WitnessMerkleNode::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::WitnessMerkleNode::as_ref(&self) -> &[u8; 32] @@ -7693,21 +7760,26 @@ pub fn bitcoin::blockdata::block::WitnessMerkleNode::cmp(&self, other: &bitcoin: pub fn bitcoin::blockdata::block::WitnessMerkleNode::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::blockdata::block::WitnessMerkleNode::consensus_encode(&self, w: &mut W) -> core::result::Result pub fn bitcoin::blockdata::block::WitnessMerkleNode::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::blockdata::block::WitnessMerkleNode::engine() -> Self::Engine +pub fn bitcoin::blockdata::block::WitnessMerkleNode::engine() -> ::Engine pub fn bitcoin::blockdata::block::WitnessMerkleNode::eq(&self, other: &bitcoin::blockdata::block::WitnessMerkleNode) -> bool pub fn bitcoin::blockdata::block::WitnessMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::block::WitnessMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::WitnessMerkleNode pub fn bitcoin::blockdata::block::WitnessMerkleNode::from(wtxid: bitcoin::blockdata::transaction::Wtxid) -> Self +pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_engine(e: ::Engine) -> bitcoin::blockdata::block::WitnessMerkleNode pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::WitnessMerkleNode pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::block::WitnessMerkleNode::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::block::WitnessMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::block::WitnessMerkleNode::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::block::WitnessMerkleNode::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::block::WitnessMerkleNode::partial_cmp(&self, other: &bitcoin::blockdata::block::WitnessMerkleNode) -> core::option::Option pub fn bitcoin::blockdata::block::WitnessMerkleNode::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::blockdata::block::WitnessMerkleNode::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::block::WitnessMerkleNode::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::block::WitnessMerkleNode::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::constants::ChainHash::as_byte_array(&self) -> &[u8; 32] @@ -8191,6 +8263,7 @@ pub fn bitcoin::blockdata::script::ScriptBuf::scan_and_push_verify(&mut self) pub fn bitcoin::blockdata::script::ScriptBuf::serialize(&self, serializer: S) -> core::result::Result<::Ok, ::Error> where S: serde::ser::Serializer pub fn bitcoin::blockdata::script::ScriptBuf::with_capacity(capacity: usize) -> Self pub fn bitcoin::blockdata::script::ScriptHash::all_zeros() -> Self +pub fn bitcoin::blockdata::script::ScriptHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::script::ScriptHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::script::ScriptHash::as_raw_hash(&self) -> &bitcoin_hashes::hash160::Hash pub fn bitcoin::blockdata::script::ScriptHash::as_ref(&self) -> &[u8; 20] @@ -8200,26 +8273,32 @@ pub fn bitcoin::blockdata::script::ScriptHash::borrow(&self) -> &[u8] pub fn bitcoin::blockdata::script::ScriptHash::clone(&self) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::cmp(&self, other: &bitcoin::blockdata::script::ScriptHash) -> core::cmp::Ordering pub fn bitcoin::blockdata::script::ScriptHash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::blockdata::script::ScriptHash::engine() -> Self::Engine +pub fn bitcoin::blockdata::script::ScriptHash::engine() -> ::Engine pub fn bitcoin::blockdata::script::ScriptHash::eq(&self, other: &bitcoin::blockdata::script::ScriptHash) -> bool pub fn bitcoin::blockdata::script::ScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::script::ScriptHash::from(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::from(script: &bitcoin::blockdata::script::Script) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::from(script: &bitcoin::blockdata::script::ScriptBuf) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::from(script: bitcoin::blockdata::script::ScriptBuf) -> bitcoin::blockdata::script::ScriptHash +pub fn bitcoin::blockdata::script::ScriptHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::script::ScriptHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::script::ScriptHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::script::ScriptHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::script::ScriptHash::from_engine(e: ::Engine) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::from_raw_hash(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::script::ScriptHash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::script::ScriptHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::script::ScriptHash::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::script::ScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::script::ScriptHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::script::ScriptHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::script::ScriptHash::partial_cmp(&self, other: &bitcoin::blockdata::script::ScriptHash) -> core::option::Option pub fn bitcoin::blockdata::script::ScriptHash::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::blockdata::script::ScriptHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::script::ScriptHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::script::ScriptHash::to_raw_hash(self) -> bitcoin_hashes::hash160::Hash pub fn bitcoin::blockdata::script::WScriptHash::all_zeros() -> Self +pub fn bitcoin::blockdata::script::WScriptHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::script::WScriptHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::script::WScriptHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256::Hash pub fn bitcoin::blockdata::script::WScriptHash::as_ref(&self) -> &[u8; 32] @@ -8229,23 +8308,28 @@ pub fn bitcoin::blockdata::script::WScriptHash::borrow(&self) -> &[u8] pub fn bitcoin::blockdata::script::WScriptHash::clone(&self) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::cmp(&self, other: &bitcoin::blockdata::script::WScriptHash) -> core::cmp::Ordering pub fn bitcoin::blockdata::script::WScriptHash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::blockdata::script::WScriptHash::engine() -> Self::Engine +pub fn bitcoin::blockdata::script::WScriptHash::engine() -> ::Engine pub fn bitcoin::blockdata::script::WScriptHash::eq(&self, other: &bitcoin::blockdata::script::WScriptHash) -> bool pub fn bitcoin::blockdata::script::WScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::script::WScriptHash::from(inner: bitcoin_hashes::sha256::Hash) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::from(script: &bitcoin::blockdata::script::Script) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::from(script: &bitcoin::blockdata::script::ScriptBuf) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::from(script: bitcoin::blockdata::script::ScriptBuf) -> bitcoin::blockdata::script::WScriptHash +pub fn bitcoin::blockdata::script::WScriptHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::script::WScriptHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::script::WScriptHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::script::WScriptHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::script::WScriptHash::from_engine(e: ::Engine) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::from_raw_hash(inner: bitcoin_hashes::sha256::Hash) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::script::WScriptHash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::script::WScriptHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::script::WScriptHash::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::script::WScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::script::WScriptHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::script::WScriptHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::script::WScriptHash::partial_cmp(&self, other: &bitcoin::blockdata::script::WScriptHash) -> core::option::Option pub fn bitcoin::blockdata::script::WScriptHash::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::blockdata::script::WScriptHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::script::WScriptHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::script::WScriptHash::to_raw_hash(self) -> bitcoin_hashes::sha256::Hash pub fn bitcoin::blockdata::script::read_scriptbool(v: &[u8]) -> bool @@ -8431,6 +8515,7 @@ pub fn bitcoin::blockdata::transaction::TxOut::serialize<__S>(&self, __serialize pub fn bitcoin::blockdata::transaction::TxOut::size(&self) -> usize pub fn bitcoin::blockdata::transaction::TxOut::weight(&self) -> bitcoin_units::weight::Weight pub fn bitcoin::blockdata::transaction::Txid::all_zeros() -> Self +pub fn bitcoin::blockdata::transaction::Txid::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::transaction::Txid::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::transaction::Txid::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::transaction::Txid::as_ref(&self) -> &[u8; 32] @@ -8441,22 +8526,27 @@ pub fn bitcoin::blockdata::transaction::Txid::cmp(&self, other: &bitcoin::blockd pub fn bitcoin::blockdata::transaction::Txid::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::blockdata::transaction::Txid::consensus_encode(&self, w: &mut W) -> core::result::Result pub fn bitcoin::blockdata::transaction::Txid::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::blockdata::transaction::Txid::engine() -> Self::Engine +pub fn bitcoin::blockdata::transaction::Txid::engine() -> ::Engine pub fn bitcoin::blockdata::transaction::Txid::eq(&self, other: &bitcoin::blockdata::transaction::Txid) -> bool pub fn bitcoin::blockdata::transaction::Txid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::transaction::Txid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::transaction::Txid pub fn bitcoin::blockdata::transaction::Txid::from(tx: &bitcoin::blockdata::transaction::Transaction) -> bitcoin::blockdata::transaction::Txid pub fn bitcoin::blockdata::transaction::Txid::from(tx: bitcoin::blockdata::transaction::Transaction) -> bitcoin::blockdata::transaction::Txid +pub fn bitcoin::blockdata::transaction::Txid::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::transaction::Txid::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::transaction::Txid::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::transaction::Txid::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::transaction::Txid::from_engine(e: ::Engine) -> bitcoin::blockdata::transaction::Txid pub fn bitcoin::blockdata::transaction::Txid::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::transaction::Txid pub fn bitcoin::blockdata::transaction::Txid::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::transaction::Txid::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::transaction::Txid::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::transaction::Txid::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::transaction::Txid::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::transaction::Txid::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::transaction::Txid::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::transaction::Txid::partial_cmp(&self, other: &bitcoin::blockdata::transaction::Txid) -> core::option::Option pub fn bitcoin::blockdata::transaction::Txid::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::blockdata::transaction::Txid::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::transaction::Txid::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::transaction::Txid::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::transaction::Version::clone(&self) -> bitcoin::blockdata::transaction::Version @@ -8472,6 +8562,7 @@ pub fn bitcoin::blockdata::transaction::Version::non_standard(version: i32) -> b pub fn bitcoin::blockdata::transaction::Version::partial_cmp(&self, other: &bitcoin::blockdata::transaction::Version) -> core::option::Option pub fn bitcoin::blockdata::transaction::Version::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer pub fn bitcoin::blockdata::transaction::Wtxid::all_zeros() -> Self +pub fn bitcoin::blockdata::transaction::Wtxid::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::transaction::Wtxid::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::transaction::Wtxid::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::transaction::Wtxid::as_ref(&self) -> &[u8; 32] @@ -8482,22 +8573,27 @@ pub fn bitcoin::blockdata::transaction::Wtxid::cmp(&self, other: &bitcoin::block pub fn bitcoin::blockdata::transaction::Wtxid::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::blockdata::transaction::Wtxid::consensus_encode(&self, w: &mut W) -> core::result::Result pub fn bitcoin::blockdata::transaction::Wtxid::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::blockdata::transaction::Wtxid::engine() -> Self::Engine +pub fn bitcoin::blockdata::transaction::Wtxid::engine() -> ::Engine pub fn bitcoin::blockdata::transaction::Wtxid::eq(&self, other: &bitcoin::blockdata::transaction::Wtxid) -> bool pub fn bitcoin::blockdata::transaction::Wtxid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::transaction::Wtxid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::transaction::Wtxid pub fn bitcoin::blockdata::transaction::Wtxid::from(tx: &bitcoin::blockdata::transaction::Transaction) -> bitcoin::blockdata::transaction::Wtxid pub fn bitcoin::blockdata::transaction::Wtxid::from(tx: bitcoin::blockdata::transaction::Transaction) -> bitcoin::blockdata::transaction::Wtxid +pub fn bitcoin::blockdata::transaction::Wtxid::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::transaction::Wtxid::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::transaction::Wtxid::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::transaction::Wtxid::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::transaction::Wtxid::from_engine(e: ::Engine) -> bitcoin::blockdata::transaction::Wtxid pub fn bitcoin::blockdata::transaction::Wtxid::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::transaction::Wtxid pub fn bitcoin::blockdata::transaction::Wtxid::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::transaction::Wtxid::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::transaction::Wtxid::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::transaction::Wtxid::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::transaction::Wtxid::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::transaction::Wtxid::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::transaction::Wtxid::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::transaction::Wtxid::partial_cmp(&self, other: &bitcoin::blockdata::transaction::Wtxid) -> core::option::Option pub fn bitcoin::blockdata::transaction::Wtxid::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::blockdata::transaction::Wtxid::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::transaction::Wtxid::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::transaction::Wtxid::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::transaction::effective_value(fee_rate: bitcoin_units::fee_rate::FeeRate, satisfaction_weight: bitcoin_units::weight::Weight, value: bitcoin_units::amount::Amount) -> core::option::Option @@ -9501,6 +9597,7 @@ pub fn bitcoin::taproot::TapLeaf::hash<__H: core::hash::Hasher>(&self, state: &m pub fn bitcoin::taproot::TapLeaf::partial_cmp(&self, other: &bitcoin::taproot::TapLeaf) -> core::option::Option pub fn bitcoin::taproot::TapLeaf::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer pub fn bitcoin::taproot::TapLeafHash::all_zeros() -> Self +pub fn bitcoin::taproot::TapLeafHash::as_byte_array(&self) -> & as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapLeafHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::taproot::TapLeafHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapLeafHash::as_ref(&self) -> &[u8; 32] @@ -9511,22 +9608,27 @@ pub fn bitcoin::taproot::TapLeafHash::cmp(&self, other: &bitcoin::taproot::TapLe pub fn bitcoin::taproot::TapLeafHash::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::taproot::TapLeafHash::consensus_encode(&self, w: &mut W) -> core::result::Result pub fn bitcoin::taproot::TapLeafHash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::taproot::TapLeafHash::engine() -> Self::Engine +pub fn bitcoin::taproot::TapLeafHash::engine() -> as bitcoin_hashes::Hash>::Engine pub fn bitcoin::taproot::TapLeafHash::eq(&self, other: &bitcoin::taproot::TapLeafHash) -> bool pub fn bitcoin::taproot::TapLeafHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::taproot::TapLeafHash::from(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapLeafHash pub fn bitcoin::taproot::TapLeafHash::from(script_path: bitcoin::sighash::ScriptPath<'s>) -> bitcoin::taproot::TapLeafHash +pub fn bitcoin::taproot::TapLeafHash::from_byte_array(bytes: as bitcoin_hashes::Hash>::Bytes) -> Self pub fn bitcoin::taproot::TapLeafHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::taproot::TapLeafHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::taproot::TapLeafHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> Self +pub fn bitcoin::taproot::TapLeafHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> bitcoin::taproot::TapLeafHash pub fn bitcoin::taproot::TapLeafHash::from_raw_hash(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapLeafHash pub fn bitcoin::taproot::TapLeafHash::from_script(script: &bitcoin::blockdata::script::Script, ver: bitcoin::taproot::LeafVersion) -> bitcoin::taproot::TapLeafHash pub fn bitcoin::taproot::TapLeafHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::taproot::TapLeafHash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::taproot::TapLeafHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::taproot::TapLeafHash::hash(data: &[u8]) -> Self pub fn bitcoin::taproot::TapLeafHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::taproot::TapLeafHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::taproot::TapLeafHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::taproot::TapLeafHash::partial_cmp(&self, other: &bitcoin::taproot::TapLeafHash) -> core::option::Option pub fn bitcoin::taproot::TapLeafHash::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::taproot::TapLeafHash::to_byte_array(self) -> as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapLeafHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::taproot::TapLeafHash::to_raw_hash(self) -> bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapLeafTag::clone(&self) -> bitcoin::taproot::TapLeafTag @@ -9537,6 +9639,7 @@ pub fn bitcoin::taproot::TapLeafTag::eq(&self, other: &bitcoin::taproot::TapLeaf pub fn bitcoin::taproot::TapLeafTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H) pub fn bitcoin::taproot::TapLeafTag::partial_cmp(&self, other: &bitcoin::taproot::TapLeafTag) -> core::option::Option pub fn bitcoin::taproot::TapNodeHash::all_zeros() -> Self +pub fn bitcoin::taproot::TapNodeHash::as_byte_array(&self) -> & as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapNodeHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::taproot::TapNodeHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapNodeHash::as_ref(&self) -> &[u8; 32] @@ -9546,25 +9649,30 @@ pub fn bitcoin::taproot::TapNodeHash::borrow(&self) -> &[u8] pub fn bitcoin::taproot::TapNodeHash::clone(&self) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::cmp(&self, other: &bitcoin::taproot::TapNodeHash) -> core::cmp::Ordering pub fn bitcoin::taproot::TapNodeHash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::taproot::TapNodeHash::engine() -> Self::Engine +pub fn bitcoin::taproot::TapNodeHash::engine() -> as bitcoin_hashes::Hash>::Engine pub fn bitcoin::taproot::TapNodeHash::eq(&self, other: &bitcoin::taproot::TapNodeHash) -> bool pub fn bitcoin::taproot::TapNodeHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::taproot::TapNodeHash::from(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from(leaf: &bitcoin::taproot::LeafNode) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from(leaf: bitcoin::taproot::LeafNode) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from(leaf: bitcoin::taproot::TapLeafHash) -> bitcoin::taproot::TapNodeHash +pub fn bitcoin::taproot::TapNodeHash::from_byte_array(bytes: as bitcoin_hashes::Hash>::Bytes) -> Self pub fn bitcoin::taproot::TapNodeHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::taproot::TapNodeHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::taproot::TapNodeHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> Self +pub fn bitcoin::taproot::TapNodeHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from_node_hashes(a: bitcoin::taproot::TapNodeHash, b: bitcoin::taproot::TapNodeHash) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from_raw_hash(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from_script(script: &bitcoin::blockdata::script::Script, ver: bitcoin::taproot::LeafVersion) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::taproot::TapNodeHash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::taproot::TapNodeHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::taproot::TapNodeHash::hash(data: &[u8]) -> Self pub fn bitcoin::taproot::TapNodeHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::taproot::TapNodeHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::taproot::TapNodeHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::taproot::TapNodeHash::partial_cmp(&self, other: &bitcoin::taproot::TapNodeHash) -> core::option::Option pub fn bitcoin::taproot::TapNodeHash::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::taproot::TapNodeHash::to_byte_array(self) -> as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapNodeHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::taproot::TapNodeHash::to_raw_hash(self) -> bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapTree::clone(&self) -> bitcoin::taproot::TapTree @@ -9580,6 +9688,7 @@ pub fn bitcoin::taproot::TapTree::serialize<__S>(&self, __serializer: __S) -> co pub fn bitcoin::taproot::TapTree::try_from(builder: bitcoin::taproot::TaprootBuilder) -> core::result::Result pub fn bitcoin::taproot::TapTree::try_from(node_info: bitcoin::taproot::NodeInfo) -> core::result::Result pub fn bitcoin::taproot::TapTweakHash::all_zeros() -> Self +pub fn bitcoin::taproot::TapTweakHash::as_byte_array(&self) -> & as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapTweakHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::taproot::TapTweakHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapTweakHash::as_ref(&self) -> &[u8; 32] @@ -9588,23 +9697,28 @@ pub fn bitcoin::taproot::TapTweakHash::borrow(&self) -> &[u8] pub fn bitcoin::taproot::TapTweakHash::clone(&self) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::cmp(&self, other: &bitcoin::taproot::TapTweakHash) -> core::cmp::Ordering pub fn bitcoin::taproot::TapTweakHash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin::taproot::TapTweakHash::engine() -> Self::Engine +pub fn bitcoin::taproot::TapTweakHash::engine() -> as bitcoin_hashes::Hash>::Engine pub fn bitcoin::taproot::TapTweakHash::eq(&self, other: &bitcoin::taproot::TapTweakHash) -> bool pub fn bitcoin::taproot::TapTweakHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::taproot::TapTweakHash::from(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::from(spend_info: &bitcoin::taproot::TaprootSpendInfo) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::from(spend_info: bitcoin::taproot::TaprootSpendInfo) -> bitcoin::taproot::TapTweakHash +pub fn bitcoin::taproot::TapTweakHash::from_byte_array(bytes: as bitcoin_hashes::Hash>::Bytes) -> Self pub fn bitcoin::taproot::TapTweakHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::taproot::TapTweakHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::taproot::TapTweakHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> Self +pub fn bitcoin::taproot::TapTweakHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::from_key_and_tweak(internal_key: bitcoin::key::UntweakedPublicKey, merkle_root: core::option::Option) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::from_raw_hash(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::taproot::TapTweakHash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin::taproot::TapTweakHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::taproot::TapTweakHash::hash(data: &[u8]) -> Self pub fn bitcoin::taproot::TapTweakHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::taproot::TapTweakHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::taproot::TapTweakHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::taproot::TapTweakHash::partial_cmp(&self, other: &bitcoin::taproot::TapTweakHash) -> core::option::Option pub fn bitcoin::taproot::TapTweakHash::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> +pub fn bitcoin::taproot::TapTweakHash::to_byte_array(self) -> as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapTweakHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::taproot::TapTweakHash::to_raw_hash(self) -> bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapTweakHash::to_scalar(self) -> secp256k1::scalar::Scalar diff --git a/api/bitcoin/default-features.txt b/api/bitcoin/default-features.txt index b56d80bba..e01b1470c 100644 --- a/api/bitcoin/default-features.txt +++ b/api/bitcoin/default-features.txt @@ -6566,6 +6566,7 @@ pub fn bitcoin::EcdsaSighashType::from_str(s: &str) -> core::result::Result(&self, state: &mut __H) pub fn bitcoin::EcdsaSighashType::to_u32(self) -> u32 pub fn bitcoin::LegacySighash::all_zeros() -> Self +pub fn bitcoin::LegacySighash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::LegacySighash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::LegacySighash::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::LegacySighash::as_ref(&self) -> &[u8; 32] @@ -6573,18 +6574,23 @@ pub fn bitcoin::LegacySighash::as_ref(&self) -> &[u8] pub fn bitcoin::LegacySighash::borrow(&self) -> &[u8] pub fn bitcoin::LegacySighash::clone(&self) -> bitcoin::LegacySighash pub fn bitcoin::LegacySighash::cmp(&self, other: &bitcoin::LegacySighash) -> core::cmp::Ordering -pub fn bitcoin::LegacySighash::engine() -> Self::Engine +pub fn bitcoin::LegacySighash::engine() -> ::Engine pub fn bitcoin::LegacySighash::eq(&self, other: &bitcoin::LegacySighash) -> bool pub fn bitcoin::LegacySighash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::LegacySighash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::LegacySighash +pub fn bitcoin::LegacySighash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::LegacySighash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::LegacySighash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::LegacySighash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::LegacySighash::from_engine(e: ::Engine) -> bitcoin::LegacySighash pub fn bitcoin::LegacySighash::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::LegacySighash pub fn bitcoin::LegacySighash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::LegacySighash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::LegacySighash::hash(data: &[u8]) -> Self pub fn bitcoin::LegacySighash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::LegacySighash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::LegacySighash::index(&self, index: I) -> &Self::Output pub fn bitcoin::LegacySighash::partial_cmp(&self, other: &bitcoin::LegacySighash) -> core::option::Option +pub fn bitcoin::LegacySighash::to_byte_array(self) -> ::Bytes pub fn bitcoin::LegacySighash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::LegacySighash::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::MerkleBlock::clone(&self) -> bitcoin::MerkleBlock @@ -6609,6 +6615,7 @@ pub fn bitcoin::PrivateKey::public_key(&self, se pub fn bitcoin::PrivateKey::to_bytes(self) -> alloc::vec::Vec pub fn bitcoin::PrivateKey::to_wif(self) -> alloc::string::String pub fn bitcoin::PubkeyHash::all_zeros() -> Self +pub fn bitcoin::PubkeyHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::PubkeyHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::PubkeyHash::as_raw_hash(&self) -> &bitcoin_hashes::hash160::Hash pub fn bitcoin::PubkeyHash::as_ref(&self) -> &[u8; 20] @@ -6617,7 +6624,7 @@ pub fn bitcoin::PubkeyHash::as_ref(&self) -> &bitcoin::blockdata::script::PushBy pub fn bitcoin::PubkeyHash::borrow(&self) -> &[u8] pub fn bitcoin::PubkeyHash::clone(&self) -> bitcoin::PubkeyHash pub fn bitcoin::PubkeyHash::cmp(&self, other: &bitcoin::PubkeyHash) -> core::cmp::Ordering -pub fn bitcoin::PubkeyHash::engine() -> Self::Engine +pub fn bitcoin::PubkeyHash::engine() -> ::Engine pub fn bitcoin::PubkeyHash::eq(&self, other: &bitcoin::PubkeyHash) -> bool pub fn bitcoin::PubkeyHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::PubkeyHash::from(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::PubkeyHash @@ -6625,14 +6632,19 @@ pub fn bitcoin::PubkeyHash::from(key: &bitcoin::CompressedPublicKey) -> Self pub fn bitcoin::PubkeyHash::from(key: &bitcoin::PublicKey) -> bitcoin::PubkeyHash pub fn bitcoin::PubkeyHash::from(key: bitcoin::CompressedPublicKey) -> Self pub fn bitcoin::PubkeyHash::from(key: bitcoin::PublicKey) -> bitcoin::PubkeyHash +pub fn bitcoin::PubkeyHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::PubkeyHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::PubkeyHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::PubkeyHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::PubkeyHash::from_engine(e: ::Engine) -> bitcoin::PubkeyHash pub fn bitcoin::PubkeyHash::from_raw_hash(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::PubkeyHash pub fn bitcoin::PubkeyHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::PubkeyHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::PubkeyHash::hash(data: &[u8]) -> Self pub fn bitcoin::PubkeyHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::PubkeyHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::PubkeyHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::PubkeyHash::partial_cmp(&self, other: &bitcoin::PubkeyHash) -> core::option::Option +pub fn bitcoin::PubkeyHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::PubkeyHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::PubkeyHash::to_raw_hash(self) -> bitcoin_hashes::hash160::Hash pub fn bitcoin::PublicKey::clone(&self) -> bitcoin::PublicKey @@ -6657,6 +6669,7 @@ pub fn bitcoin::PublicKey::verify(&self, se pub fn bitcoin::PublicKey::wpubkey_hash(&self) -> core::result::Result pub fn bitcoin::PublicKey::write_into(&self, writer: &mut W) -> core::result::Result<(), bitcoin_io::error::Error> pub fn bitcoin::SegwitV0Sighash::all_zeros() -> Self +pub fn bitcoin::SegwitV0Sighash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::SegwitV0Sighash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::SegwitV0Sighash::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::SegwitV0Sighash::as_ref(&self) -> &[u8; 32] @@ -6664,21 +6677,27 @@ pub fn bitcoin::SegwitV0Sighash::as_ref(&self) -> &[u8] pub fn bitcoin::SegwitV0Sighash::borrow(&self) -> &[u8] pub fn bitcoin::SegwitV0Sighash::clone(&self) -> bitcoin::SegwitV0Sighash pub fn bitcoin::SegwitV0Sighash::cmp(&self, other: &bitcoin::SegwitV0Sighash) -> core::cmp::Ordering -pub fn bitcoin::SegwitV0Sighash::engine() -> Self::Engine +pub fn bitcoin::SegwitV0Sighash::engine() -> ::Engine pub fn bitcoin::SegwitV0Sighash::eq(&self, other: &bitcoin::SegwitV0Sighash) -> bool pub fn bitcoin::SegwitV0Sighash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::SegwitV0Sighash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::SegwitV0Sighash +pub fn bitcoin::SegwitV0Sighash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::SegwitV0Sighash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::SegwitV0Sighash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::SegwitV0Sighash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::SegwitV0Sighash::from_engine(e: ::Engine) -> bitcoin::SegwitV0Sighash pub fn bitcoin::SegwitV0Sighash::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::SegwitV0Sighash pub fn bitcoin::SegwitV0Sighash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::SegwitV0Sighash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::SegwitV0Sighash::hash(data: &[u8]) -> Self pub fn bitcoin::SegwitV0Sighash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::SegwitV0Sighash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::SegwitV0Sighash::index(&self, index: I) -> &Self::Output pub fn bitcoin::SegwitV0Sighash::partial_cmp(&self, other: &bitcoin::SegwitV0Sighash) -> core::option::Option +pub fn bitcoin::SegwitV0Sighash::to_byte_array(self) -> ::Bytes pub fn bitcoin::SegwitV0Sighash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::SegwitV0Sighash::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::TapSighash::all_zeros() -> Self +pub fn bitcoin::TapSighash::as_byte_array(&self) -> & as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::TapSighash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::TapSighash::as_raw_hash(&self) -> &bitcoin_hashes::sha256t::Hash pub fn bitcoin::TapSighash::as_ref(&self) -> &[u8; 32] @@ -6686,18 +6705,23 @@ pub fn bitcoin::TapSighash::as_ref(&self) -> &[u8] pub fn bitcoin::TapSighash::borrow(&self) -> &[u8] pub fn bitcoin::TapSighash::clone(&self) -> bitcoin::TapSighash pub fn bitcoin::TapSighash::cmp(&self, other: &bitcoin::TapSighash) -> core::cmp::Ordering -pub fn bitcoin::TapSighash::engine() -> Self::Engine +pub fn bitcoin::TapSighash::engine() -> as bitcoin_hashes::Hash>::Engine pub fn bitcoin::TapSighash::eq(&self, other: &bitcoin::TapSighash) -> bool pub fn bitcoin::TapSighash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::TapSighash::from(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::TapSighash +pub fn bitcoin::TapSighash::from_byte_array(bytes: as bitcoin_hashes::Hash>::Bytes) -> Self pub fn bitcoin::TapSighash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::TapSighash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::TapSighash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> Self +pub fn bitcoin::TapSighash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> bitcoin::TapSighash pub fn bitcoin::TapSighash::from_raw_hash(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::TapSighash pub fn bitcoin::TapSighash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::TapSighash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::TapSighash::hash(data: &[u8]) -> Self pub fn bitcoin::TapSighash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::TapSighash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::TapSighash::index(&self, index: I) -> &Self::Output pub fn bitcoin::TapSighash::partial_cmp(&self, other: &bitcoin::TapSighash) -> core::option::Option +pub fn bitcoin::TapSighash::to_byte_array(self) -> as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::TapSighash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::TapSighash::to_raw_hash(self) -> bitcoin_hashes::sha256t::Hash pub fn bitcoin::TapSighashTag::clone(&self) -> bitcoin::TapSighashTag @@ -6717,6 +6741,7 @@ pub fn bitcoin::TapSighashType::from_str(s: &str) -> core::result::Result(&self, state: &mut __H) pub fn bitcoin::TapSighashType::partial_cmp(&self, other: &bitcoin::TapSighashType) -> core::option::Option pub fn bitcoin::WPubkeyHash::all_zeros() -> Self +pub fn bitcoin::WPubkeyHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::WPubkeyHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::WPubkeyHash::as_raw_hash(&self) -> &bitcoin_hashes::hash160::Hash pub fn bitcoin::WPubkeyHash::as_ref(&self) -> &[u8; 20] @@ -6725,20 +6750,25 @@ pub fn bitcoin::WPubkeyHash::as_ref(&self) -> &bitcoin::blockdata::script::PushB pub fn bitcoin::WPubkeyHash::borrow(&self) -> &[u8] pub fn bitcoin::WPubkeyHash::clone(&self) -> bitcoin::WPubkeyHash pub fn bitcoin::WPubkeyHash::cmp(&self, other: &bitcoin::WPubkeyHash) -> core::cmp::Ordering -pub fn bitcoin::WPubkeyHash::engine() -> Self::Engine +pub fn bitcoin::WPubkeyHash::engine() -> ::Engine pub fn bitcoin::WPubkeyHash::eq(&self, other: &bitcoin::WPubkeyHash) -> bool pub fn bitcoin::WPubkeyHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::WPubkeyHash::from(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::WPubkeyHash pub fn bitcoin::WPubkeyHash::from(key: &bitcoin::CompressedPublicKey) -> Self pub fn bitcoin::WPubkeyHash::from(key: bitcoin::CompressedPublicKey) -> Self +pub fn bitcoin::WPubkeyHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::WPubkeyHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::WPubkeyHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::WPubkeyHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::WPubkeyHash::from_engine(e: ::Engine) -> bitcoin::WPubkeyHash pub fn bitcoin::WPubkeyHash::from_raw_hash(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::WPubkeyHash pub fn bitcoin::WPubkeyHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::WPubkeyHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::WPubkeyHash::hash(data: &[u8]) -> Self pub fn bitcoin::WPubkeyHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::WPubkeyHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::WPubkeyHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::WPubkeyHash::partial_cmp(&self, other: &bitcoin::WPubkeyHash) -> core::option::Option +pub fn bitcoin::WPubkeyHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::WPubkeyHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::WPubkeyHash::to_raw_hash(self) -> bitcoin_hashes::hash160::Hash pub fn bitcoin::address::Address::address_type(&self) -> core::option::Option @@ -6963,6 +6993,7 @@ pub fn bitcoin::bip158::Error::from(io: bitcoin_io::error::Error) -> Self pub fn bitcoin::bip158::Error::from(never: core::convert::Infallible) -> Self pub fn bitcoin::bip158::Error::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> pub fn bitcoin::bip158::FilterHash::all_zeros() -> Self +pub fn bitcoin::bip158::FilterHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::bip158::FilterHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::bip158::FilterHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::bip158::FilterHash::as_ref(&self) -> &[u8; 32] @@ -6972,22 +7003,28 @@ pub fn bitcoin::bip158::FilterHash::clone(&self) -> bitcoin::bip158::FilterHash pub fn bitcoin::bip158::FilterHash::cmp(&self, other: &bitcoin::bip158::FilterHash) -> core::cmp::Ordering pub fn bitcoin::bip158::FilterHash::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::bip158::FilterHash::consensus_encode(&self, w: &mut W) -> core::result::Result -pub fn bitcoin::bip158::FilterHash::engine() -> Self::Engine +pub fn bitcoin::bip158::FilterHash::engine() -> ::Engine pub fn bitcoin::bip158::FilterHash::eq(&self, other: &bitcoin::bip158::FilterHash) -> bool pub fn bitcoin::bip158::FilterHash::filter_header(&self, previous_filter_header: &bitcoin::bip158::FilterHeader) -> bitcoin::bip158::FilterHeader pub fn bitcoin::bip158::FilterHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::bip158::FilterHash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::bip158::FilterHash +pub fn bitcoin::bip158::FilterHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::bip158::FilterHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::bip158::FilterHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::bip158::FilterHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::bip158::FilterHash::from_engine(e: ::Engine) -> bitcoin::bip158::FilterHash pub fn bitcoin::bip158::FilterHash::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::bip158::FilterHash pub fn bitcoin::bip158::FilterHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::bip158::FilterHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::bip158::FilterHash::hash(data: &[u8]) -> Self pub fn bitcoin::bip158::FilterHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::bip158::FilterHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::bip158::FilterHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::bip158::FilterHash::partial_cmp(&self, other: &bitcoin::bip158::FilterHash) -> core::option::Option +pub fn bitcoin::bip158::FilterHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::bip158::FilterHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::bip158::FilterHash::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::bip158::FilterHeader::all_zeros() -> Self +pub fn bitcoin::bip158::FilterHeader::as_byte_array(&self) -> &::Bytes pub fn bitcoin::bip158::FilterHeader::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::bip158::FilterHeader::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::bip158::FilterHeader::as_ref(&self) -> &[u8; 32] @@ -6997,18 +7034,23 @@ pub fn bitcoin::bip158::FilterHeader::clone(&self) -> bitcoin::bip158::FilterHea pub fn bitcoin::bip158::FilterHeader::cmp(&self, other: &bitcoin::bip158::FilterHeader) -> core::cmp::Ordering pub fn bitcoin::bip158::FilterHeader::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::bip158::FilterHeader::consensus_encode(&self, w: &mut W) -> core::result::Result -pub fn bitcoin::bip158::FilterHeader::engine() -> Self::Engine +pub fn bitcoin::bip158::FilterHeader::engine() -> ::Engine pub fn bitcoin::bip158::FilterHeader::eq(&self, other: &bitcoin::bip158::FilterHeader) -> bool pub fn bitcoin::bip158::FilterHeader::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::bip158::FilterHeader::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::bip158::FilterHeader +pub fn bitcoin::bip158::FilterHeader::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::bip158::FilterHeader::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::bip158::FilterHeader::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::bip158::FilterHeader::from_engine(e: ::Engine) -> Self +pub fn bitcoin::bip158::FilterHeader::from_engine(e: ::Engine) -> bitcoin::bip158::FilterHeader pub fn bitcoin::bip158::FilterHeader::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::bip158::FilterHeader pub fn bitcoin::bip158::FilterHeader::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::bip158::FilterHeader::from_str(s: &str) -> core::result::Result +pub fn bitcoin::bip158::FilterHeader::hash(data: &[u8]) -> Self pub fn bitcoin::bip158::FilterHeader::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::bip158::FilterHeader::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::bip158::FilterHeader::index(&self, index: I) -> &Self::Output pub fn bitcoin::bip158::FilterHeader::partial_cmp(&self, other: &bitcoin::bip158::FilterHeader) -> core::option::Option +pub fn bitcoin::bip158::FilterHeader::to_byte_array(self) -> ::Bytes pub fn bitcoin::bip158::FilterHeader::to_byte_array(self) -> Self::Bytes pub fn bitcoin::bip158::FilterHeader::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::bip158::GcsFilterReader::match_all(&self, reader: &mut R, query: I) -> core::result::Result where I: core::iter::traits::iterator::Iterator, ::Item: core::borrow::Borrow<[u8]>, R: bitcoin_io::BufRead + core::marker::Sized @@ -7128,6 +7170,7 @@ pub fn bitcoin::bip32::InvalidBase58PayloadLengthError::eq(&self, other: &bitcoi pub fn bitcoin::bip32::InvalidBase58PayloadLengthError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::bip32::InvalidBase58PayloadLengthError::invalid_base58_payload_length(&self) -> usize pub fn bitcoin::bip32::XKeyIdentifier::all_zeros() -> Self +pub fn bitcoin::bip32::XKeyIdentifier::as_byte_array(&self) -> &::Bytes pub fn bitcoin::bip32::XKeyIdentifier::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::bip32::XKeyIdentifier::as_raw_hash(&self) -> &bitcoin_hashes::hash160::Hash pub fn bitcoin::bip32::XKeyIdentifier::as_ref(&self) -> &[u8; 20] @@ -7135,20 +7178,25 @@ pub fn bitcoin::bip32::XKeyIdentifier::as_ref(&self) -> &[u8] pub fn bitcoin::bip32::XKeyIdentifier::borrow(&self) -> &[u8] pub fn bitcoin::bip32::XKeyIdentifier::clone(&self) -> bitcoin::bip32::XKeyIdentifier pub fn bitcoin::bip32::XKeyIdentifier::cmp(&self, other: &bitcoin::bip32::XKeyIdentifier) -> core::cmp::Ordering -pub fn bitcoin::bip32::XKeyIdentifier::engine() -> Self::Engine +pub fn bitcoin::bip32::XKeyIdentifier::engine() -> ::Engine pub fn bitcoin::bip32::XKeyIdentifier::eq(&self, other: &bitcoin::bip32::XKeyIdentifier) -> bool pub fn bitcoin::bip32::XKeyIdentifier::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::bip32::XKeyIdentifier::from(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::bip32::XKeyIdentifier pub fn bitcoin::bip32::XKeyIdentifier::from(key: &bitcoin::bip32::Xpub) -> bitcoin::bip32::XKeyIdentifier pub fn bitcoin::bip32::XKeyIdentifier::from(key: bitcoin::bip32::Xpub) -> bitcoin::bip32::XKeyIdentifier +pub fn bitcoin::bip32::XKeyIdentifier::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::bip32::XKeyIdentifier::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::bip32::XKeyIdentifier::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::bip32::XKeyIdentifier::from_engine(e: ::Engine) -> Self +pub fn bitcoin::bip32::XKeyIdentifier::from_engine(e: ::Engine) -> bitcoin::bip32::XKeyIdentifier pub fn bitcoin::bip32::XKeyIdentifier::from_raw_hash(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::bip32::XKeyIdentifier pub fn bitcoin::bip32::XKeyIdentifier::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::bip32::XKeyIdentifier::from_str(s: &str) -> core::result::Result +pub fn bitcoin::bip32::XKeyIdentifier::hash(data: &[u8]) -> Self pub fn bitcoin::bip32::XKeyIdentifier::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::bip32::XKeyIdentifier::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::bip32::XKeyIdentifier::index(&self, index: I) -> &Self::Output pub fn bitcoin::bip32::XKeyIdentifier::partial_cmp(&self, other: &bitcoin::bip32::XKeyIdentifier) -> core::option::Option +pub fn bitcoin::bip32::XKeyIdentifier::to_byte_array(self) -> ::Bytes pub fn bitcoin::bip32::XKeyIdentifier::to_byte_array(self) -> Self::Bytes pub fn bitcoin::bip32::XKeyIdentifier::to_raw_hash(self) -> bitcoin_hashes::hash160::Hash pub fn bitcoin::bip32::Xpriv::clone(&self) -> bitcoin::bip32::Xpriv @@ -7205,6 +7253,7 @@ pub fn bitcoin::blockdata::block::Block::total_size(&self) -> usize pub fn bitcoin::blockdata::block::Block::weight(&self) -> bitcoin_units::weight::Weight pub fn bitcoin::blockdata::block::Block::witness_root(&self) -> core::option::Option pub fn bitcoin::blockdata::block::BlockHash::all_zeros() -> Self +pub fn bitcoin::blockdata::block::BlockHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::block::BlockHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::block::BlockHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::BlockHash::as_ref(&self) -> &[u8; 32] @@ -7214,7 +7263,7 @@ pub fn bitcoin::blockdata::block::BlockHash::clone(&self) -> bitcoin::blockdata: pub fn bitcoin::blockdata::block::BlockHash::cmp(&self, other: &bitcoin::blockdata::block::BlockHash) -> core::cmp::Ordering pub fn bitcoin::blockdata::block::BlockHash::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::blockdata::block::BlockHash::consensus_encode(&self, w: &mut W) -> core::result::Result -pub fn bitcoin::blockdata::block::BlockHash::engine() -> Self::Engine +pub fn bitcoin::blockdata::block::BlockHash::engine() -> ::Engine pub fn bitcoin::blockdata::block::BlockHash::eq(&self, other: &bitcoin::blockdata::block::BlockHash) -> bool pub fn bitcoin::blockdata::block::BlockHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::block::BlockHash::from(block: &bitcoin::blockdata::block::Block) -> bitcoin::blockdata::block::BlockHash @@ -7222,14 +7271,19 @@ pub fn bitcoin::blockdata::block::BlockHash::from(block: bitcoin::blockdata::blo pub fn bitcoin::blockdata::block::BlockHash::from(header: &bitcoin::blockdata::block::Header) -> bitcoin::blockdata::block::BlockHash pub fn bitcoin::blockdata::block::BlockHash::from(header: bitcoin::blockdata::block::Header) -> bitcoin::blockdata::block::BlockHash pub fn bitcoin::blockdata::block::BlockHash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::BlockHash +pub fn bitcoin::blockdata::block::BlockHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::block::BlockHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::block::BlockHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::block::BlockHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::block::BlockHash::from_engine(e: ::Engine) -> bitcoin::blockdata::block::BlockHash pub fn bitcoin::blockdata::block::BlockHash::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::BlockHash pub fn bitcoin::blockdata::block::BlockHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::block::BlockHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::block::BlockHash::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::block::BlockHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::block::BlockHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::block::BlockHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::block::BlockHash::partial_cmp(&self, other: &bitcoin::blockdata::block::BlockHash) -> core::option::Option +pub fn bitcoin::blockdata::block::BlockHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::block::BlockHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::block::BlockHash::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::Header::block_hash(&self) -> bitcoin::blockdata::block::BlockHash @@ -7248,6 +7302,7 @@ pub fn bitcoin::blockdata::block::Header::target(&self) -> bitcoin::pow::Target pub fn bitcoin::blockdata::block::Header::validate_pow(&self, required_target: bitcoin::pow::Target) -> core::result::Result pub fn bitcoin::blockdata::block::Header::work(&self) -> bitcoin::pow::Work pub fn bitcoin::blockdata::block::TxMerkleNode::all_zeros() -> Self +pub fn bitcoin::blockdata::block::TxMerkleNode::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::block::TxMerkleNode::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::block::TxMerkleNode::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::TxMerkleNode::as_ref(&self) -> &[u8; 32] @@ -7257,19 +7312,24 @@ pub fn bitcoin::blockdata::block::TxMerkleNode::clone(&self) -> bitcoin::blockda pub fn bitcoin::blockdata::block::TxMerkleNode::cmp(&self, other: &bitcoin::blockdata::block::TxMerkleNode) -> core::cmp::Ordering pub fn bitcoin::blockdata::block::TxMerkleNode::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::blockdata::block::TxMerkleNode::consensus_encode(&self, w: &mut W) -> core::result::Result -pub fn bitcoin::blockdata::block::TxMerkleNode::engine() -> Self::Engine +pub fn bitcoin::blockdata::block::TxMerkleNode::engine() -> ::Engine pub fn bitcoin::blockdata::block::TxMerkleNode::eq(&self, other: &bitcoin::blockdata::block::TxMerkleNode) -> bool pub fn bitcoin::blockdata::block::TxMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::block::TxMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::TxMerkleNode pub fn bitcoin::blockdata::block::TxMerkleNode::from(txid: bitcoin::blockdata::transaction::Txid) -> Self +pub fn bitcoin::blockdata::block::TxMerkleNode::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::block::TxMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::block::TxMerkleNode::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::block::TxMerkleNode::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::block::TxMerkleNode::from_engine(e: ::Engine) -> bitcoin::blockdata::block::TxMerkleNode pub fn bitcoin::blockdata::block::TxMerkleNode::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::TxMerkleNode pub fn bitcoin::blockdata::block::TxMerkleNode::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::block::TxMerkleNode::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::block::TxMerkleNode::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::block::TxMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::block::TxMerkleNode::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::block::TxMerkleNode::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::block::TxMerkleNode::partial_cmp(&self, other: &bitcoin::blockdata::block::TxMerkleNode) -> core::option::Option +pub fn bitcoin::blockdata::block::TxMerkleNode::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::block::TxMerkleNode::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::block::TxMerkleNode::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::ValidationError::clone(&self) -> bitcoin::blockdata::block::ValidationError @@ -7289,6 +7349,7 @@ pub fn bitcoin::blockdata::block::Version::is_signalling_soft_fork(&self, bit: u pub fn bitcoin::blockdata::block::Version::partial_cmp(&self, other: &bitcoin::blockdata::block::Version) -> core::option::Option pub fn bitcoin::blockdata::block::Version::to_consensus(self) -> i32 pub fn bitcoin::blockdata::block::WitnessCommitment::all_zeros() -> Self +pub fn bitcoin::blockdata::block::WitnessCommitment::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::block::WitnessCommitment::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::block::WitnessCommitment::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::WitnessCommitment::as_ref(&self) -> &[u8; 32] @@ -7296,21 +7357,27 @@ pub fn bitcoin::blockdata::block::WitnessCommitment::as_ref(&self) -> &[u8] pub fn bitcoin::blockdata::block::WitnessCommitment::borrow(&self) -> &[u8] pub fn bitcoin::blockdata::block::WitnessCommitment::clone(&self) -> bitcoin::blockdata::block::WitnessCommitment pub fn bitcoin::blockdata::block::WitnessCommitment::cmp(&self, other: &bitcoin::blockdata::block::WitnessCommitment) -> core::cmp::Ordering -pub fn bitcoin::blockdata::block::WitnessCommitment::engine() -> Self::Engine +pub fn bitcoin::blockdata::block::WitnessCommitment::engine() -> ::Engine pub fn bitcoin::blockdata::block::WitnessCommitment::eq(&self, other: &bitcoin::blockdata::block::WitnessCommitment) -> bool pub fn bitcoin::blockdata::block::WitnessCommitment::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::block::WitnessCommitment::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::WitnessCommitment +pub fn bitcoin::blockdata::block::WitnessCommitment::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::block::WitnessCommitment::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::block::WitnessCommitment::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::block::WitnessCommitment::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::block::WitnessCommitment::from_engine(e: ::Engine) -> bitcoin::blockdata::block::WitnessCommitment pub fn bitcoin::blockdata::block::WitnessCommitment::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::WitnessCommitment pub fn bitcoin::blockdata::block::WitnessCommitment::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::block::WitnessCommitment::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::block::WitnessCommitment::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::block::WitnessCommitment::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::block::WitnessCommitment::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::block::WitnessCommitment::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::block::WitnessCommitment::partial_cmp(&self, other: &bitcoin::blockdata::block::WitnessCommitment) -> core::option::Option +pub fn bitcoin::blockdata::block::WitnessCommitment::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::block::WitnessCommitment::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::block::WitnessCommitment::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::WitnessMerkleNode::all_zeros() -> Self +pub fn bitcoin::blockdata::block::WitnessMerkleNode::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::block::WitnessMerkleNode::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::block::WitnessMerkleNode::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::WitnessMerkleNode::as_ref(&self) -> &[u8; 32] @@ -7320,19 +7387,24 @@ pub fn bitcoin::blockdata::block::WitnessMerkleNode::clone(&self) -> bitcoin::bl pub fn bitcoin::blockdata::block::WitnessMerkleNode::cmp(&self, other: &bitcoin::blockdata::block::WitnessMerkleNode) -> core::cmp::Ordering pub fn bitcoin::blockdata::block::WitnessMerkleNode::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::blockdata::block::WitnessMerkleNode::consensus_encode(&self, w: &mut W) -> core::result::Result -pub fn bitcoin::blockdata::block::WitnessMerkleNode::engine() -> Self::Engine +pub fn bitcoin::blockdata::block::WitnessMerkleNode::engine() -> ::Engine pub fn bitcoin::blockdata::block::WitnessMerkleNode::eq(&self, other: &bitcoin::blockdata::block::WitnessMerkleNode) -> bool pub fn bitcoin::blockdata::block::WitnessMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::block::WitnessMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::WitnessMerkleNode pub fn bitcoin::blockdata::block::WitnessMerkleNode::from(wtxid: bitcoin::blockdata::transaction::Wtxid) -> Self +pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_engine(e: ::Engine) -> bitcoin::blockdata::block::WitnessMerkleNode pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::WitnessMerkleNode pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::block::WitnessMerkleNode::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::block::WitnessMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::block::WitnessMerkleNode::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::block::WitnessMerkleNode::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::block::WitnessMerkleNode::partial_cmp(&self, other: &bitcoin::blockdata::block::WitnessMerkleNode) -> core::option::Option +pub fn bitcoin::blockdata::block::WitnessMerkleNode::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::block::WitnessMerkleNode::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::block::WitnessMerkleNode::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::constants::ChainHash::as_byte_array(&self) -> &[u8; 32] @@ -7802,6 +7874,7 @@ pub fn bitcoin::blockdata::script::ScriptBuf::reserve_exact(&mut self, additiona pub fn bitcoin::blockdata::script::ScriptBuf::scan_and_push_verify(&mut self) pub fn bitcoin::blockdata::script::ScriptBuf::with_capacity(capacity: usize) -> Self pub fn bitcoin::blockdata::script::ScriptHash::all_zeros() -> Self +pub fn bitcoin::blockdata::script::ScriptHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::script::ScriptHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::script::ScriptHash::as_raw_hash(&self) -> &bitcoin_hashes::hash160::Hash pub fn bitcoin::blockdata::script::ScriptHash::as_ref(&self) -> &[u8; 20] @@ -7810,24 +7883,30 @@ pub fn bitcoin::blockdata::script::ScriptHash::as_ref(&self) -> &bitcoin::blockd pub fn bitcoin::blockdata::script::ScriptHash::borrow(&self) -> &[u8] pub fn bitcoin::blockdata::script::ScriptHash::clone(&self) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::cmp(&self, other: &bitcoin::blockdata::script::ScriptHash) -> core::cmp::Ordering -pub fn bitcoin::blockdata::script::ScriptHash::engine() -> Self::Engine +pub fn bitcoin::blockdata::script::ScriptHash::engine() -> ::Engine pub fn bitcoin::blockdata::script::ScriptHash::eq(&self, other: &bitcoin::blockdata::script::ScriptHash) -> bool pub fn bitcoin::blockdata::script::ScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::script::ScriptHash::from(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::from(script: &bitcoin::blockdata::script::Script) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::from(script: &bitcoin::blockdata::script::ScriptBuf) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::from(script: bitcoin::blockdata::script::ScriptBuf) -> bitcoin::blockdata::script::ScriptHash +pub fn bitcoin::blockdata::script::ScriptHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::script::ScriptHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::script::ScriptHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::script::ScriptHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::script::ScriptHash::from_engine(e: ::Engine) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::from_raw_hash(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::script::ScriptHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::script::ScriptHash::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::script::ScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::script::ScriptHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::script::ScriptHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::script::ScriptHash::partial_cmp(&self, other: &bitcoin::blockdata::script::ScriptHash) -> core::option::Option +pub fn bitcoin::blockdata::script::ScriptHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::script::ScriptHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::script::ScriptHash::to_raw_hash(self) -> bitcoin_hashes::hash160::Hash pub fn bitcoin::blockdata::script::WScriptHash::all_zeros() -> Self +pub fn bitcoin::blockdata::script::WScriptHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::script::WScriptHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::script::WScriptHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256::Hash pub fn bitcoin::blockdata::script::WScriptHash::as_ref(&self) -> &[u8; 32] @@ -7836,21 +7915,26 @@ pub fn bitcoin::blockdata::script::WScriptHash::as_ref(&self) -> &bitcoin::block pub fn bitcoin::blockdata::script::WScriptHash::borrow(&self) -> &[u8] pub fn bitcoin::blockdata::script::WScriptHash::clone(&self) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::cmp(&self, other: &bitcoin::blockdata::script::WScriptHash) -> core::cmp::Ordering -pub fn bitcoin::blockdata::script::WScriptHash::engine() -> Self::Engine +pub fn bitcoin::blockdata::script::WScriptHash::engine() -> ::Engine pub fn bitcoin::blockdata::script::WScriptHash::eq(&self, other: &bitcoin::blockdata::script::WScriptHash) -> bool pub fn bitcoin::blockdata::script::WScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::script::WScriptHash::from(inner: bitcoin_hashes::sha256::Hash) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::from(script: &bitcoin::blockdata::script::Script) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::from(script: &bitcoin::blockdata::script::ScriptBuf) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::from(script: bitcoin::blockdata::script::ScriptBuf) -> bitcoin::blockdata::script::WScriptHash +pub fn bitcoin::blockdata::script::WScriptHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::script::WScriptHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::script::WScriptHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::script::WScriptHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::script::WScriptHash::from_engine(e: ::Engine) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::from_raw_hash(inner: bitcoin_hashes::sha256::Hash) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::script::WScriptHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::script::WScriptHash::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::script::WScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::script::WScriptHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::script::WScriptHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::script::WScriptHash::partial_cmp(&self, other: &bitcoin::blockdata::script::WScriptHash) -> core::option::Option +pub fn bitcoin::blockdata::script::WScriptHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::script::WScriptHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::script::WScriptHash::to_raw_hash(self) -> bitcoin_hashes::sha256::Hash pub fn bitcoin::blockdata::script::read_scriptbool(v: &[u8]) -> bool @@ -8024,6 +8108,7 @@ pub fn bitcoin::blockdata::transaction::TxOut::partial_cmp(&self, other: &bitcoi pub fn bitcoin::blockdata::transaction::TxOut::size(&self) -> usize pub fn bitcoin::blockdata::transaction::TxOut::weight(&self) -> bitcoin_units::weight::Weight pub fn bitcoin::blockdata::transaction::Txid::all_zeros() -> Self +pub fn bitcoin::blockdata::transaction::Txid::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::transaction::Txid::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::transaction::Txid::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::transaction::Txid::as_ref(&self) -> &[u8; 32] @@ -8033,20 +8118,25 @@ pub fn bitcoin::blockdata::transaction::Txid::clone(&self) -> bitcoin::blockdata pub fn bitcoin::blockdata::transaction::Txid::cmp(&self, other: &bitcoin::blockdata::transaction::Txid) -> core::cmp::Ordering pub fn bitcoin::blockdata::transaction::Txid::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::blockdata::transaction::Txid::consensus_encode(&self, w: &mut W) -> core::result::Result -pub fn bitcoin::blockdata::transaction::Txid::engine() -> Self::Engine +pub fn bitcoin::blockdata::transaction::Txid::engine() -> ::Engine pub fn bitcoin::blockdata::transaction::Txid::eq(&self, other: &bitcoin::blockdata::transaction::Txid) -> bool pub fn bitcoin::blockdata::transaction::Txid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::transaction::Txid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::transaction::Txid pub fn bitcoin::blockdata::transaction::Txid::from(tx: &bitcoin::blockdata::transaction::Transaction) -> bitcoin::blockdata::transaction::Txid pub fn bitcoin::blockdata::transaction::Txid::from(tx: bitcoin::blockdata::transaction::Transaction) -> bitcoin::blockdata::transaction::Txid +pub fn bitcoin::blockdata::transaction::Txid::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::transaction::Txid::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::transaction::Txid::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::transaction::Txid::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::transaction::Txid::from_engine(e: ::Engine) -> bitcoin::blockdata::transaction::Txid pub fn bitcoin::blockdata::transaction::Txid::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::transaction::Txid pub fn bitcoin::blockdata::transaction::Txid::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::transaction::Txid::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::transaction::Txid::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::transaction::Txid::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::transaction::Txid::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::transaction::Txid::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::transaction::Txid::partial_cmp(&self, other: &bitcoin::blockdata::transaction::Txid) -> core::option::Option +pub fn bitcoin::blockdata::transaction::Txid::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::transaction::Txid::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::transaction::Txid::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::transaction::Version::clone(&self) -> bitcoin::blockdata::transaction::Version @@ -8060,6 +8150,7 @@ pub fn bitcoin::blockdata::transaction::Version::is_standard(&self) -> bool pub fn bitcoin::blockdata::transaction::Version::non_standard(version: i32) -> bitcoin::blockdata::transaction::Version pub fn bitcoin::blockdata::transaction::Version::partial_cmp(&self, other: &bitcoin::blockdata::transaction::Version) -> core::option::Option pub fn bitcoin::blockdata::transaction::Wtxid::all_zeros() -> Self +pub fn bitcoin::blockdata::transaction::Wtxid::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::transaction::Wtxid::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::transaction::Wtxid::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::transaction::Wtxid::as_ref(&self) -> &[u8; 32] @@ -8069,20 +8160,25 @@ pub fn bitcoin::blockdata::transaction::Wtxid::clone(&self) -> bitcoin::blockdat pub fn bitcoin::blockdata::transaction::Wtxid::cmp(&self, other: &bitcoin::blockdata::transaction::Wtxid) -> core::cmp::Ordering pub fn bitcoin::blockdata::transaction::Wtxid::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::blockdata::transaction::Wtxid::consensus_encode(&self, w: &mut W) -> core::result::Result -pub fn bitcoin::blockdata::transaction::Wtxid::engine() -> Self::Engine +pub fn bitcoin::blockdata::transaction::Wtxid::engine() -> ::Engine pub fn bitcoin::blockdata::transaction::Wtxid::eq(&self, other: &bitcoin::blockdata::transaction::Wtxid) -> bool pub fn bitcoin::blockdata::transaction::Wtxid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::transaction::Wtxid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::transaction::Wtxid pub fn bitcoin::blockdata::transaction::Wtxid::from(tx: &bitcoin::blockdata::transaction::Transaction) -> bitcoin::blockdata::transaction::Wtxid pub fn bitcoin::blockdata::transaction::Wtxid::from(tx: bitcoin::blockdata::transaction::Transaction) -> bitcoin::blockdata::transaction::Wtxid +pub fn bitcoin::blockdata::transaction::Wtxid::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::transaction::Wtxid::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::transaction::Wtxid::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::transaction::Wtxid::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::transaction::Wtxid::from_engine(e: ::Engine) -> bitcoin::blockdata::transaction::Wtxid pub fn bitcoin::blockdata::transaction::Wtxid::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::transaction::Wtxid pub fn bitcoin::blockdata::transaction::Wtxid::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::transaction::Wtxid::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::transaction::Wtxid::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::transaction::Wtxid::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::transaction::Wtxid::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::transaction::Wtxid::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::transaction::Wtxid::partial_cmp(&self, other: &bitcoin::blockdata::transaction::Wtxid) -> core::option::Option +pub fn bitcoin::blockdata::transaction::Wtxid::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::transaction::Wtxid::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::transaction::Wtxid::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::transaction::effective_value(fee_rate: bitcoin_units::fee_rate::FeeRate, satisfaction_weight: bitcoin_units::weight::Weight, value: bitcoin_units::amount::Amount) -> core::option::Option @@ -8998,6 +9094,7 @@ pub fn bitcoin::taproot::TapLeaf::fmt(&self, f: &mut core::fmt::Formatter<'_>) - pub fn bitcoin::taproot::TapLeaf::hash<__H: core::hash::Hasher>(&self, state: &mut __H) pub fn bitcoin::taproot::TapLeaf::partial_cmp(&self, other: &bitcoin::taproot::TapLeaf) -> core::option::Option pub fn bitcoin::taproot::TapLeafHash::all_zeros() -> Self +pub fn bitcoin::taproot::TapLeafHash::as_byte_array(&self) -> & as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapLeafHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::taproot::TapLeafHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapLeafHash::as_ref(&self) -> &[u8; 32] @@ -9007,20 +9104,25 @@ pub fn bitcoin::taproot::TapLeafHash::clone(&self) -> bitcoin::taproot::TapLeafH pub fn bitcoin::taproot::TapLeafHash::cmp(&self, other: &bitcoin::taproot::TapLeafHash) -> core::cmp::Ordering pub fn bitcoin::taproot::TapLeafHash::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::taproot::TapLeafHash::consensus_encode(&self, w: &mut W) -> core::result::Result -pub fn bitcoin::taproot::TapLeafHash::engine() -> Self::Engine +pub fn bitcoin::taproot::TapLeafHash::engine() -> as bitcoin_hashes::Hash>::Engine pub fn bitcoin::taproot::TapLeafHash::eq(&self, other: &bitcoin::taproot::TapLeafHash) -> bool pub fn bitcoin::taproot::TapLeafHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::taproot::TapLeafHash::from(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapLeafHash pub fn bitcoin::taproot::TapLeafHash::from(script_path: bitcoin::sighash::ScriptPath<'s>) -> bitcoin::taproot::TapLeafHash +pub fn bitcoin::taproot::TapLeafHash::from_byte_array(bytes: as bitcoin_hashes::Hash>::Bytes) -> Self pub fn bitcoin::taproot::TapLeafHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::taproot::TapLeafHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::taproot::TapLeafHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> Self +pub fn bitcoin::taproot::TapLeafHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> bitcoin::taproot::TapLeafHash pub fn bitcoin::taproot::TapLeafHash::from_raw_hash(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapLeafHash pub fn bitcoin::taproot::TapLeafHash::from_script(script: &bitcoin::blockdata::script::Script, ver: bitcoin::taproot::LeafVersion) -> bitcoin::taproot::TapLeafHash pub fn bitcoin::taproot::TapLeafHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::taproot::TapLeafHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::taproot::TapLeafHash::hash(data: &[u8]) -> Self pub fn bitcoin::taproot::TapLeafHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::taproot::TapLeafHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::taproot::TapLeafHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::taproot::TapLeafHash::partial_cmp(&self, other: &bitcoin::taproot::TapLeafHash) -> core::option::Option +pub fn bitcoin::taproot::TapLeafHash::to_byte_array(self) -> as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapLeafHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::taproot::TapLeafHash::to_raw_hash(self) -> bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapLeafTag::clone(&self) -> bitcoin::taproot::TapLeafTag @@ -9031,6 +9133,7 @@ pub fn bitcoin::taproot::TapLeafTag::eq(&self, other: &bitcoin::taproot::TapLeaf pub fn bitcoin::taproot::TapLeafTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H) pub fn bitcoin::taproot::TapLeafTag::partial_cmp(&self, other: &bitcoin::taproot::TapLeafTag) -> core::option::Option pub fn bitcoin::taproot::TapNodeHash::all_zeros() -> Self +pub fn bitcoin::taproot::TapNodeHash::as_byte_array(&self) -> & as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapNodeHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::taproot::TapNodeHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapNodeHash::as_ref(&self) -> &[u8; 32] @@ -9039,23 +9142,28 @@ pub fn bitcoin::taproot::TapNodeHash::assume_hidden(hash: [u8; 32]) -> bitcoin:: pub fn bitcoin::taproot::TapNodeHash::borrow(&self) -> &[u8] pub fn bitcoin::taproot::TapNodeHash::clone(&self) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::cmp(&self, other: &bitcoin::taproot::TapNodeHash) -> core::cmp::Ordering -pub fn bitcoin::taproot::TapNodeHash::engine() -> Self::Engine +pub fn bitcoin::taproot::TapNodeHash::engine() -> as bitcoin_hashes::Hash>::Engine pub fn bitcoin::taproot::TapNodeHash::eq(&self, other: &bitcoin::taproot::TapNodeHash) -> bool pub fn bitcoin::taproot::TapNodeHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::taproot::TapNodeHash::from(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from(leaf: &bitcoin::taproot::LeafNode) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from(leaf: bitcoin::taproot::LeafNode) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from(leaf: bitcoin::taproot::TapLeafHash) -> bitcoin::taproot::TapNodeHash +pub fn bitcoin::taproot::TapNodeHash::from_byte_array(bytes: as bitcoin_hashes::Hash>::Bytes) -> Self pub fn bitcoin::taproot::TapNodeHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::taproot::TapNodeHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::taproot::TapNodeHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> Self +pub fn bitcoin::taproot::TapNodeHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from_node_hashes(a: bitcoin::taproot::TapNodeHash, b: bitcoin::taproot::TapNodeHash) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from_raw_hash(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from_script(script: &bitcoin::blockdata::script::Script, ver: bitcoin::taproot::LeafVersion) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::taproot::TapNodeHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::taproot::TapNodeHash::hash(data: &[u8]) -> Self pub fn bitcoin::taproot::TapNodeHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::taproot::TapNodeHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::taproot::TapNodeHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::taproot::TapNodeHash::partial_cmp(&self, other: &bitcoin::taproot::TapNodeHash) -> core::option::Option +pub fn bitcoin::taproot::TapNodeHash::to_byte_array(self) -> as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapNodeHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::taproot::TapNodeHash::to_raw_hash(self) -> bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapTree::clone(&self) -> bitcoin::taproot::TapTree @@ -9069,6 +9177,7 @@ pub fn bitcoin::taproot::TapTree::script_leaves(&self) -> bitcoin::taproot::Scri pub fn bitcoin::taproot::TapTree::try_from(builder: bitcoin::taproot::TaprootBuilder) -> core::result::Result pub fn bitcoin::taproot::TapTree::try_from(node_info: bitcoin::taproot::NodeInfo) -> core::result::Result pub fn bitcoin::taproot::TapTweakHash::all_zeros() -> Self +pub fn bitcoin::taproot::TapTweakHash::as_byte_array(&self) -> & as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapTweakHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::taproot::TapTweakHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapTweakHash::as_ref(&self) -> &[u8; 32] @@ -9076,21 +9185,26 @@ pub fn bitcoin::taproot::TapTweakHash::as_ref(&self) -> &[u8] pub fn bitcoin::taproot::TapTweakHash::borrow(&self) -> &[u8] pub fn bitcoin::taproot::TapTweakHash::clone(&self) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::cmp(&self, other: &bitcoin::taproot::TapTweakHash) -> core::cmp::Ordering -pub fn bitcoin::taproot::TapTweakHash::engine() -> Self::Engine +pub fn bitcoin::taproot::TapTweakHash::engine() -> as bitcoin_hashes::Hash>::Engine pub fn bitcoin::taproot::TapTweakHash::eq(&self, other: &bitcoin::taproot::TapTweakHash) -> bool pub fn bitcoin::taproot::TapTweakHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::taproot::TapTweakHash::from(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::from(spend_info: &bitcoin::taproot::TaprootSpendInfo) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::from(spend_info: bitcoin::taproot::TaprootSpendInfo) -> bitcoin::taproot::TapTweakHash +pub fn bitcoin::taproot::TapTweakHash::from_byte_array(bytes: as bitcoin_hashes::Hash>::Bytes) -> Self pub fn bitcoin::taproot::TapTweakHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::taproot::TapTweakHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::taproot::TapTweakHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> Self +pub fn bitcoin::taproot::TapTweakHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::from_key_and_tweak(internal_key: bitcoin::key::UntweakedPublicKey, merkle_root: core::option::Option) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::from_raw_hash(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::taproot::TapTweakHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::taproot::TapTweakHash::hash(data: &[u8]) -> Self pub fn bitcoin::taproot::TapTweakHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::taproot::TapTweakHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::taproot::TapTweakHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::taproot::TapTweakHash::partial_cmp(&self, other: &bitcoin::taproot::TapTweakHash) -> core::option::Option +pub fn bitcoin::taproot::TapTweakHash::to_byte_array(self) -> as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapTweakHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::taproot::TapTweakHash::to_raw_hash(self) -> bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapTweakHash::to_scalar(self) -> secp256k1::scalar::Scalar diff --git a/api/bitcoin/no-features.txt b/api/bitcoin/no-features.txt index 2126fff0a..bbe4c5af7 100644 --- a/api/bitcoin/no-features.txt +++ b/api/bitcoin/no-features.txt @@ -5937,6 +5937,7 @@ pub fn bitcoin::EcdsaSighashType::from_str(s: &str) -> core::result::Result(&self, state: &mut __H) pub fn bitcoin::EcdsaSighashType::to_u32(self) -> u32 pub fn bitcoin::LegacySighash::all_zeros() -> Self +pub fn bitcoin::LegacySighash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::LegacySighash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::LegacySighash::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::LegacySighash::as_ref(&self) -> &[u8; 32] @@ -5944,18 +5945,23 @@ pub fn bitcoin::LegacySighash::as_ref(&self) -> &[u8] pub fn bitcoin::LegacySighash::borrow(&self) -> &[u8] pub fn bitcoin::LegacySighash::clone(&self) -> bitcoin::LegacySighash pub fn bitcoin::LegacySighash::cmp(&self, other: &bitcoin::LegacySighash) -> core::cmp::Ordering -pub fn bitcoin::LegacySighash::engine() -> Self::Engine +pub fn bitcoin::LegacySighash::engine() -> ::Engine pub fn bitcoin::LegacySighash::eq(&self, other: &bitcoin::LegacySighash) -> bool pub fn bitcoin::LegacySighash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::LegacySighash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::LegacySighash +pub fn bitcoin::LegacySighash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::LegacySighash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::LegacySighash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::LegacySighash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::LegacySighash::from_engine(e: ::Engine) -> bitcoin::LegacySighash pub fn bitcoin::LegacySighash::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::LegacySighash pub fn bitcoin::LegacySighash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::LegacySighash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::LegacySighash::hash(data: &[u8]) -> Self pub fn bitcoin::LegacySighash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::LegacySighash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::LegacySighash::index(&self, index: I) -> &Self::Output pub fn bitcoin::LegacySighash::partial_cmp(&self, other: &bitcoin::LegacySighash) -> core::option::Option +pub fn bitcoin::LegacySighash::to_byte_array(self) -> ::Bytes pub fn bitcoin::LegacySighash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::LegacySighash::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::MerkleBlock::clone(&self) -> bitcoin::MerkleBlock @@ -5980,6 +5986,7 @@ pub fn bitcoin::PrivateKey::public_key(&self, se pub fn bitcoin::PrivateKey::to_bytes(self) -> alloc::vec::Vec pub fn bitcoin::PrivateKey::to_wif(self) -> alloc::string::String pub fn bitcoin::PubkeyHash::all_zeros() -> Self +pub fn bitcoin::PubkeyHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::PubkeyHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::PubkeyHash::as_raw_hash(&self) -> &bitcoin_hashes::hash160::Hash pub fn bitcoin::PubkeyHash::as_ref(&self) -> &[u8; 20] @@ -5988,7 +5995,7 @@ pub fn bitcoin::PubkeyHash::as_ref(&self) -> &bitcoin::blockdata::script::PushBy pub fn bitcoin::PubkeyHash::borrow(&self) -> &[u8] pub fn bitcoin::PubkeyHash::clone(&self) -> bitcoin::PubkeyHash pub fn bitcoin::PubkeyHash::cmp(&self, other: &bitcoin::PubkeyHash) -> core::cmp::Ordering -pub fn bitcoin::PubkeyHash::engine() -> Self::Engine +pub fn bitcoin::PubkeyHash::engine() -> ::Engine pub fn bitcoin::PubkeyHash::eq(&self, other: &bitcoin::PubkeyHash) -> bool pub fn bitcoin::PubkeyHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::PubkeyHash::from(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::PubkeyHash @@ -5996,14 +6003,19 @@ pub fn bitcoin::PubkeyHash::from(key: &bitcoin::CompressedPublicKey) -> Self pub fn bitcoin::PubkeyHash::from(key: &bitcoin::PublicKey) -> bitcoin::PubkeyHash pub fn bitcoin::PubkeyHash::from(key: bitcoin::CompressedPublicKey) -> Self pub fn bitcoin::PubkeyHash::from(key: bitcoin::PublicKey) -> bitcoin::PubkeyHash +pub fn bitcoin::PubkeyHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::PubkeyHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::PubkeyHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::PubkeyHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::PubkeyHash::from_engine(e: ::Engine) -> bitcoin::PubkeyHash pub fn bitcoin::PubkeyHash::from_raw_hash(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::PubkeyHash pub fn bitcoin::PubkeyHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::PubkeyHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::PubkeyHash::hash(data: &[u8]) -> Self pub fn bitcoin::PubkeyHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::PubkeyHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::PubkeyHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::PubkeyHash::partial_cmp(&self, other: &bitcoin::PubkeyHash) -> core::option::Option +pub fn bitcoin::PubkeyHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::PubkeyHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::PubkeyHash::to_raw_hash(self) -> bitcoin_hashes::hash160::Hash pub fn bitcoin::PublicKey::clone(&self) -> bitcoin::PublicKey @@ -6028,6 +6040,7 @@ pub fn bitcoin::PublicKey::verify(&self, se pub fn bitcoin::PublicKey::wpubkey_hash(&self) -> core::result::Result pub fn bitcoin::PublicKey::write_into(&self, writer: &mut W) -> core::result::Result<(), bitcoin_io::error::Error> pub fn bitcoin::SegwitV0Sighash::all_zeros() -> Self +pub fn bitcoin::SegwitV0Sighash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::SegwitV0Sighash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::SegwitV0Sighash::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::SegwitV0Sighash::as_ref(&self) -> &[u8; 32] @@ -6035,21 +6048,27 @@ pub fn bitcoin::SegwitV0Sighash::as_ref(&self) -> &[u8] pub fn bitcoin::SegwitV0Sighash::borrow(&self) -> &[u8] pub fn bitcoin::SegwitV0Sighash::clone(&self) -> bitcoin::SegwitV0Sighash pub fn bitcoin::SegwitV0Sighash::cmp(&self, other: &bitcoin::SegwitV0Sighash) -> core::cmp::Ordering -pub fn bitcoin::SegwitV0Sighash::engine() -> Self::Engine +pub fn bitcoin::SegwitV0Sighash::engine() -> ::Engine pub fn bitcoin::SegwitV0Sighash::eq(&self, other: &bitcoin::SegwitV0Sighash) -> bool pub fn bitcoin::SegwitV0Sighash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::SegwitV0Sighash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::SegwitV0Sighash +pub fn bitcoin::SegwitV0Sighash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::SegwitV0Sighash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::SegwitV0Sighash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::SegwitV0Sighash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::SegwitV0Sighash::from_engine(e: ::Engine) -> bitcoin::SegwitV0Sighash pub fn bitcoin::SegwitV0Sighash::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::SegwitV0Sighash pub fn bitcoin::SegwitV0Sighash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::SegwitV0Sighash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::SegwitV0Sighash::hash(data: &[u8]) -> Self pub fn bitcoin::SegwitV0Sighash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::SegwitV0Sighash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::SegwitV0Sighash::index(&self, index: I) -> &Self::Output pub fn bitcoin::SegwitV0Sighash::partial_cmp(&self, other: &bitcoin::SegwitV0Sighash) -> core::option::Option +pub fn bitcoin::SegwitV0Sighash::to_byte_array(self) -> ::Bytes pub fn bitcoin::SegwitV0Sighash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::SegwitV0Sighash::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::TapSighash::all_zeros() -> Self +pub fn bitcoin::TapSighash::as_byte_array(&self) -> & as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::TapSighash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::TapSighash::as_raw_hash(&self) -> &bitcoin_hashes::sha256t::Hash pub fn bitcoin::TapSighash::as_ref(&self) -> &[u8; 32] @@ -6057,18 +6076,23 @@ pub fn bitcoin::TapSighash::as_ref(&self) -> &[u8] pub fn bitcoin::TapSighash::borrow(&self) -> &[u8] pub fn bitcoin::TapSighash::clone(&self) -> bitcoin::TapSighash pub fn bitcoin::TapSighash::cmp(&self, other: &bitcoin::TapSighash) -> core::cmp::Ordering -pub fn bitcoin::TapSighash::engine() -> Self::Engine +pub fn bitcoin::TapSighash::engine() -> as bitcoin_hashes::Hash>::Engine pub fn bitcoin::TapSighash::eq(&self, other: &bitcoin::TapSighash) -> bool pub fn bitcoin::TapSighash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::TapSighash::from(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::TapSighash +pub fn bitcoin::TapSighash::from_byte_array(bytes: as bitcoin_hashes::Hash>::Bytes) -> Self pub fn bitcoin::TapSighash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::TapSighash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::TapSighash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> Self +pub fn bitcoin::TapSighash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> bitcoin::TapSighash pub fn bitcoin::TapSighash::from_raw_hash(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::TapSighash pub fn bitcoin::TapSighash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::TapSighash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::TapSighash::hash(data: &[u8]) -> Self pub fn bitcoin::TapSighash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::TapSighash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::TapSighash::index(&self, index: I) -> &Self::Output pub fn bitcoin::TapSighash::partial_cmp(&self, other: &bitcoin::TapSighash) -> core::option::Option +pub fn bitcoin::TapSighash::to_byte_array(self) -> as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::TapSighash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::TapSighash::to_raw_hash(self) -> bitcoin_hashes::sha256t::Hash pub fn bitcoin::TapSighashTag::clone(&self) -> bitcoin::TapSighashTag @@ -6088,6 +6112,7 @@ pub fn bitcoin::TapSighashType::from_str(s: &str) -> core::result::Result(&self, state: &mut __H) pub fn bitcoin::TapSighashType::partial_cmp(&self, other: &bitcoin::TapSighashType) -> core::option::Option pub fn bitcoin::WPubkeyHash::all_zeros() -> Self +pub fn bitcoin::WPubkeyHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::WPubkeyHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::WPubkeyHash::as_raw_hash(&self) -> &bitcoin_hashes::hash160::Hash pub fn bitcoin::WPubkeyHash::as_ref(&self) -> &[u8; 20] @@ -6096,20 +6121,25 @@ pub fn bitcoin::WPubkeyHash::as_ref(&self) -> &bitcoin::blockdata::script::PushB pub fn bitcoin::WPubkeyHash::borrow(&self) -> &[u8] pub fn bitcoin::WPubkeyHash::clone(&self) -> bitcoin::WPubkeyHash pub fn bitcoin::WPubkeyHash::cmp(&self, other: &bitcoin::WPubkeyHash) -> core::cmp::Ordering -pub fn bitcoin::WPubkeyHash::engine() -> Self::Engine +pub fn bitcoin::WPubkeyHash::engine() -> ::Engine pub fn bitcoin::WPubkeyHash::eq(&self, other: &bitcoin::WPubkeyHash) -> bool pub fn bitcoin::WPubkeyHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::WPubkeyHash::from(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::WPubkeyHash pub fn bitcoin::WPubkeyHash::from(key: &bitcoin::CompressedPublicKey) -> Self pub fn bitcoin::WPubkeyHash::from(key: bitcoin::CompressedPublicKey) -> Self +pub fn bitcoin::WPubkeyHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::WPubkeyHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::WPubkeyHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::WPubkeyHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::WPubkeyHash::from_engine(e: ::Engine) -> bitcoin::WPubkeyHash pub fn bitcoin::WPubkeyHash::from_raw_hash(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::WPubkeyHash pub fn bitcoin::WPubkeyHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::WPubkeyHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::WPubkeyHash::hash(data: &[u8]) -> Self pub fn bitcoin::WPubkeyHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::WPubkeyHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::WPubkeyHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::WPubkeyHash::partial_cmp(&self, other: &bitcoin::WPubkeyHash) -> core::option::Option +pub fn bitcoin::WPubkeyHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::WPubkeyHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::WPubkeyHash::to_raw_hash(self) -> bitcoin_hashes::hash160::Hash pub fn bitcoin::address::Address::address_type(&self) -> core::option::Option @@ -6326,6 +6356,7 @@ pub fn bitcoin::bip158::Error::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> c pub fn bitcoin::bip158::Error::from(io: bitcoin_io::error::Error) -> Self pub fn bitcoin::bip158::Error::from(never: core::convert::Infallible) -> Self pub fn bitcoin::bip158::FilterHash::all_zeros() -> Self +pub fn bitcoin::bip158::FilterHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::bip158::FilterHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::bip158::FilterHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::bip158::FilterHash::as_ref(&self) -> &[u8; 32] @@ -6335,22 +6366,28 @@ pub fn bitcoin::bip158::FilterHash::clone(&self) -> bitcoin::bip158::FilterHash pub fn bitcoin::bip158::FilterHash::cmp(&self, other: &bitcoin::bip158::FilterHash) -> core::cmp::Ordering pub fn bitcoin::bip158::FilterHash::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::bip158::FilterHash::consensus_encode(&self, w: &mut W) -> core::result::Result -pub fn bitcoin::bip158::FilterHash::engine() -> Self::Engine +pub fn bitcoin::bip158::FilterHash::engine() -> ::Engine pub fn bitcoin::bip158::FilterHash::eq(&self, other: &bitcoin::bip158::FilterHash) -> bool pub fn bitcoin::bip158::FilterHash::filter_header(&self, previous_filter_header: &bitcoin::bip158::FilterHeader) -> bitcoin::bip158::FilterHeader pub fn bitcoin::bip158::FilterHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::bip158::FilterHash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::bip158::FilterHash +pub fn bitcoin::bip158::FilterHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::bip158::FilterHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::bip158::FilterHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::bip158::FilterHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::bip158::FilterHash::from_engine(e: ::Engine) -> bitcoin::bip158::FilterHash pub fn bitcoin::bip158::FilterHash::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::bip158::FilterHash pub fn bitcoin::bip158::FilterHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::bip158::FilterHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::bip158::FilterHash::hash(data: &[u8]) -> Self pub fn bitcoin::bip158::FilterHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::bip158::FilterHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::bip158::FilterHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::bip158::FilterHash::partial_cmp(&self, other: &bitcoin::bip158::FilterHash) -> core::option::Option +pub fn bitcoin::bip158::FilterHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::bip158::FilterHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::bip158::FilterHash::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::bip158::FilterHeader::all_zeros() -> Self +pub fn bitcoin::bip158::FilterHeader::as_byte_array(&self) -> &::Bytes pub fn bitcoin::bip158::FilterHeader::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::bip158::FilterHeader::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::bip158::FilterHeader::as_ref(&self) -> &[u8; 32] @@ -6360,18 +6397,23 @@ pub fn bitcoin::bip158::FilterHeader::clone(&self) -> bitcoin::bip158::FilterHea pub fn bitcoin::bip158::FilterHeader::cmp(&self, other: &bitcoin::bip158::FilterHeader) -> core::cmp::Ordering pub fn bitcoin::bip158::FilterHeader::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::bip158::FilterHeader::consensus_encode(&self, w: &mut W) -> core::result::Result -pub fn bitcoin::bip158::FilterHeader::engine() -> Self::Engine +pub fn bitcoin::bip158::FilterHeader::engine() -> ::Engine pub fn bitcoin::bip158::FilterHeader::eq(&self, other: &bitcoin::bip158::FilterHeader) -> bool pub fn bitcoin::bip158::FilterHeader::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::bip158::FilterHeader::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::bip158::FilterHeader +pub fn bitcoin::bip158::FilterHeader::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::bip158::FilterHeader::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::bip158::FilterHeader::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::bip158::FilterHeader::from_engine(e: ::Engine) -> Self +pub fn bitcoin::bip158::FilterHeader::from_engine(e: ::Engine) -> bitcoin::bip158::FilterHeader pub fn bitcoin::bip158::FilterHeader::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::bip158::FilterHeader pub fn bitcoin::bip158::FilterHeader::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::bip158::FilterHeader::from_str(s: &str) -> core::result::Result +pub fn bitcoin::bip158::FilterHeader::hash(data: &[u8]) -> Self pub fn bitcoin::bip158::FilterHeader::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::bip158::FilterHeader::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::bip158::FilterHeader::index(&self, index: I) -> &Self::Output pub fn bitcoin::bip158::FilterHeader::partial_cmp(&self, other: &bitcoin::bip158::FilterHeader) -> core::option::Option +pub fn bitcoin::bip158::FilterHeader::to_byte_array(self) -> ::Bytes pub fn bitcoin::bip158::FilterHeader::to_byte_array(self) -> Self::Bytes pub fn bitcoin::bip158::FilterHeader::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::bip158::GcsFilterReader::match_all(&self, reader: &mut R, query: I) -> core::result::Result where I: core::iter::traits::iterator::Iterator, ::Item: core::borrow::Borrow<[u8]>, R: bitcoin_io::BufRead + core::marker::Sized @@ -6490,6 +6532,7 @@ pub fn bitcoin::bip32::InvalidBase58PayloadLengthError::eq(&self, other: &bitcoi pub fn bitcoin::bip32::InvalidBase58PayloadLengthError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::bip32::InvalidBase58PayloadLengthError::invalid_base58_payload_length(&self) -> usize pub fn bitcoin::bip32::XKeyIdentifier::all_zeros() -> Self +pub fn bitcoin::bip32::XKeyIdentifier::as_byte_array(&self) -> &::Bytes pub fn bitcoin::bip32::XKeyIdentifier::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::bip32::XKeyIdentifier::as_raw_hash(&self) -> &bitcoin_hashes::hash160::Hash pub fn bitcoin::bip32::XKeyIdentifier::as_ref(&self) -> &[u8; 20] @@ -6497,20 +6540,25 @@ pub fn bitcoin::bip32::XKeyIdentifier::as_ref(&self) -> &[u8] pub fn bitcoin::bip32::XKeyIdentifier::borrow(&self) -> &[u8] pub fn bitcoin::bip32::XKeyIdentifier::clone(&self) -> bitcoin::bip32::XKeyIdentifier pub fn bitcoin::bip32::XKeyIdentifier::cmp(&self, other: &bitcoin::bip32::XKeyIdentifier) -> core::cmp::Ordering -pub fn bitcoin::bip32::XKeyIdentifier::engine() -> Self::Engine +pub fn bitcoin::bip32::XKeyIdentifier::engine() -> ::Engine pub fn bitcoin::bip32::XKeyIdentifier::eq(&self, other: &bitcoin::bip32::XKeyIdentifier) -> bool pub fn bitcoin::bip32::XKeyIdentifier::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::bip32::XKeyIdentifier::from(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::bip32::XKeyIdentifier pub fn bitcoin::bip32::XKeyIdentifier::from(key: &bitcoin::bip32::Xpub) -> bitcoin::bip32::XKeyIdentifier pub fn bitcoin::bip32::XKeyIdentifier::from(key: bitcoin::bip32::Xpub) -> bitcoin::bip32::XKeyIdentifier +pub fn bitcoin::bip32::XKeyIdentifier::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::bip32::XKeyIdentifier::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::bip32::XKeyIdentifier::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::bip32::XKeyIdentifier::from_engine(e: ::Engine) -> Self +pub fn bitcoin::bip32::XKeyIdentifier::from_engine(e: ::Engine) -> bitcoin::bip32::XKeyIdentifier pub fn bitcoin::bip32::XKeyIdentifier::from_raw_hash(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::bip32::XKeyIdentifier pub fn bitcoin::bip32::XKeyIdentifier::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::bip32::XKeyIdentifier::from_str(s: &str) -> core::result::Result +pub fn bitcoin::bip32::XKeyIdentifier::hash(data: &[u8]) -> Self pub fn bitcoin::bip32::XKeyIdentifier::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::bip32::XKeyIdentifier::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::bip32::XKeyIdentifier::index(&self, index: I) -> &Self::Output pub fn bitcoin::bip32::XKeyIdentifier::partial_cmp(&self, other: &bitcoin::bip32::XKeyIdentifier) -> core::option::Option +pub fn bitcoin::bip32::XKeyIdentifier::to_byte_array(self) -> ::Bytes pub fn bitcoin::bip32::XKeyIdentifier::to_byte_array(self) -> Self::Bytes pub fn bitcoin::bip32::XKeyIdentifier::to_raw_hash(self) -> bitcoin_hashes::hash160::Hash pub fn bitcoin::bip32::Xpriv::clone(&self) -> bitcoin::bip32::Xpriv @@ -6566,6 +6614,7 @@ pub fn bitcoin::blockdata::block::Block::total_size(&self) -> usize pub fn bitcoin::blockdata::block::Block::weight(&self) -> bitcoin_units::weight::Weight pub fn bitcoin::blockdata::block::Block::witness_root(&self) -> core::option::Option pub fn bitcoin::blockdata::block::BlockHash::all_zeros() -> Self +pub fn bitcoin::blockdata::block::BlockHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::block::BlockHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::block::BlockHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::BlockHash::as_ref(&self) -> &[u8; 32] @@ -6575,7 +6624,7 @@ pub fn bitcoin::blockdata::block::BlockHash::clone(&self) -> bitcoin::blockdata: pub fn bitcoin::blockdata::block::BlockHash::cmp(&self, other: &bitcoin::blockdata::block::BlockHash) -> core::cmp::Ordering pub fn bitcoin::blockdata::block::BlockHash::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::blockdata::block::BlockHash::consensus_encode(&self, w: &mut W) -> core::result::Result -pub fn bitcoin::blockdata::block::BlockHash::engine() -> Self::Engine +pub fn bitcoin::blockdata::block::BlockHash::engine() -> ::Engine pub fn bitcoin::blockdata::block::BlockHash::eq(&self, other: &bitcoin::blockdata::block::BlockHash) -> bool pub fn bitcoin::blockdata::block::BlockHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::block::BlockHash::from(block: &bitcoin::blockdata::block::Block) -> bitcoin::blockdata::block::BlockHash @@ -6583,14 +6632,19 @@ pub fn bitcoin::blockdata::block::BlockHash::from(block: bitcoin::blockdata::blo pub fn bitcoin::blockdata::block::BlockHash::from(header: &bitcoin::blockdata::block::Header) -> bitcoin::blockdata::block::BlockHash pub fn bitcoin::blockdata::block::BlockHash::from(header: bitcoin::blockdata::block::Header) -> bitcoin::blockdata::block::BlockHash pub fn bitcoin::blockdata::block::BlockHash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::BlockHash +pub fn bitcoin::blockdata::block::BlockHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::block::BlockHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::block::BlockHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::block::BlockHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::block::BlockHash::from_engine(e: ::Engine) -> bitcoin::blockdata::block::BlockHash pub fn bitcoin::blockdata::block::BlockHash::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::BlockHash pub fn bitcoin::blockdata::block::BlockHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::block::BlockHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::block::BlockHash::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::block::BlockHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::block::BlockHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::block::BlockHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::block::BlockHash::partial_cmp(&self, other: &bitcoin::blockdata::block::BlockHash) -> core::option::Option +pub fn bitcoin::blockdata::block::BlockHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::block::BlockHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::block::BlockHash::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::Header::block_hash(&self) -> bitcoin::blockdata::block::BlockHash @@ -6609,6 +6663,7 @@ pub fn bitcoin::blockdata::block::Header::target(&self) -> bitcoin::pow::Target pub fn bitcoin::blockdata::block::Header::validate_pow(&self, required_target: bitcoin::pow::Target) -> core::result::Result pub fn bitcoin::blockdata::block::Header::work(&self) -> bitcoin::pow::Work pub fn bitcoin::blockdata::block::TxMerkleNode::all_zeros() -> Self +pub fn bitcoin::blockdata::block::TxMerkleNode::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::block::TxMerkleNode::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::block::TxMerkleNode::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::TxMerkleNode::as_ref(&self) -> &[u8; 32] @@ -6618,19 +6673,24 @@ pub fn bitcoin::blockdata::block::TxMerkleNode::clone(&self) -> bitcoin::blockda pub fn bitcoin::blockdata::block::TxMerkleNode::cmp(&self, other: &bitcoin::blockdata::block::TxMerkleNode) -> core::cmp::Ordering pub fn bitcoin::blockdata::block::TxMerkleNode::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::blockdata::block::TxMerkleNode::consensus_encode(&self, w: &mut W) -> core::result::Result -pub fn bitcoin::blockdata::block::TxMerkleNode::engine() -> Self::Engine +pub fn bitcoin::blockdata::block::TxMerkleNode::engine() -> ::Engine pub fn bitcoin::blockdata::block::TxMerkleNode::eq(&self, other: &bitcoin::blockdata::block::TxMerkleNode) -> bool pub fn bitcoin::blockdata::block::TxMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::block::TxMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::TxMerkleNode pub fn bitcoin::blockdata::block::TxMerkleNode::from(txid: bitcoin::blockdata::transaction::Txid) -> Self +pub fn bitcoin::blockdata::block::TxMerkleNode::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::block::TxMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::block::TxMerkleNode::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::block::TxMerkleNode::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::block::TxMerkleNode::from_engine(e: ::Engine) -> bitcoin::blockdata::block::TxMerkleNode pub fn bitcoin::blockdata::block::TxMerkleNode::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::TxMerkleNode pub fn bitcoin::blockdata::block::TxMerkleNode::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::block::TxMerkleNode::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::block::TxMerkleNode::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::block::TxMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::block::TxMerkleNode::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::block::TxMerkleNode::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::block::TxMerkleNode::partial_cmp(&self, other: &bitcoin::blockdata::block::TxMerkleNode) -> core::option::Option +pub fn bitcoin::blockdata::block::TxMerkleNode::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::block::TxMerkleNode::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::block::TxMerkleNode::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::ValidationError::clone(&self) -> bitcoin::blockdata::block::ValidationError @@ -6649,6 +6709,7 @@ pub fn bitcoin::blockdata::block::Version::is_signalling_soft_fork(&self, bit: u pub fn bitcoin::blockdata::block::Version::partial_cmp(&self, other: &bitcoin::blockdata::block::Version) -> core::option::Option pub fn bitcoin::blockdata::block::Version::to_consensus(self) -> i32 pub fn bitcoin::blockdata::block::WitnessCommitment::all_zeros() -> Self +pub fn bitcoin::blockdata::block::WitnessCommitment::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::block::WitnessCommitment::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::block::WitnessCommitment::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::WitnessCommitment::as_ref(&self) -> &[u8; 32] @@ -6656,21 +6717,27 @@ pub fn bitcoin::blockdata::block::WitnessCommitment::as_ref(&self) -> &[u8] pub fn bitcoin::blockdata::block::WitnessCommitment::borrow(&self) -> &[u8] pub fn bitcoin::blockdata::block::WitnessCommitment::clone(&self) -> bitcoin::blockdata::block::WitnessCommitment pub fn bitcoin::blockdata::block::WitnessCommitment::cmp(&self, other: &bitcoin::blockdata::block::WitnessCommitment) -> core::cmp::Ordering -pub fn bitcoin::blockdata::block::WitnessCommitment::engine() -> Self::Engine +pub fn bitcoin::blockdata::block::WitnessCommitment::engine() -> ::Engine pub fn bitcoin::blockdata::block::WitnessCommitment::eq(&self, other: &bitcoin::blockdata::block::WitnessCommitment) -> bool pub fn bitcoin::blockdata::block::WitnessCommitment::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::block::WitnessCommitment::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::WitnessCommitment +pub fn bitcoin::blockdata::block::WitnessCommitment::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::block::WitnessCommitment::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::block::WitnessCommitment::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::block::WitnessCommitment::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::block::WitnessCommitment::from_engine(e: ::Engine) -> bitcoin::blockdata::block::WitnessCommitment pub fn bitcoin::blockdata::block::WitnessCommitment::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::WitnessCommitment pub fn bitcoin::blockdata::block::WitnessCommitment::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::block::WitnessCommitment::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::block::WitnessCommitment::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::block::WitnessCommitment::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::block::WitnessCommitment::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::block::WitnessCommitment::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::block::WitnessCommitment::partial_cmp(&self, other: &bitcoin::blockdata::block::WitnessCommitment) -> core::option::Option +pub fn bitcoin::blockdata::block::WitnessCommitment::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::block::WitnessCommitment::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::block::WitnessCommitment::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::WitnessMerkleNode::all_zeros() -> Self +pub fn bitcoin::blockdata::block::WitnessMerkleNode::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::block::WitnessMerkleNode::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::block::WitnessMerkleNode::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::block::WitnessMerkleNode::as_ref(&self) -> &[u8; 32] @@ -6680,19 +6747,24 @@ pub fn bitcoin::blockdata::block::WitnessMerkleNode::clone(&self) -> bitcoin::bl pub fn bitcoin::blockdata::block::WitnessMerkleNode::cmp(&self, other: &bitcoin::blockdata::block::WitnessMerkleNode) -> core::cmp::Ordering pub fn bitcoin::blockdata::block::WitnessMerkleNode::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::blockdata::block::WitnessMerkleNode::consensus_encode(&self, w: &mut W) -> core::result::Result -pub fn bitcoin::blockdata::block::WitnessMerkleNode::engine() -> Self::Engine +pub fn bitcoin::blockdata::block::WitnessMerkleNode::engine() -> ::Engine pub fn bitcoin::blockdata::block::WitnessMerkleNode::eq(&self, other: &bitcoin::blockdata::block::WitnessMerkleNode) -> bool pub fn bitcoin::blockdata::block::WitnessMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::block::WitnessMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::WitnessMerkleNode pub fn bitcoin::blockdata::block::WitnessMerkleNode::from(wtxid: bitcoin::blockdata::transaction::Wtxid) -> Self +pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_engine(e: ::Engine) -> bitcoin::blockdata::block::WitnessMerkleNode pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::block::WitnessMerkleNode pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::block::WitnessMerkleNode::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::block::WitnessMerkleNode::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::block::WitnessMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::block::WitnessMerkleNode::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::block::WitnessMerkleNode::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::block::WitnessMerkleNode::partial_cmp(&self, other: &bitcoin::blockdata::block::WitnessMerkleNode) -> core::option::Option +pub fn bitcoin::blockdata::block::WitnessMerkleNode::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::block::WitnessMerkleNode::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::block::WitnessMerkleNode::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::constants::ChainHash::as_byte_array(&self) -> &[u8; 32] @@ -7157,6 +7229,7 @@ pub fn bitcoin::blockdata::script::ScriptBuf::reserve_exact(&mut self, additiona pub fn bitcoin::blockdata::script::ScriptBuf::scan_and_push_verify(&mut self) pub fn bitcoin::blockdata::script::ScriptBuf::with_capacity(capacity: usize) -> Self pub fn bitcoin::blockdata::script::ScriptHash::all_zeros() -> Self +pub fn bitcoin::blockdata::script::ScriptHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::script::ScriptHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::script::ScriptHash::as_raw_hash(&self) -> &bitcoin_hashes::hash160::Hash pub fn bitcoin::blockdata::script::ScriptHash::as_ref(&self) -> &[u8; 20] @@ -7165,24 +7238,30 @@ pub fn bitcoin::blockdata::script::ScriptHash::as_ref(&self) -> &bitcoin::blockd pub fn bitcoin::blockdata::script::ScriptHash::borrow(&self) -> &[u8] pub fn bitcoin::blockdata::script::ScriptHash::clone(&self) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::cmp(&self, other: &bitcoin::blockdata::script::ScriptHash) -> core::cmp::Ordering -pub fn bitcoin::blockdata::script::ScriptHash::engine() -> Self::Engine +pub fn bitcoin::blockdata::script::ScriptHash::engine() -> ::Engine pub fn bitcoin::blockdata::script::ScriptHash::eq(&self, other: &bitcoin::blockdata::script::ScriptHash) -> bool pub fn bitcoin::blockdata::script::ScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::script::ScriptHash::from(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::from(script: &bitcoin::blockdata::script::Script) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::from(script: &bitcoin::blockdata::script::ScriptBuf) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::from(script: bitcoin::blockdata::script::ScriptBuf) -> bitcoin::blockdata::script::ScriptHash +pub fn bitcoin::blockdata::script::ScriptHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::script::ScriptHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::script::ScriptHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::script::ScriptHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::script::ScriptHash::from_engine(e: ::Engine) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::from_raw_hash(inner: bitcoin_hashes::hash160::Hash) -> bitcoin::blockdata::script::ScriptHash pub fn bitcoin::blockdata::script::ScriptHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::script::ScriptHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::script::ScriptHash::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::script::ScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::script::ScriptHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::script::ScriptHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::script::ScriptHash::partial_cmp(&self, other: &bitcoin::blockdata::script::ScriptHash) -> core::option::Option +pub fn bitcoin::blockdata::script::ScriptHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::script::ScriptHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::script::ScriptHash::to_raw_hash(self) -> bitcoin_hashes::hash160::Hash pub fn bitcoin::blockdata::script::WScriptHash::all_zeros() -> Self +pub fn bitcoin::blockdata::script::WScriptHash::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::script::WScriptHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::script::WScriptHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256::Hash pub fn bitcoin::blockdata::script::WScriptHash::as_ref(&self) -> &[u8; 32] @@ -7191,21 +7270,26 @@ pub fn bitcoin::blockdata::script::WScriptHash::as_ref(&self) -> &bitcoin::block pub fn bitcoin::blockdata::script::WScriptHash::borrow(&self) -> &[u8] pub fn bitcoin::blockdata::script::WScriptHash::clone(&self) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::cmp(&self, other: &bitcoin::blockdata::script::WScriptHash) -> core::cmp::Ordering -pub fn bitcoin::blockdata::script::WScriptHash::engine() -> Self::Engine +pub fn bitcoin::blockdata::script::WScriptHash::engine() -> ::Engine pub fn bitcoin::blockdata::script::WScriptHash::eq(&self, other: &bitcoin::blockdata::script::WScriptHash) -> bool pub fn bitcoin::blockdata::script::WScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::script::WScriptHash::from(inner: bitcoin_hashes::sha256::Hash) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::from(script: &bitcoin::blockdata::script::Script) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::from(script: &bitcoin::blockdata::script::ScriptBuf) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::from(script: bitcoin::blockdata::script::ScriptBuf) -> bitcoin::blockdata::script::WScriptHash +pub fn bitcoin::blockdata::script::WScriptHash::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::script::WScriptHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::script::WScriptHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::script::WScriptHash::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::script::WScriptHash::from_engine(e: ::Engine) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::from_raw_hash(inner: bitcoin_hashes::sha256::Hash) -> bitcoin::blockdata::script::WScriptHash pub fn bitcoin::blockdata::script::WScriptHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::script::WScriptHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::script::WScriptHash::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::script::WScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::script::WScriptHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::script::WScriptHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::script::WScriptHash::partial_cmp(&self, other: &bitcoin::blockdata::script::WScriptHash) -> core::option::Option +pub fn bitcoin::blockdata::script::WScriptHash::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::script::WScriptHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::script::WScriptHash::to_raw_hash(self) -> bitcoin_hashes::sha256::Hash pub fn bitcoin::blockdata::script::read_scriptbool(v: &[u8]) -> bool @@ -7369,6 +7453,7 @@ pub fn bitcoin::blockdata::transaction::TxOut::partial_cmp(&self, other: &bitcoi pub fn bitcoin::blockdata::transaction::TxOut::size(&self) -> usize pub fn bitcoin::blockdata::transaction::TxOut::weight(&self) -> bitcoin_units::weight::Weight pub fn bitcoin::blockdata::transaction::Txid::all_zeros() -> Self +pub fn bitcoin::blockdata::transaction::Txid::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::transaction::Txid::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::transaction::Txid::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::transaction::Txid::as_ref(&self) -> &[u8; 32] @@ -7378,20 +7463,25 @@ pub fn bitcoin::blockdata::transaction::Txid::clone(&self) -> bitcoin::blockdata pub fn bitcoin::blockdata::transaction::Txid::cmp(&self, other: &bitcoin::blockdata::transaction::Txid) -> core::cmp::Ordering pub fn bitcoin::blockdata::transaction::Txid::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::blockdata::transaction::Txid::consensus_encode(&self, w: &mut W) -> core::result::Result -pub fn bitcoin::blockdata::transaction::Txid::engine() -> Self::Engine +pub fn bitcoin::blockdata::transaction::Txid::engine() -> ::Engine pub fn bitcoin::blockdata::transaction::Txid::eq(&self, other: &bitcoin::blockdata::transaction::Txid) -> bool pub fn bitcoin::blockdata::transaction::Txid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::transaction::Txid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::transaction::Txid pub fn bitcoin::blockdata::transaction::Txid::from(tx: &bitcoin::blockdata::transaction::Transaction) -> bitcoin::blockdata::transaction::Txid pub fn bitcoin::blockdata::transaction::Txid::from(tx: bitcoin::blockdata::transaction::Transaction) -> bitcoin::blockdata::transaction::Txid +pub fn bitcoin::blockdata::transaction::Txid::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::transaction::Txid::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::transaction::Txid::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::transaction::Txid::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::transaction::Txid::from_engine(e: ::Engine) -> bitcoin::blockdata::transaction::Txid pub fn bitcoin::blockdata::transaction::Txid::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::transaction::Txid pub fn bitcoin::blockdata::transaction::Txid::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::transaction::Txid::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::transaction::Txid::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::transaction::Txid::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::transaction::Txid::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::transaction::Txid::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::transaction::Txid::partial_cmp(&self, other: &bitcoin::blockdata::transaction::Txid) -> core::option::Option +pub fn bitcoin::blockdata::transaction::Txid::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::transaction::Txid::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::transaction::Txid::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::transaction::Version::clone(&self) -> bitcoin::blockdata::transaction::Version @@ -7405,6 +7495,7 @@ pub fn bitcoin::blockdata::transaction::Version::is_standard(&self) -> bool pub fn bitcoin::blockdata::transaction::Version::non_standard(version: i32) -> bitcoin::blockdata::transaction::Version pub fn bitcoin::blockdata::transaction::Version::partial_cmp(&self, other: &bitcoin::blockdata::transaction::Version) -> core::option::Option pub fn bitcoin::blockdata::transaction::Wtxid::all_zeros() -> Self +pub fn bitcoin::blockdata::transaction::Wtxid::as_byte_array(&self) -> &::Bytes pub fn bitcoin::blockdata::transaction::Wtxid::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::blockdata::transaction::Wtxid::as_raw_hash(&self) -> &bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::transaction::Wtxid::as_ref(&self) -> &[u8; 32] @@ -7414,20 +7505,25 @@ pub fn bitcoin::blockdata::transaction::Wtxid::clone(&self) -> bitcoin::blockdat pub fn bitcoin::blockdata::transaction::Wtxid::cmp(&self, other: &bitcoin::blockdata::transaction::Wtxid) -> core::cmp::Ordering pub fn bitcoin::blockdata::transaction::Wtxid::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::blockdata::transaction::Wtxid::consensus_encode(&self, w: &mut W) -> core::result::Result -pub fn bitcoin::blockdata::transaction::Wtxid::engine() -> Self::Engine +pub fn bitcoin::blockdata::transaction::Wtxid::engine() -> ::Engine pub fn bitcoin::blockdata::transaction::Wtxid::eq(&self, other: &bitcoin::blockdata::transaction::Wtxid) -> bool pub fn bitcoin::blockdata::transaction::Wtxid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::blockdata::transaction::Wtxid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::transaction::Wtxid pub fn bitcoin::blockdata::transaction::Wtxid::from(tx: &bitcoin::blockdata::transaction::Transaction) -> bitcoin::blockdata::transaction::Wtxid pub fn bitcoin::blockdata::transaction::Wtxid::from(tx: bitcoin::blockdata::transaction::Transaction) -> bitcoin::blockdata::transaction::Wtxid +pub fn bitcoin::blockdata::transaction::Wtxid::from_byte_array(bytes: ::Bytes) -> Self pub fn bitcoin::blockdata::transaction::Wtxid::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::blockdata::transaction::Wtxid::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::blockdata::transaction::Wtxid::from_engine(e: ::Engine) -> Self +pub fn bitcoin::blockdata::transaction::Wtxid::from_engine(e: ::Engine) -> bitcoin::blockdata::transaction::Wtxid pub fn bitcoin::blockdata::transaction::Wtxid::from_raw_hash(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin::blockdata::transaction::Wtxid pub fn bitcoin::blockdata::transaction::Wtxid::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::blockdata::transaction::Wtxid::from_str(s: &str) -> core::result::Result +pub fn bitcoin::blockdata::transaction::Wtxid::hash(data: &[u8]) -> Self pub fn bitcoin::blockdata::transaction::Wtxid::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::blockdata::transaction::Wtxid::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::blockdata::transaction::Wtxid::index(&self, index: I) -> &Self::Output pub fn bitcoin::blockdata::transaction::Wtxid::partial_cmp(&self, other: &bitcoin::blockdata::transaction::Wtxid) -> core::option::Option +pub fn bitcoin::blockdata::transaction::Wtxid::to_byte_array(self) -> ::Bytes pub fn bitcoin::blockdata::transaction::Wtxid::to_byte_array(self) -> Self::Bytes pub fn bitcoin::blockdata::transaction::Wtxid::to_raw_hash(self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin::blockdata::transaction::effective_value(fee_rate: bitcoin_units::fee_rate::FeeRate, satisfaction_weight: bitcoin_units::weight::Weight, value: bitcoin_units::amount::Amount) -> core::option::Option @@ -8109,6 +8205,7 @@ pub fn bitcoin::taproot::TapLeaf::fmt(&self, f: &mut core::fmt::Formatter<'_>) - pub fn bitcoin::taproot::TapLeaf::hash<__H: core::hash::Hasher>(&self, state: &mut __H) pub fn bitcoin::taproot::TapLeaf::partial_cmp(&self, other: &bitcoin::taproot::TapLeaf) -> core::option::Option pub fn bitcoin::taproot::TapLeafHash::all_zeros() -> Self +pub fn bitcoin::taproot::TapLeafHash::as_byte_array(&self) -> & as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapLeafHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::taproot::TapLeafHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapLeafHash::as_ref(&self) -> &[u8; 32] @@ -8118,20 +8215,25 @@ pub fn bitcoin::taproot::TapLeafHash::clone(&self) -> bitcoin::taproot::TapLeafH pub fn bitcoin::taproot::TapLeafHash::cmp(&self, other: &bitcoin::taproot::TapLeafHash) -> core::cmp::Ordering pub fn bitcoin::taproot::TapLeafHash::consensus_decode(r: &mut R) -> core::result::Result pub fn bitcoin::taproot::TapLeafHash::consensus_encode(&self, w: &mut W) -> core::result::Result -pub fn bitcoin::taproot::TapLeafHash::engine() -> Self::Engine +pub fn bitcoin::taproot::TapLeafHash::engine() -> as bitcoin_hashes::Hash>::Engine pub fn bitcoin::taproot::TapLeafHash::eq(&self, other: &bitcoin::taproot::TapLeafHash) -> bool pub fn bitcoin::taproot::TapLeafHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::taproot::TapLeafHash::from(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapLeafHash pub fn bitcoin::taproot::TapLeafHash::from(script_path: bitcoin::sighash::ScriptPath<'s>) -> bitcoin::taproot::TapLeafHash +pub fn bitcoin::taproot::TapLeafHash::from_byte_array(bytes: as bitcoin_hashes::Hash>::Bytes) -> Self pub fn bitcoin::taproot::TapLeafHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::taproot::TapLeafHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::taproot::TapLeafHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> Self +pub fn bitcoin::taproot::TapLeafHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> bitcoin::taproot::TapLeafHash pub fn bitcoin::taproot::TapLeafHash::from_raw_hash(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapLeafHash pub fn bitcoin::taproot::TapLeafHash::from_script(script: &bitcoin::blockdata::script::Script, ver: bitcoin::taproot::LeafVersion) -> bitcoin::taproot::TapLeafHash pub fn bitcoin::taproot::TapLeafHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::taproot::TapLeafHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::taproot::TapLeafHash::hash(data: &[u8]) -> Self pub fn bitcoin::taproot::TapLeafHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::taproot::TapLeafHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::taproot::TapLeafHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::taproot::TapLeafHash::partial_cmp(&self, other: &bitcoin::taproot::TapLeafHash) -> core::option::Option +pub fn bitcoin::taproot::TapLeafHash::to_byte_array(self) -> as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapLeafHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::taproot::TapLeafHash::to_raw_hash(self) -> bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapLeafTag::clone(&self) -> bitcoin::taproot::TapLeafTag @@ -8142,6 +8244,7 @@ pub fn bitcoin::taproot::TapLeafTag::eq(&self, other: &bitcoin::taproot::TapLeaf pub fn bitcoin::taproot::TapLeafTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H) pub fn bitcoin::taproot::TapLeafTag::partial_cmp(&self, other: &bitcoin::taproot::TapLeafTag) -> core::option::Option pub fn bitcoin::taproot::TapNodeHash::all_zeros() -> Self +pub fn bitcoin::taproot::TapNodeHash::as_byte_array(&self) -> & as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapNodeHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::taproot::TapNodeHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapNodeHash::as_ref(&self) -> &[u8; 32] @@ -8150,23 +8253,28 @@ pub fn bitcoin::taproot::TapNodeHash::assume_hidden(hash: [u8; 32]) -> bitcoin:: pub fn bitcoin::taproot::TapNodeHash::borrow(&self) -> &[u8] pub fn bitcoin::taproot::TapNodeHash::clone(&self) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::cmp(&self, other: &bitcoin::taproot::TapNodeHash) -> core::cmp::Ordering -pub fn bitcoin::taproot::TapNodeHash::engine() -> Self::Engine +pub fn bitcoin::taproot::TapNodeHash::engine() -> as bitcoin_hashes::Hash>::Engine pub fn bitcoin::taproot::TapNodeHash::eq(&self, other: &bitcoin::taproot::TapNodeHash) -> bool pub fn bitcoin::taproot::TapNodeHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::taproot::TapNodeHash::from(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from(leaf: &bitcoin::taproot::LeafNode) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from(leaf: bitcoin::taproot::LeafNode) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from(leaf: bitcoin::taproot::TapLeafHash) -> bitcoin::taproot::TapNodeHash +pub fn bitcoin::taproot::TapNodeHash::from_byte_array(bytes: as bitcoin_hashes::Hash>::Bytes) -> Self pub fn bitcoin::taproot::TapNodeHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::taproot::TapNodeHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::taproot::TapNodeHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> Self +pub fn bitcoin::taproot::TapNodeHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from_node_hashes(a: bitcoin::taproot::TapNodeHash, b: bitcoin::taproot::TapNodeHash) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from_raw_hash(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from_script(script: &bitcoin::blockdata::script::Script, ver: bitcoin::taproot::LeafVersion) -> bitcoin::taproot::TapNodeHash pub fn bitcoin::taproot::TapNodeHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::taproot::TapNodeHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::taproot::TapNodeHash::hash(data: &[u8]) -> Self pub fn bitcoin::taproot::TapNodeHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::taproot::TapNodeHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::taproot::TapNodeHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::taproot::TapNodeHash::partial_cmp(&self, other: &bitcoin::taproot::TapNodeHash) -> core::option::Option +pub fn bitcoin::taproot::TapNodeHash::to_byte_array(self) -> as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapNodeHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::taproot::TapNodeHash::to_raw_hash(self) -> bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapTree::clone(&self) -> bitcoin::taproot::TapTree @@ -8180,6 +8288,7 @@ pub fn bitcoin::taproot::TapTree::script_leaves(&self) -> bitcoin::taproot::Scri pub fn bitcoin::taproot::TapTree::try_from(builder: bitcoin::taproot::TaprootBuilder) -> core::result::Result pub fn bitcoin::taproot::TapTree::try_from(node_info: bitcoin::taproot::NodeInfo) -> core::result::Result pub fn bitcoin::taproot::TapTweakHash::all_zeros() -> Self +pub fn bitcoin::taproot::TapTweakHash::as_byte_array(&self) -> & as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapTweakHash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin::taproot::TapTweakHash::as_raw_hash(&self) -> &bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapTweakHash::as_ref(&self) -> &[u8; 32] @@ -8187,21 +8296,26 @@ pub fn bitcoin::taproot::TapTweakHash::as_ref(&self) -> &[u8] pub fn bitcoin::taproot::TapTweakHash::borrow(&self) -> &[u8] pub fn bitcoin::taproot::TapTweakHash::clone(&self) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::cmp(&self, other: &bitcoin::taproot::TapTweakHash) -> core::cmp::Ordering -pub fn bitcoin::taproot::TapTweakHash::engine() -> Self::Engine +pub fn bitcoin::taproot::TapTweakHash::engine() -> as bitcoin_hashes::Hash>::Engine pub fn bitcoin::taproot::TapTweakHash::eq(&self, other: &bitcoin::taproot::TapTweakHash) -> bool pub fn bitcoin::taproot::TapTweakHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin::taproot::TapTweakHash::from(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::from(spend_info: &bitcoin::taproot::TaprootSpendInfo) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::from(spend_info: bitcoin::taproot::TaprootSpendInfo) -> bitcoin::taproot::TapTweakHash +pub fn bitcoin::taproot::TapTweakHash::from_byte_array(bytes: as bitcoin_hashes::Hash>::Bytes) -> Self pub fn bitcoin::taproot::TapTweakHash::from_byte_array(bytes: Self::Bytes) -> Self -pub fn bitcoin::taproot::TapTweakHash::from_engine(e: Self::Engine) -> Self +pub fn bitcoin::taproot::TapTweakHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> Self +pub fn bitcoin::taproot::TapTweakHash::from_engine(e: as bitcoin_hashes::Hash>::Engine) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::from_key_and_tweak(internal_key: bitcoin::key::UntweakedPublicKey, merkle_root: core::option::Option) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::from_raw_hash(inner: bitcoin_hashes::sha256t::Hash) -> bitcoin::taproot::TapTweakHash pub fn bitcoin::taproot::TapTweakHash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin::taproot::TapTweakHash::from_str(s: &str) -> core::result::Result +pub fn bitcoin::taproot::TapTweakHash::hash(data: &[u8]) -> Self pub fn bitcoin::taproot::TapTweakHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin::taproot::TapTweakHash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin::taproot::TapTweakHash::index(&self, index: I) -> &Self::Output pub fn bitcoin::taproot::TapTweakHash::partial_cmp(&self, other: &bitcoin::taproot::TapTweakHash) -> core::option::Option +pub fn bitcoin::taproot::TapTweakHash::to_byte_array(self) -> as bitcoin_hashes::Hash>::Bytes pub fn bitcoin::taproot::TapTweakHash::to_byte_array(self) -> Self::Bytes pub fn bitcoin::taproot::TapTweakHash::to_raw_hash(self) -> bitcoin_hashes::sha256t::Hash pub fn bitcoin::taproot::TapTweakHash::to_scalar(self) -> secp256k1::scalar::Scalar diff --git a/api/hashes/all-features.txt b/api/hashes/all-features.txt index ab2cbe77d..6b14979d1 100644 --- a/api/hashes/all-features.txt +++ b/api/hashes/all-features.txt @@ -534,9 +534,46 @@ pub const bitcoin_hashes::siphash24::Hash::DISPLAY_BACKWARD: bool pub const bitcoin_hashes::siphash24::Hash::LEN: usize pub const bitcoin_hashes::siphash24::Hash::N: usize pub const bitcoin_hashes::siphash24::HashEngine::BLOCK_SIZE: usize +pub const fn bitcoin_hashes::hash160::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::hash160::Hash::as_byte_array(&self) -> &[u8; 20] +pub const fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: [u8; 20]) -> Self +pub const fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> [u8; 20] +pub const fn bitcoin_hashes::ripemd160::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::ripemd160::Hash::as_byte_array(&self) -> &[u8; 20] +pub const fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: [u8; 20]) -> Self +pub const fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> [u8; 20] +pub const fn bitcoin_hashes::sha1::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha1::Hash::as_byte_array(&self) -> &[u8; 20] +pub const fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: [u8; 20]) -> Self +pub const fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> [u8; 20] +pub const fn bitcoin_hashes::sha256::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha256::Hash::as_byte_array(&self) -> &[u8; 32] pub const fn bitcoin_hashes::sha256::Hash::const_hash(bytes: &[u8]) -> Self +pub const fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: [u8; 32]) -> Self +pub const fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> [u8; 32] pub const fn bitcoin_hashes::sha256::Midstate::from_byte_array(inner: [u8; 32]) -> Self pub const fn bitcoin_hashes::sha256::Midstate::hash_tag(tag: &[u8]) -> Self +pub const fn bitcoin_hashes::sha256::Midstate::to_byte_array(self) -> [u8; 32] +pub const fn bitcoin_hashes::sha256d::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &[u8; 32] +pub const fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: [u8; 32]) -> Self +pub const fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> [u8; 32] +pub const fn bitcoin_hashes::sha384::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &[u8; 48] +pub const fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: [u8; 48]) -> Self +pub const fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> [u8; 48] +pub const fn bitcoin_hashes::sha512::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha512::Hash::as_byte_array(&self) -> &[u8; 64] +pub const fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: [u8; 64]) -> Self +pub const fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> [u8; 64] +pub const fn bitcoin_hashes::sha512_256::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha512_256::Hash::as_byte_array(&self) -> &[u8; 32] +pub const fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: [u8; 32]) -> Self +pub const fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> [u8; 32] +pub const fn bitcoin_hashes::siphash24::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::siphash24::Hash::as_byte_array(&self) -> &[u8; 8] +pub const fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: [u8; 8]) -> Self +pub const fn bitcoin_hashes::siphash24::Hash::to_byte_array(self) -> [u8; 8] pub const fn bitcoin_hashes::siphash24::HashEngine::new() -> bitcoin_hashes::siphash24::HashEngine pub const fn bitcoin_hashes::siphash24::HashEngine::with_keys(k0: u64, k1: u64) -> bitcoin_hashes::siphash24::HashEngine pub extern crate bitcoin_hashes::hex @@ -567,7 +604,7 @@ pub fn bitcoin_hashes::hash160::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::hash160::Hash::clone(&self) -> bitcoin_hashes::hash160::Hash pub fn bitcoin_hashes::hash160::Hash::cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::cmp::Ordering pub fn bitcoin_hashes::hash160::Hash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin_hashes::hash160::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::hash160::Hash::engine() -> bitcoin_hashes::sha256::HashEngine pub fn bitcoin_hashes::hash160::Hash::eq(&self, other: &bitcoin_hashes::hash160::Hash) -> bool pub fn bitcoin_hashes::hash160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -577,7 +614,9 @@ pub fn bitcoin_hashes::hash160::Hash::from_engine(e: bitcoin_hashes::sha256::Has pub fn bitcoin_hashes::hash160::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::hash160::Hash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::hash160::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::hash160::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::hash160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::hash160::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::hash160::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::hash160::Hash::json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema pub fn bitcoin_hashes::hash160::Hash::partial_cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::option::Option @@ -628,7 +667,7 @@ pub fn bitcoin_hashes::ripemd160::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::ripemd160::Hash::clone(&self) -> bitcoin_hashes::ripemd160::Hash pub fn bitcoin_hashes::ripemd160::Hash::cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::cmp::Ordering pub fn bitcoin_hashes::ripemd160::Hash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin_hashes::ripemd160::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::ripemd160::Hash::engine() -> bitcoin_hashes::ripemd160::HashEngine pub fn bitcoin_hashes::ripemd160::Hash::eq(&self, other: &bitcoin_hashes::ripemd160::Hash) -> bool pub fn bitcoin_hashes::ripemd160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -638,7 +677,9 @@ pub fn bitcoin_hashes::ripemd160::Hash::from_engine(e: bitcoin_hashes::ripemd160 pub fn bitcoin_hashes::ripemd160::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::ripemd160::Hash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::ripemd160::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::ripemd160::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::ripemd160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::ripemd160::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::ripemd160::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::ripemd160::Hash::json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema pub fn bitcoin_hashes::ripemd160::Hash::partial_cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::option::Option @@ -665,7 +706,7 @@ pub fn bitcoin_hashes::sha1::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha1::Hash::clone(&self) -> bitcoin_hashes::sha1::Hash pub fn bitcoin_hashes::sha1::Hash::cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::cmp::Ordering pub fn bitcoin_hashes::sha1::Hash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin_hashes::sha1::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha1::Hash::engine() -> bitcoin_hashes::sha1::HashEngine pub fn bitcoin_hashes::sha1::Hash::eq(&self, other: &bitcoin_hashes::sha1::Hash) -> bool pub fn bitcoin_hashes::sha1::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -675,7 +716,9 @@ pub fn bitcoin_hashes::sha1::Hash::from_engine(e: bitcoin_hashes::sha1::HashEngi pub fn bitcoin_hashes::sha1::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha1::Hash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha1::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha1::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha1::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::sha1::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha1::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha1::Hash::json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema pub fn bitcoin_hashes::sha1::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::option::Option @@ -699,7 +742,7 @@ pub fn bitcoin_hashes::sha256::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha256::Hash::clone(&self) -> bitcoin_hashes::sha256::Hash pub fn bitcoin_hashes::sha256::Hash::cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::cmp::Ordering pub fn bitcoin_hashes::sha256::Hash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin_hashes::sha256::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha256::Hash::engine() -> bitcoin_hashes::sha256::HashEngine pub fn bitcoin_hashes::sha256::Hash::eq(&self, other: &bitcoin_hashes::sha256::Hash) -> bool pub fn bitcoin_hashes::sha256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -709,8 +752,10 @@ pub fn bitcoin_hashes::sha256::Hash::from_engine(e: bitcoin_hashes::sha256::Hash pub fn bitcoin_hashes::sha256::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha256::Hash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha256::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha256::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) pub fn bitcoin_hashes::sha256::Hash::hash_again(&self) -> bitcoin_hashes::sha256d::Hash +pub fn bitcoin_hashes::sha256::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha256::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha256::Hash::json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema pub fn bitcoin_hashes::sha256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::option::Option @@ -743,7 +788,6 @@ pub fn bitcoin_hashes::sha256::Midstate::hash<__H: core::hash::Hasher>(&self, st pub fn bitcoin_hashes::sha256::Midstate::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha256::Midstate::partial_cmp(&self, other: &bitcoin_hashes::sha256::Midstate) -> core::option::Option pub fn bitcoin_hashes::sha256::Midstate::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> -pub fn bitcoin_hashes::sha256::Midstate::to_byte_array(self) -> [u8; 32] pub fn bitcoin_hashes::sha256d::Hash::all_zeros() -> Self pub fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8; 32] @@ -752,7 +796,7 @@ pub fn bitcoin_hashes::sha256d::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha256d::Hash::clone(&self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin_hashes::sha256d::Hash::cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::cmp::Ordering pub fn bitcoin_hashes::sha256d::Hash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin_hashes::sha256d::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha256d::Hash::engine() -> bitcoin_hashes::sha256::HashEngine pub fn bitcoin_hashes::sha256d::Hash::eq(&self, other: &bitcoin_hashes::sha256d::Hash) -> bool pub fn bitcoin_hashes::sha256d::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -762,7 +806,9 @@ pub fn bitcoin_hashes::sha256d::Hash::from_engine(e: bitcoin_hashes::sha256::Has pub fn bitcoin_hashes::sha256d::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha256d::Hash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha256d::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha256d::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha256d::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::sha256d::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha256d::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha256d::Hash::json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema pub fn bitcoin_hashes::sha256d::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::option::Option @@ -771,6 +817,7 @@ pub fn bitcoin_hashes::sha256d::Hash::serialize(&self pub fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> Self::Bytes pub fn bitcoin_hashes::sha256t::Hash::all_zeros() -> Self pub fn bitcoin_hashes::sha256t::Hash::as_byte_array(&self) -> &Self::Bytes +pub fn bitcoin_hashes::sha256t::Hash::as_byte_array(&self) -> &[u8; 32] pub fn bitcoin_hashes::sha256t::Hash::as_ref(&self) -> &[u8; 32] pub fn bitcoin_hashes::sha256t::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::sha256t::Hash::borrow(&self) -> &[u8] @@ -778,23 +825,27 @@ pub fn bitcoin_hashes::sha256t::Hash::clone(&self) -> Self pub fn bitcoin_hashes::sha256t::Hash::cmp(&self, other: &bitcoin_hashes::sha256t::Hash) -> core::cmp::Ordering pub fn bitcoin_hashes::sha256t::Hash::default() -> Self pub fn bitcoin_hashes::sha256t::Hash::deserialize>(d: D) -> core::result::Result, ::Error> -pub fn bitcoin_hashes::sha256t::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha256t::Hash::engine() -> bitcoin_hashes::sha256::HashEngine pub fn bitcoin_hashes::sha256t::Hash::eq(&self, other: &bitcoin_hashes::sha256t::Hash) -> bool pub fn bitcoin_hashes::sha256t::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha256t::Hash::from_byte_array(bytes: Self::Bytes) -> Self +pub fn bitcoin_hashes::sha256t::Hash::from_byte_array(bytes: [u8; 32]) -> Self pub fn bitcoin_hashes::sha256t::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self pub fn bitcoin_hashes::sha256t::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self pub fn bitcoin_hashes::sha256t::Hash::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256t::Hash pub fn bitcoin_hashes::sha256t::Hash::from_slice(sl: &[u8]) -> core::result::Result, bitcoin_hashes::FromSliceError> pub fn bitcoin_hashes::sha256t::Hash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha256t::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha256t::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha256t::Hash::hash(&self, h: &mut H) +pub fn bitcoin_hashes::sha256t::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha256t::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha256t::Hash::json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema pub fn bitcoin_hashes::sha256t::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256t::Hash) -> core::option::Option pub fn bitcoin_hashes::sha256t::Hash::schema_name() -> alloc::string::String pub fn bitcoin_hashes::sha256t::Hash::serialize(&self, s: S) -> core::result::Result<::Ok, ::Error> pub fn bitcoin_hashes::sha256t::Hash::to_byte_array(self) -> Self::Bytes +pub fn bitcoin_hashes::sha256t::Hash::to_byte_array(self) -> [u8; 32] pub fn bitcoin_hashes::sha256t::Tag::engine() -> bitcoin_hashes::sha256::HashEngine pub fn bitcoin_hashes::sha384::Hash::all_zeros() -> Self pub fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &Self::Bytes @@ -804,7 +855,7 @@ pub fn bitcoin_hashes::sha384::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha384::Hash::clone(&self) -> bitcoin_hashes::sha384::Hash pub fn bitcoin_hashes::sha384::Hash::cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::cmp::Ordering pub fn bitcoin_hashes::sha384::Hash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin_hashes::sha384::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha384::Hash::engine() -> bitcoin_hashes::sha384::HashEngine pub fn bitcoin_hashes::sha384::Hash::eq(&self, other: &bitcoin_hashes::sha384::Hash) -> bool pub fn bitcoin_hashes::sha384::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -814,7 +865,9 @@ pub fn bitcoin_hashes::sha384::Hash::from_engine(e: bitcoin_hashes::sha384::Hash pub fn bitcoin_hashes::sha384::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha384::Hash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha384::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha384::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha384::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::sha384::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha384::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha384::Hash::json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema pub fn bitcoin_hashes::sha384::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::option::Option @@ -834,7 +887,7 @@ pub fn bitcoin_hashes::sha512::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha512::Hash::clone(&self) -> bitcoin_hashes::sha512::Hash pub fn bitcoin_hashes::sha512::Hash::cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::cmp::Ordering pub fn bitcoin_hashes::sha512::Hash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin_hashes::sha512::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha512::Hash::engine() -> bitcoin_hashes::sha512::HashEngine pub fn bitcoin_hashes::sha512::Hash::eq(&self, other: &bitcoin_hashes::sha512::Hash) -> bool pub fn bitcoin_hashes::sha512::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -844,7 +897,9 @@ pub fn bitcoin_hashes::sha512::Hash::from_engine(e: bitcoin_hashes::sha512::Hash pub fn bitcoin_hashes::sha512::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha512::Hash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha512::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha512::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha512::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::sha512::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha512::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha512::Hash::json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema pub fn bitcoin_hashes::sha512::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::option::Option @@ -868,7 +923,7 @@ pub fn bitcoin_hashes::sha512_256::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha512_256::Hash::clone(&self) -> bitcoin_hashes::sha512_256::Hash pub fn bitcoin_hashes::sha512_256::Hash::cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::cmp::Ordering pub fn bitcoin_hashes::sha512_256::Hash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin_hashes::sha512_256::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha512_256::Hash::engine() -> bitcoin_hashes::sha512_256::HashEngine pub fn bitcoin_hashes::sha512_256::Hash::eq(&self, other: &bitcoin_hashes::sha512_256::Hash) -> bool pub fn bitcoin_hashes::sha512_256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -878,7 +933,9 @@ pub fn bitcoin_hashes::sha512_256::Hash::from_engine(e: bitcoin_hashes::sha512_2 pub fn bitcoin_hashes::sha512_256::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha512_256::Hash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha512_256::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha512_256::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha512_256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::sha512_256::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha512_256::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha512_256::Hash::json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema pub fn bitcoin_hashes::sha512_256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::option::Option @@ -899,7 +956,7 @@ pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::siphash24::Hash::clone(&self) -> bitcoin_hashes::siphash24::Hash pub fn bitcoin_hashes::siphash24::Hash::cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::cmp::Ordering pub fn bitcoin_hashes::siphash24::Hash::deserialize>(d: D) -> core::result::Result::Error> -pub fn bitcoin_hashes::siphash24::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::siphash24::Hash::engine() -> bitcoin_hashes::siphash24::HashEngine pub fn bitcoin_hashes::siphash24::Hash::eq(&self, other: &bitcoin_hashes::siphash24::Hash) -> bool pub fn bitcoin_hashes::siphash24::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -911,7 +968,9 @@ pub fn bitcoin_hashes::siphash24::Hash::from_slice(sl: &[u8]) -> core::result::R pub fn bitcoin_hashes::siphash24::Hash::from_slice_delegated(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::siphash24::Hash::from_str(s: &str) -> core::result::Result pub fn bitcoin_hashes::siphash24::Hash::from_u64(hash: u64) -> bitcoin_hashes::siphash24::Hash +pub fn bitcoin_hashes::siphash24::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::siphash24::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::siphash24::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::siphash24::Hash::hash_to_u64_with_keys(k0: u64, k1: u64, data: &[u8]) -> u64 pub fn bitcoin_hashes::siphash24::Hash::hash_with_keys(k0: u64, k1: u64, data: &[u8]) -> bitcoin_hashes::siphash24::Hash pub fn bitcoin_hashes::siphash24::Hash::index(&self, index: I) -> &Self::Output diff --git a/api/hashes/alloc-only.txt b/api/hashes/alloc-only.txt index baefc09f9..f03fb2d6b 100644 --- a/api/hashes/alloc-only.txt +++ b/api/hashes/alloc-only.txt @@ -462,9 +462,46 @@ pub const bitcoin_hashes::sha512_256::HashEngine::BLOCK_SIZE: usize pub const bitcoin_hashes::siphash24::Hash::DISPLAY_BACKWARD: bool pub const bitcoin_hashes::siphash24::Hash::LEN: usize pub const bitcoin_hashes::siphash24::HashEngine::BLOCK_SIZE: usize +pub const fn bitcoin_hashes::hash160::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::hash160::Hash::as_byte_array(&self) -> &[u8; 20] +pub const fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: [u8; 20]) -> Self +pub const fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> [u8; 20] +pub const fn bitcoin_hashes::ripemd160::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::ripemd160::Hash::as_byte_array(&self) -> &[u8; 20] +pub const fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: [u8; 20]) -> Self +pub const fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> [u8; 20] +pub const fn bitcoin_hashes::sha1::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha1::Hash::as_byte_array(&self) -> &[u8; 20] +pub const fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: [u8; 20]) -> Self +pub const fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> [u8; 20] +pub const fn bitcoin_hashes::sha256::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha256::Hash::as_byte_array(&self) -> &[u8; 32] pub const fn bitcoin_hashes::sha256::Hash::const_hash(bytes: &[u8]) -> Self +pub const fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: [u8; 32]) -> Self +pub const fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> [u8; 32] pub const fn bitcoin_hashes::sha256::Midstate::from_byte_array(inner: [u8; 32]) -> Self pub const fn bitcoin_hashes::sha256::Midstate::hash_tag(tag: &[u8]) -> Self +pub const fn bitcoin_hashes::sha256::Midstate::to_byte_array(self) -> [u8; 32] +pub const fn bitcoin_hashes::sha256d::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &[u8; 32] +pub const fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: [u8; 32]) -> Self +pub const fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> [u8; 32] +pub const fn bitcoin_hashes::sha384::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &[u8; 48] +pub const fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: [u8; 48]) -> Self +pub const fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> [u8; 48] +pub const fn bitcoin_hashes::sha512::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha512::Hash::as_byte_array(&self) -> &[u8; 64] +pub const fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: [u8; 64]) -> Self +pub const fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> [u8; 64] +pub const fn bitcoin_hashes::sha512_256::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha512_256::Hash::as_byte_array(&self) -> &[u8; 32] +pub const fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: [u8; 32]) -> Self +pub const fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> [u8; 32] +pub const fn bitcoin_hashes::siphash24::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::siphash24::Hash::as_byte_array(&self) -> &[u8; 8] +pub const fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: [u8; 8]) -> Self +pub const fn bitcoin_hashes::siphash24::Hash::to_byte_array(self) -> [u8; 8] pub const fn bitcoin_hashes::siphash24::HashEngine::new() -> bitcoin_hashes::siphash24::HashEngine pub const fn bitcoin_hashes::siphash24::HashEngine::with_keys(k0: u64, k1: u64) -> bitcoin_hashes::siphash24::HashEngine pub extern crate bitcoin_hashes::hex @@ -493,7 +530,7 @@ pub fn bitcoin_hashes::hash160::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::hash160::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::hash160::Hash::clone(&self) -> bitcoin_hashes::hash160::Hash pub fn bitcoin_hashes::hash160::Hash::cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::hash160::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::hash160::Hash::engine() -> bitcoin_hashes::sha256::HashEngine pub fn bitcoin_hashes::hash160::Hash::eq(&self, other: &bitcoin_hashes::hash160::Hash) -> bool pub fn bitcoin_hashes::hash160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -502,7 +539,9 @@ pub fn bitcoin_hashes::hash160::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self pub fn bitcoin_hashes::hash160::Hash::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::hash160::Hash pub fn bitcoin_hashes::hash160::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::hash160::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::hash160::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::hash160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::hash160::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::hash160::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::hash160::Hash::partial_cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::option::Option pub fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> Self::Bytes @@ -540,7 +579,7 @@ pub fn bitcoin_hashes::ripemd160::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::ripemd160::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::ripemd160::Hash::clone(&self) -> bitcoin_hashes::ripemd160::Hash pub fn bitcoin_hashes::ripemd160::Hash::cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::ripemd160::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::ripemd160::Hash::engine() -> bitcoin_hashes::ripemd160::HashEngine pub fn bitcoin_hashes::ripemd160::Hash::eq(&self, other: &bitcoin_hashes::ripemd160::Hash) -> bool pub fn bitcoin_hashes::ripemd160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -549,7 +588,9 @@ pub fn bitcoin_hashes::ripemd160::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Sel pub fn bitcoin_hashes::ripemd160::Hash::from_engine(e: bitcoin_hashes::ripemd160::HashEngine) -> bitcoin_hashes::ripemd160::Hash pub fn bitcoin_hashes::ripemd160::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::ripemd160::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::ripemd160::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::ripemd160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::ripemd160::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::ripemd160::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::ripemd160::Hash::partial_cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::option::Option pub fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> Self::Bytes @@ -565,7 +606,7 @@ pub fn bitcoin_hashes::sha1::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::sha1::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha1::Hash::clone(&self) -> bitcoin_hashes::sha1::Hash pub fn bitcoin_hashes::sha1::Hash::cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::sha1::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha1::Hash::engine() -> bitcoin_hashes::sha1::HashEngine pub fn bitcoin_hashes::sha1::Hash::eq(&self, other: &bitcoin_hashes::sha1::Hash) -> bool pub fn bitcoin_hashes::sha1::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -574,7 +615,9 @@ pub fn bitcoin_hashes::sha1::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self pub fn bitcoin_hashes::sha1::Hash::from_engine(e: bitcoin_hashes::sha1::HashEngine) -> bitcoin_hashes::sha1::Hash pub fn bitcoin_hashes::sha1::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha1::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha1::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha1::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::sha1::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha1::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha1::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::option::Option pub fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> Self::Bytes @@ -590,7 +633,7 @@ pub fn bitcoin_hashes::sha256::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::sha256::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha256::Hash::clone(&self) -> bitcoin_hashes::sha256::Hash pub fn bitcoin_hashes::sha256::Hash::cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::sha256::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha256::Hash::engine() -> bitcoin_hashes::sha256::HashEngine pub fn bitcoin_hashes::sha256::Hash::eq(&self, other: &bitcoin_hashes::sha256::Hash) -> bool pub fn bitcoin_hashes::sha256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -599,8 +642,10 @@ pub fn bitcoin_hashes::sha256::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self pub fn bitcoin_hashes::sha256::Hash::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256::Hash pub fn bitcoin_hashes::sha256::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha256::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha256::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) pub fn bitcoin_hashes::sha256::Hash::hash_again(&self) -> bitcoin_hashes::sha256d::Hash +pub fn bitcoin_hashes::sha256::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha256::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::option::Option pub fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> Self::Bytes @@ -623,7 +668,6 @@ pub fn bitcoin_hashes::sha256::Midstate::from_str(s: &str) -> core::result::Resu pub fn bitcoin_hashes::sha256::Midstate::hash<__H: core::hash::Hasher>(&self, state: &mut __H) pub fn bitcoin_hashes::sha256::Midstate::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha256::Midstate::partial_cmp(&self, other: &bitcoin_hashes::sha256::Midstate) -> core::option::Option -pub fn bitcoin_hashes::sha256::Midstate::to_byte_array(self) -> [u8; 32] pub fn bitcoin_hashes::sha256d::Hash::all_zeros() -> Self pub fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8; 32] @@ -631,7 +675,7 @@ pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::sha256d::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha256d::Hash::clone(&self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin_hashes::sha256d::Hash::cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::sha256d::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha256d::Hash::engine() -> bitcoin_hashes::sha256::HashEngine pub fn bitcoin_hashes::sha256d::Hash::eq(&self, other: &bitcoin_hashes::sha256d::Hash) -> bool pub fn bitcoin_hashes::sha256d::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -640,31 +684,38 @@ pub fn bitcoin_hashes::sha256d::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self pub fn bitcoin_hashes::sha256d::Hash::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin_hashes::sha256d::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha256d::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha256d::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha256d::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::sha256d::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha256d::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha256d::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::option::Option pub fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> Self::Bytes pub fn bitcoin_hashes::sha256t::Hash::all_zeros() -> Self pub fn bitcoin_hashes::sha256t::Hash::as_byte_array(&self) -> &Self::Bytes +pub fn bitcoin_hashes::sha256t::Hash::as_byte_array(&self) -> &[u8; 32] pub fn bitcoin_hashes::sha256t::Hash::as_ref(&self) -> &[u8; 32] pub fn bitcoin_hashes::sha256t::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::sha256t::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha256t::Hash::clone(&self) -> Self pub fn bitcoin_hashes::sha256t::Hash::cmp(&self, other: &bitcoin_hashes::sha256t::Hash) -> core::cmp::Ordering pub fn bitcoin_hashes::sha256t::Hash::default() -> Self -pub fn bitcoin_hashes::sha256t::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha256t::Hash::engine() -> bitcoin_hashes::sha256::HashEngine pub fn bitcoin_hashes::sha256t::Hash::eq(&self, other: &bitcoin_hashes::sha256t::Hash) -> bool pub fn bitcoin_hashes::sha256t::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha256t::Hash::from_byte_array(bytes: Self::Bytes) -> Self +pub fn bitcoin_hashes::sha256t::Hash::from_byte_array(bytes: [u8; 32]) -> Self pub fn bitcoin_hashes::sha256t::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self pub fn bitcoin_hashes::sha256t::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self pub fn bitcoin_hashes::sha256t::Hash::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256t::Hash pub fn bitcoin_hashes::sha256t::Hash::from_slice(sl: &[u8]) -> core::result::Result, bitcoin_hashes::FromSliceError> pub fn bitcoin_hashes::sha256t::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha256t::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha256t::Hash::hash(&self, h: &mut H) +pub fn bitcoin_hashes::sha256t::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha256t::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha256t::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256t::Hash) -> core::option::Option pub fn bitcoin_hashes::sha256t::Hash::to_byte_array(self) -> Self::Bytes +pub fn bitcoin_hashes::sha256t::Hash::to_byte_array(self) -> [u8; 32] pub fn bitcoin_hashes::sha256t::Tag::engine() -> bitcoin_hashes::sha256::HashEngine pub fn bitcoin_hashes::sha384::Hash::all_zeros() -> Self pub fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &Self::Bytes @@ -673,7 +724,7 @@ pub fn bitcoin_hashes::sha384::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::sha384::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha384::Hash::clone(&self) -> bitcoin_hashes::sha384::Hash pub fn bitcoin_hashes::sha384::Hash::cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::sha384::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha384::Hash::engine() -> bitcoin_hashes::sha384::HashEngine pub fn bitcoin_hashes::sha384::Hash::eq(&self, other: &bitcoin_hashes::sha384::Hash) -> bool pub fn bitcoin_hashes::sha384::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -682,7 +733,9 @@ pub fn bitcoin_hashes::sha384::Hash::from_bytes_ref(bytes: &[u8; 48]) -> &Self pub fn bitcoin_hashes::sha384::Hash::from_engine(e: bitcoin_hashes::sha384::HashEngine) -> bitcoin_hashes::sha384::Hash pub fn bitcoin_hashes::sha384::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha384::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha384::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha384::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::sha384::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha384::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha384::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::option::Option pub fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> Self::Bytes @@ -698,7 +751,7 @@ pub fn bitcoin_hashes::sha512::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::sha512::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha512::Hash::clone(&self) -> bitcoin_hashes::sha512::Hash pub fn bitcoin_hashes::sha512::Hash::cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::sha512::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha512::Hash::engine() -> bitcoin_hashes::sha512::HashEngine pub fn bitcoin_hashes::sha512::Hash::eq(&self, other: &bitcoin_hashes::sha512::Hash) -> bool pub fn bitcoin_hashes::sha512::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -707,7 +760,9 @@ pub fn bitcoin_hashes::sha512::Hash::from_bytes_ref(bytes: &[u8; 64]) -> &Self pub fn bitcoin_hashes::sha512::Hash::from_engine(e: bitcoin_hashes::sha512::HashEngine) -> bitcoin_hashes::sha512::Hash pub fn bitcoin_hashes::sha512::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha512::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha512::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha512::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::sha512::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha512::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha512::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::option::Option pub fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> Self::Bytes @@ -723,7 +778,7 @@ pub fn bitcoin_hashes::sha512_256::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::sha512_256::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha512_256::Hash::clone(&self) -> bitcoin_hashes::sha512_256::Hash pub fn bitcoin_hashes::sha512_256::Hash::cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::sha512_256::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha512_256::Hash::engine() -> bitcoin_hashes::sha512_256::HashEngine pub fn bitcoin_hashes::sha512_256::Hash::eq(&self, other: &bitcoin_hashes::sha512_256::Hash) -> bool pub fn bitcoin_hashes::sha512_256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -732,7 +787,9 @@ pub fn bitcoin_hashes::sha512_256::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Se pub fn bitcoin_hashes::sha512_256::Hash::from_engine(e: bitcoin_hashes::sha512_256::HashEngine) -> bitcoin_hashes::sha512_256::Hash pub fn bitcoin_hashes::sha512_256::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha512_256::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha512_256::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha512_256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::sha512_256::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha512_256::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha512_256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::option::Option pub fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> Self::Bytes @@ -749,7 +806,7 @@ pub fn bitcoin_hashes::siphash24::Hash::as_u64(&self) -> u64 pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::siphash24::Hash::clone(&self) -> bitcoin_hashes::siphash24::Hash pub fn bitcoin_hashes::siphash24::Hash::cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::siphash24::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::siphash24::Hash::engine() -> bitcoin_hashes::siphash24::HashEngine pub fn bitcoin_hashes::siphash24::Hash::eq(&self, other: &bitcoin_hashes::siphash24::Hash) -> bool pub fn bitcoin_hashes::siphash24::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -760,7 +817,9 @@ pub fn bitcoin_hashes::siphash24::Hash::from_engine_to_u64(e: bitcoin_hashes::si pub fn bitcoin_hashes::siphash24::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::siphash24::Hash::from_str(s: &str) -> core::result::Result pub fn bitcoin_hashes::siphash24::Hash::from_u64(hash: u64) -> bitcoin_hashes::siphash24::Hash +pub fn bitcoin_hashes::siphash24::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::siphash24::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::siphash24::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::siphash24::Hash::hash_to_u64_with_keys(k0: u64, k1: u64, data: &[u8]) -> u64 pub fn bitcoin_hashes::siphash24::Hash::hash_with_keys(k0: u64, k1: u64, data: &[u8]) -> bitcoin_hashes::siphash24::Hash pub fn bitcoin_hashes::siphash24::Hash::index(&self, index: I) -> &Self::Output diff --git a/api/hashes/no-features.txt b/api/hashes/no-features.txt index 134993aad..225243502 100644 --- a/api/hashes/no-features.txt +++ b/api/hashes/no-features.txt @@ -462,9 +462,46 @@ pub const bitcoin_hashes::sha512_256::HashEngine::BLOCK_SIZE: usize pub const bitcoin_hashes::siphash24::Hash::DISPLAY_BACKWARD: bool pub const bitcoin_hashes::siphash24::Hash::LEN: usize pub const bitcoin_hashes::siphash24::HashEngine::BLOCK_SIZE: usize +pub const fn bitcoin_hashes::hash160::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::hash160::Hash::as_byte_array(&self) -> &[u8; 20] +pub const fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: [u8; 20]) -> Self +pub const fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> [u8; 20] +pub const fn bitcoin_hashes::ripemd160::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::ripemd160::Hash::as_byte_array(&self) -> &[u8; 20] +pub const fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: [u8; 20]) -> Self +pub const fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> [u8; 20] +pub const fn bitcoin_hashes::sha1::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha1::Hash::as_byte_array(&self) -> &[u8; 20] +pub const fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: [u8; 20]) -> Self +pub const fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> [u8; 20] +pub const fn bitcoin_hashes::sha256::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha256::Hash::as_byte_array(&self) -> &[u8; 32] pub const fn bitcoin_hashes::sha256::Hash::const_hash(bytes: &[u8]) -> Self +pub const fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: [u8; 32]) -> Self +pub const fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> [u8; 32] pub const fn bitcoin_hashes::sha256::Midstate::from_byte_array(inner: [u8; 32]) -> Self pub const fn bitcoin_hashes::sha256::Midstate::hash_tag(tag: &[u8]) -> Self +pub const fn bitcoin_hashes::sha256::Midstate::to_byte_array(self) -> [u8; 32] +pub const fn bitcoin_hashes::sha256d::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &[u8; 32] +pub const fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: [u8; 32]) -> Self +pub const fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> [u8; 32] +pub const fn bitcoin_hashes::sha384::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &[u8; 48] +pub const fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: [u8; 48]) -> Self +pub const fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> [u8; 48] +pub const fn bitcoin_hashes::sha512::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha512::Hash::as_byte_array(&self) -> &[u8; 64] +pub const fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: [u8; 64]) -> Self +pub const fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> [u8; 64] +pub const fn bitcoin_hashes::sha512_256::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::sha512_256::Hash::as_byte_array(&self) -> &[u8; 32] +pub const fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: [u8; 32]) -> Self +pub const fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> [u8; 32] +pub const fn bitcoin_hashes::siphash24::Hash::all_zeros() -> Self +pub const fn bitcoin_hashes::siphash24::Hash::as_byte_array(&self) -> &[u8; 8] +pub const fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: [u8; 8]) -> Self +pub const fn bitcoin_hashes::siphash24::Hash::to_byte_array(self) -> [u8; 8] pub const fn bitcoin_hashes::siphash24::HashEngine::new() -> bitcoin_hashes::siphash24::HashEngine pub const fn bitcoin_hashes::siphash24::HashEngine::with_keys(k0: u64, k1: u64) -> bitcoin_hashes::siphash24::HashEngine pub extern crate bitcoin_hashes::hex @@ -493,7 +530,7 @@ pub fn bitcoin_hashes::hash160::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::hash160::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::hash160::Hash::clone(&self) -> bitcoin_hashes::hash160::Hash pub fn bitcoin_hashes::hash160::Hash::cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::hash160::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::hash160::Hash::engine() -> bitcoin_hashes::sha256::HashEngine pub fn bitcoin_hashes::hash160::Hash::eq(&self, other: &bitcoin_hashes::hash160::Hash) -> bool pub fn bitcoin_hashes::hash160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -502,7 +539,9 @@ pub fn bitcoin_hashes::hash160::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self pub fn bitcoin_hashes::hash160::Hash::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::hash160::Hash pub fn bitcoin_hashes::hash160::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::hash160::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::hash160::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::hash160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::hash160::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::hash160::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::hash160::Hash::partial_cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::option::Option pub fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> Self::Bytes @@ -539,7 +578,7 @@ pub fn bitcoin_hashes::ripemd160::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::ripemd160::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::ripemd160::Hash::clone(&self) -> bitcoin_hashes::ripemd160::Hash pub fn bitcoin_hashes::ripemd160::Hash::cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::ripemd160::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::ripemd160::Hash::engine() -> bitcoin_hashes::ripemd160::HashEngine pub fn bitcoin_hashes::ripemd160::Hash::eq(&self, other: &bitcoin_hashes::ripemd160::Hash) -> bool pub fn bitcoin_hashes::ripemd160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -548,7 +587,9 @@ pub fn bitcoin_hashes::ripemd160::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Sel pub fn bitcoin_hashes::ripemd160::Hash::from_engine(e: bitcoin_hashes::ripemd160::HashEngine) -> bitcoin_hashes::ripemd160::Hash pub fn bitcoin_hashes::ripemd160::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::ripemd160::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::ripemd160::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::ripemd160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::ripemd160::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::ripemd160::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::ripemd160::Hash::partial_cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::option::Option pub fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> Self::Bytes @@ -564,7 +605,7 @@ pub fn bitcoin_hashes::sha1::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::sha1::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha1::Hash::clone(&self) -> bitcoin_hashes::sha1::Hash pub fn bitcoin_hashes::sha1::Hash::cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::sha1::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha1::Hash::engine() -> bitcoin_hashes::sha1::HashEngine pub fn bitcoin_hashes::sha1::Hash::eq(&self, other: &bitcoin_hashes::sha1::Hash) -> bool pub fn bitcoin_hashes::sha1::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -573,7 +614,9 @@ pub fn bitcoin_hashes::sha1::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self pub fn bitcoin_hashes::sha1::Hash::from_engine(e: bitcoin_hashes::sha1::HashEngine) -> bitcoin_hashes::sha1::Hash pub fn bitcoin_hashes::sha1::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha1::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha1::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha1::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::sha1::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha1::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha1::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::option::Option pub fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> Self::Bytes @@ -589,7 +632,7 @@ pub fn bitcoin_hashes::sha256::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::sha256::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha256::Hash::clone(&self) -> bitcoin_hashes::sha256::Hash pub fn bitcoin_hashes::sha256::Hash::cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::sha256::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha256::Hash::engine() -> bitcoin_hashes::sha256::HashEngine pub fn bitcoin_hashes::sha256::Hash::eq(&self, other: &bitcoin_hashes::sha256::Hash) -> bool pub fn bitcoin_hashes::sha256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -598,8 +641,10 @@ pub fn bitcoin_hashes::sha256::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self pub fn bitcoin_hashes::sha256::Hash::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256::Hash pub fn bitcoin_hashes::sha256::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha256::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha256::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) pub fn bitcoin_hashes::sha256::Hash::hash_again(&self) -> bitcoin_hashes::sha256d::Hash +pub fn bitcoin_hashes::sha256::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha256::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::option::Option pub fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> Self::Bytes @@ -622,7 +667,6 @@ pub fn bitcoin_hashes::sha256::Midstate::from_str(s: &str) -> core::result::Resu pub fn bitcoin_hashes::sha256::Midstate::hash<__H: core::hash::Hasher>(&self, state: &mut __H) pub fn bitcoin_hashes::sha256::Midstate::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha256::Midstate::partial_cmp(&self, other: &bitcoin_hashes::sha256::Midstate) -> core::option::Option -pub fn bitcoin_hashes::sha256::Midstate::to_byte_array(self) -> [u8; 32] pub fn bitcoin_hashes::sha256d::Hash::all_zeros() -> Self pub fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &Self::Bytes pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8; 32] @@ -630,7 +674,7 @@ pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::sha256d::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha256d::Hash::clone(&self) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin_hashes::sha256d::Hash::cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::sha256d::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha256d::Hash::engine() -> bitcoin_hashes::sha256::HashEngine pub fn bitcoin_hashes::sha256d::Hash::eq(&self, other: &bitcoin_hashes::sha256d::Hash) -> bool pub fn bitcoin_hashes::sha256d::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -639,31 +683,38 @@ pub fn bitcoin_hashes::sha256d::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self pub fn bitcoin_hashes::sha256d::Hash::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256d::Hash pub fn bitcoin_hashes::sha256d::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha256d::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha256d::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha256d::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::sha256d::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha256d::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha256d::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::option::Option pub fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> Self::Bytes pub fn bitcoin_hashes::sha256t::Hash::all_zeros() -> Self pub fn bitcoin_hashes::sha256t::Hash::as_byte_array(&self) -> &Self::Bytes +pub fn bitcoin_hashes::sha256t::Hash::as_byte_array(&self) -> &[u8; 32] pub fn bitcoin_hashes::sha256t::Hash::as_ref(&self) -> &[u8; 32] pub fn bitcoin_hashes::sha256t::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::sha256t::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha256t::Hash::clone(&self) -> Self pub fn bitcoin_hashes::sha256t::Hash::cmp(&self, other: &bitcoin_hashes::sha256t::Hash) -> core::cmp::Ordering pub fn bitcoin_hashes::sha256t::Hash::default() -> Self -pub fn bitcoin_hashes::sha256t::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha256t::Hash::engine() -> bitcoin_hashes::sha256::HashEngine pub fn bitcoin_hashes::sha256t::Hash::eq(&self, other: &bitcoin_hashes::sha256t::Hash) -> bool pub fn bitcoin_hashes::sha256t::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha256t::Hash::from_byte_array(bytes: Self::Bytes) -> Self +pub fn bitcoin_hashes::sha256t::Hash::from_byte_array(bytes: [u8; 32]) -> Self pub fn bitcoin_hashes::sha256t::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self pub fn bitcoin_hashes::sha256t::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self pub fn bitcoin_hashes::sha256t::Hash::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256t::Hash pub fn bitcoin_hashes::sha256t::Hash::from_slice(sl: &[u8]) -> core::result::Result, bitcoin_hashes::FromSliceError> pub fn bitcoin_hashes::sha256t::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha256t::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha256t::Hash::hash(&self, h: &mut H) +pub fn bitcoin_hashes::sha256t::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha256t::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha256t::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256t::Hash) -> core::option::Option pub fn bitcoin_hashes::sha256t::Hash::to_byte_array(self) -> Self::Bytes +pub fn bitcoin_hashes::sha256t::Hash::to_byte_array(self) -> [u8; 32] pub fn bitcoin_hashes::sha256t::Tag::engine() -> bitcoin_hashes::sha256::HashEngine pub fn bitcoin_hashes::sha384::Hash::all_zeros() -> Self pub fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &Self::Bytes @@ -672,7 +723,7 @@ pub fn bitcoin_hashes::sha384::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::sha384::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha384::Hash::clone(&self) -> bitcoin_hashes::sha384::Hash pub fn bitcoin_hashes::sha384::Hash::cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::sha384::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha384::Hash::engine() -> bitcoin_hashes::sha384::HashEngine pub fn bitcoin_hashes::sha384::Hash::eq(&self, other: &bitcoin_hashes::sha384::Hash) -> bool pub fn bitcoin_hashes::sha384::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -681,7 +732,9 @@ pub fn bitcoin_hashes::sha384::Hash::from_bytes_ref(bytes: &[u8; 48]) -> &Self pub fn bitcoin_hashes::sha384::Hash::from_engine(e: bitcoin_hashes::sha384::HashEngine) -> bitcoin_hashes::sha384::Hash pub fn bitcoin_hashes::sha384::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha384::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha384::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha384::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::sha384::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha384::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha384::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::option::Option pub fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> Self::Bytes @@ -697,7 +750,7 @@ pub fn bitcoin_hashes::sha512::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::sha512::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha512::Hash::clone(&self) -> bitcoin_hashes::sha512::Hash pub fn bitcoin_hashes::sha512::Hash::cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::sha512::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha512::Hash::engine() -> bitcoin_hashes::sha512::HashEngine pub fn bitcoin_hashes::sha512::Hash::eq(&self, other: &bitcoin_hashes::sha512::Hash) -> bool pub fn bitcoin_hashes::sha512::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -706,7 +759,9 @@ pub fn bitcoin_hashes::sha512::Hash::from_bytes_ref(bytes: &[u8; 64]) -> &Self pub fn bitcoin_hashes::sha512::Hash::from_engine(e: bitcoin_hashes::sha512::HashEngine) -> bitcoin_hashes::sha512::Hash pub fn bitcoin_hashes::sha512::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha512::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha512::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha512::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::sha512::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha512::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha512::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::option::Option pub fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> Self::Bytes @@ -722,7 +777,7 @@ pub fn bitcoin_hashes::sha512_256::Hash::as_ref(&self) -> &[u8] pub fn bitcoin_hashes::sha512_256::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::sha512_256::Hash::clone(&self) -> bitcoin_hashes::sha512_256::Hash pub fn bitcoin_hashes::sha512_256::Hash::cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::sha512_256::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::sha512_256::Hash::engine() -> bitcoin_hashes::sha512_256::HashEngine pub fn bitcoin_hashes::sha512_256::Hash::eq(&self, other: &bitcoin_hashes::sha512_256::Hash) -> bool pub fn bitcoin_hashes::sha512_256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -731,7 +786,9 @@ pub fn bitcoin_hashes::sha512_256::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Se pub fn bitcoin_hashes::sha512_256::Hash::from_engine(e: bitcoin_hashes::sha512_256::HashEngine) -> bitcoin_hashes::sha512_256::Hash pub fn bitcoin_hashes::sha512_256::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::sha512_256::Hash::from_str(s: &str) -> core::result::Result +pub fn bitcoin_hashes::sha512_256::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::sha512_256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::sha512_256::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::sha512_256::Hash::index(&self, index: I) -> &Self::Output pub fn bitcoin_hashes::sha512_256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::option::Option pub fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> Self::Bytes @@ -748,7 +805,7 @@ pub fn bitcoin_hashes::siphash24::Hash::as_u64(&self) -> u64 pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8] pub fn bitcoin_hashes::siphash24::Hash::clone(&self) -> bitcoin_hashes::siphash24::Hash pub fn bitcoin_hashes::siphash24::Hash::cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::cmp::Ordering -pub fn bitcoin_hashes::siphash24::Hash::engine() -> Self::Engine +pub fn bitcoin_hashes::siphash24::Hash::engine() -> bitcoin_hashes::siphash24::HashEngine pub fn bitcoin_hashes::siphash24::Hash::eq(&self, other: &bitcoin_hashes::siphash24::Hash) -> bool pub fn bitcoin_hashes::siphash24::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: Self::Bytes) -> Self @@ -759,7 +816,9 @@ pub fn bitcoin_hashes::siphash24::Hash::from_engine_to_u64(e: bitcoin_hashes::si pub fn bitcoin_hashes::siphash24::Hash::from_slice(sl: &[u8]) -> core::result::Result pub fn bitcoin_hashes::siphash24::Hash::from_str(s: &str) -> core::result::Result pub fn bitcoin_hashes::siphash24::Hash::from_u64(hash: u64) -> bitcoin_hashes::siphash24::Hash +pub fn bitcoin_hashes::siphash24::Hash::hash(data: &[u8]) -> Self pub fn bitcoin_hashes::siphash24::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H) +pub fn bitcoin_hashes::siphash24::Hash::hash_byte_chunks(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator pub fn bitcoin_hashes::siphash24::Hash::hash_to_u64_with_keys(k0: u64, k1: u64, data: &[u8]) -> u64 pub fn bitcoin_hashes::siphash24::Hash::hash_with_keys(k0: u64, k1: u64, data: &[u8]) -> bitcoin_hashes::siphash24::Hash pub fn bitcoin_hashes::siphash24::Hash::index(&self, index: I) -> &Self::Output