Trait fedimint_core::BitcoinHash

pub trait BitcoinHash: Copy + Clone + PartialEq + Eq + PartialOrd + Ord + Hash + Debug + Display + LowerHex + Index<RangeFull, Output = [u8], Output = [u8], Output = [u8], Output = [u8], Output = u8> + Index<RangeFrom<usize>> + Index<RangeTo<usize>> + Index<Range<usize>> + Index<usize> + Borrow<[u8]> {
    type Engine: HashEngine;
    type Inner: FromHex;

    const LEN: usize;
    const DISPLAY_BACKWARD: bool = false;

    // Required methods
    fn from_engine(e: Self::Engine) -> Self;
    fn from_slice(sl: &[u8]) -> Result<Self, Error>;
    fn into_inner(self) -> Self::Inner;
    fn as_inner(&self) -> &Self::Inner;
    fn from_inner(inner: Self::Inner) -> Self;
    fn all_zeros() -> Self;

    // Provided methods
    fn engine() -> Self::Engine { ... }
    fn hash(data: &[u8]) -> Self { ... }
}

Trait which applies to hashes of all types.

Required Associated Types

type Engine: HashEngine

A hashing engine which bytes can be serialized into. It is expected to implement the io::Write trait, and to never return errors under any conditions.

type Inner: FromHex

The byte array that represents the hash internally.

Required Associated Constants

const LEN: usize

Length of the hash, in bytes.

Provided Associated Constants

const DISPLAY_BACKWARD: bool = false

Flag indicating whether user-visible serializations of this hash should be backward. For some reason Satoshi decided this should be true for Sha256dHash, so here we are.

Required Methods

fn from_engine(e: Self::Engine) -> Self

Produces a hash from the current state of a given engine.

fn from_slice(sl: &[u8]) -> Result<Self, Error>

Copies a byte slice into a hash object.

fn into_inner(self) -> Self::Inner

Unwraps the hash and returns the underlying byte array.

fn as_inner(&self) -> &Self::Inner

Unwraps the hash and returns a reference to the underlying byte array.

fn from_inner(inner: Self::Inner) -> Self

Constructs a hash from the underlying byte array.

fn all_zeros() -> Self

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.

Provided Methods

fn engine() -> Self::Engine

Constructs a new engine.

fn hash(data: &[u8]) -> Self

Hashes some bytes.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl Hash for BlockHash

type Engine = <Hash as Hash>::Engine

type Inner = <Hash as Hash>::Inner

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = true

fn engine() -> <BlockHash as Hash>::Engine

fn from_engine(e: <BlockHash as Hash>::Engine) -> BlockHash

fn from_slice(sl: &[u8]) -> Result<BlockHash, Error>

fn from_inner(inner: <BlockHash as Hash>::Inner) -> BlockHash

fn into_inner(self) -> <BlockHash as Hash>::Inner

fn as_inner(&self) -> &<BlockHash as Hash>::Inner

fn all_zeros() -> BlockHash

impl Hash for FilterHash

type Engine = <Hash as Hash>::Engine

type Inner = <Hash as Hash>::Inner

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = true

fn engine() -> <FilterHash as Hash>::Engine

fn from_engine(e: <FilterHash as Hash>::Engine) -> FilterHash

fn from_slice(sl: &[u8]) -> Result<FilterHash, Error>

fn from_inner(inner: <FilterHash as Hash>::Inner) -> FilterHash

fn into_inner(self) -> <FilterHash as Hash>::Inner

fn as_inner(&self) -> &<FilterHash as Hash>::Inner

fn all_zeros() -> FilterHash

impl Hash for FilterHeader

type Engine = <Hash as Hash>::Engine

type Inner = <Hash as Hash>::Inner

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = true

fn engine() -> <FilterHeader as Hash>::Engine

fn from_engine(e: <FilterHeader as Hash>::Engine) -> FilterHeader

fn from_slice(sl: &[u8]) -> Result<FilterHeader, Error>

fn from_inner(inner: <FilterHeader as Hash>::Inner) -> FilterHeader

fn into_inner(self) -> <FilterHeader as Hash>::Inner

fn as_inner(&self) -> &<FilterHeader as Hash>::Inner

fn all_zeros() -> FilterHeader

impl Hash for PubkeyHash

type Engine = <Hash as Hash>::Engine

type Inner = <Hash as Hash>::Inner

const LEN: usize = 20usize

const DISPLAY_BACKWARD: bool = false

fn engine() -> <PubkeyHash as Hash>::Engine

fn from_engine(e: <PubkeyHash as Hash>::Engine) -> PubkeyHash

fn from_slice(sl: &[u8]) -> Result<PubkeyHash, Error>

fn from_inner(inner: <PubkeyHash as Hash>::Inner) -> PubkeyHash

fn into_inner(self) -> <PubkeyHash as Hash>::Inner

fn as_inner(&self) -> &<PubkeyHash as Hash>::Inner

fn all_zeros() -> PubkeyHash

impl Hash for ScriptHash

type Engine = <Hash as Hash>::Engine

type Inner = <Hash as Hash>::Inner

const LEN: usize = 20usize

const DISPLAY_BACKWARD: bool = false

fn engine() -> <ScriptHash as Hash>::Engine

fn from_engine(e: <ScriptHash as Hash>::Engine) -> ScriptHash

fn from_slice(sl: &[u8]) -> Result<ScriptHash, Error>

fn from_inner(inner: <ScriptHash as Hash>::Inner) -> ScriptHash

fn into_inner(self) -> <ScriptHash as Hash>::Inner

fn as_inner(&self) -> &<ScriptHash as Hash>::Inner

fn all_zeros() -> ScriptHash

impl Hash for Sighash

type Engine = <Hash as Hash>::Engine

type Inner = <Hash as Hash>::Inner

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = true

fn engine() -> <Sighash as Hash>::Engine

fn from_engine(e: <Sighash as Hash>::Engine) -> Sighash

fn from_slice(sl: &[u8]) -> Result<Sighash, Error>

fn from_inner(inner: <Sighash as Hash>::Inner) -> Sighash

fn into_inner(self) -> <Sighash as Hash>::Inner

fn as_inner(&self) -> &<Sighash as Hash>::Inner

fn all_zeros() -> Sighash

impl Hash for TxMerkleNode

type Engine = <Hash as Hash>::Engine

type Inner = <Hash as Hash>::Inner

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = true

fn engine() -> <TxMerkleNode as Hash>::Engine

fn from_engine(e: <TxMerkleNode as Hash>::Engine) -> TxMerkleNode

fn from_slice(sl: &[u8]) -> Result<TxMerkleNode, Error>

fn from_inner(inner: <TxMerkleNode as Hash>::Inner) -> TxMerkleNode

fn into_inner(self) -> <TxMerkleNode as Hash>::Inner

fn as_inner(&self) -> &<TxMerkleNode as Hash>::Inner

fn all_zeros() -> TxMerkleNode

impl Hash for Txid

type Engine = <Hash as Hash>::Engine

type Inner = <Hash as Hash>::Inner

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = true

fn engine() -> <Txid as Hash>::Engine

fn from_engine(e: <Txid as Hash>::Engine) -> Txid

fn from_slice(sl: &[u8]) -> Result<Txid, Error>

fn from_inner(inner: <Txid as Hash>::Inner) -> Txid

fn into_inner(self) -> <Txid as Hash>::Inner

fn as_inner(&self) -> &<Txid as Hash>::Inner

fn all_zeros() -> Txid

impl Hash for WPubkeyHash

type Engine = <Hash as Hash>::Engine

type Inner = <Hash as Hash>::Inner

const LEN: usize = 20usize

const DISPLAY_BACKWARD: bool = false

fn engine() -> <WPubkeyHash as Hash>::Engine

fn from_engine(e: <WPubkeyHash as Hash>::Engine) -> WPubkeyHash

fn from_slice(sl: &[u8]) -> Result<WPubkeyHash, Error>

fn from_inner(inner: <WPubkeyHash as Hash>::Inner) -> WPubkeyHash

fn into_inner(self) -> <WPubkeyHash as Hash>::Inner

fn as_inner(&self) -> &<WPubkeyHash as Hash>::Inner

fn all_zeros() -> WPubkeyHash

impl Hash for WScriptHash

type Engine = <Hash as Hash>::Engine

type Inner = <Hash as Hash>::Inner

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = false

fn engine() -> <WScriptHash as Hash>::Engine

fn from_engine(e: <WScriptHash as Hash>::Engine) -> WScriptHash

fn from_slice(sl: &[u8]) -> Result<WScriptHash, Error>

fn from_inner(inner: <WScriptHash as Hash>::Inner) -> WScriptHash

fn into_inner(self) -> <WScriptHash as Hash>::Inner

fn as_inner(&self) -> &<WScriptHash as Hash>::Inner

fn all_zeros() -> WScriptHash

impl Hash for WitnessCommitment

type Engine = <Hash as Hash>::Engine

type Inner = <Hash as Hash>::Inner

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = true

fn engine() -> <WitnessCommitment as Hash>::Engine

fn from_engine(e: <WitnessCommitment as Hash>::Engine) -> WitnessCommitment

fn from_slice(sl: &[u8]) -> Result<WitnessCommitment, Error>

fn from_inner(inner: <WitnessCommitment as Hash>::Inner) -> WitnessCommitment

fn into_inner(self) -> <WitnessCommitment as Hash>::Inner

fn as_inner(&self) -> &<WitnessCommitment as Hash>::Inner

fn all_zeros() -> WitnessCommitment

impl Hash for WitnessMerkleNode

type Engine = <Hash as Hash>::Engine

type Inner = <Hash as Hash>::Inner

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = true

fn engine() -> <WitnessMerkleNode as Hash>::Engine

fn from_engine(e: <WitnessMerkleNode as Hash>::Engine) -> WitnessMerkleNode

fn from_slice(sl: &[u8]) -> Result<WitnessMerkleNode, Error>

fn from_inner(inner: <WitnessMerkleNode as Hash>::Inner) -> WitnessMerkleNode

fn into_inner(self) -> <WitnessMerkleNode as Hash>::Inner

fn as_inner(&self) -> &<WitnessMerkleNode as Hash>::Inner

fn all_zeros() -> WitnessMerkleNode

impl Hash for Wtxid

type Engine = <Hash as Hash>::Engine

type Inner = <Hash as Hash>::Inner

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = true

fn engine() -> <Wtxid as Hash>::Engine

fn from_engine(e: <Wtxid as Hash>::Engine) -> Wtxid

fn from_slice(sl: &[u8]) -> Result<Wtxid, Error>

fn from_inner(inner: <Wtxid as Hash>::Inner) -> Wtxid

fn into_inner(self) -> <Wtxid as Hash>::Inner

fn as_inner(&self) -> &<Wtxid as Hash>::Inner

fn all_zeros() -> Wtxid

impl Hash for XpubIdentifier

type Engine = <Hash as Hash>::Engine

type Inner = <Hash as Hash>::Inner

const LEN: usize = 20usize

const DISPLAY_BACKWARD: bool = false

fn engine() -> <XpubIdentifier as Hash>::Engine

fn from_engine(e: <XpubIdentifier as Hash>::Engine) -> XpubIdentifier

fn from_slice(sl: &[u8]) -> Result<XpubIdentifier, Error>

fn from_inner(inner: <XpubIdentifier as Hash>::Inner) -> XpubIdentifier

fn into_inner(self) -> <XpubIdentifier as Hash>::Inner

fn as_inner(&self) -> &<XpubIdentifier as Hash>::Inner

fn all_zeros() -> XpubIdentifier

impl Hash for TapBranchHash

type Engine = <Hash<TapBranchTag> as Hash>::Engine

type Inner = <Hash<TapBranchTag> as Hash>::Inner

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = false

fn engine() -> <TapBranchHash as Hash>::Engine

fn from_engine(e: <TapBranchHash as Hash>::Engine) -> TapBranchHash

fn from_slice(sl: &[u8]) -> Result<TapBranchHash, Error>

fn from_inner(inner: <TapBranchHash as Hash>::Inner) -> TapBranchHash

fn into_inner(self) -> <TapBranchHash as Hash>::Inner

fn as_inner(&self) -> &<TapBranchHash as Hash>::Inner

fn all_zeros() -> TapBranchHash

impl Hash for TapLeafHash

type Engine = <Hash<TapLeafTag> as Hash>::Engine

type Inner = <Hash<TapLeafTag> as Hash>::Inner

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = false

fn engine() -> <TapLeafHash as Hash>::Engine

fn from_engine(e: <TapLeafHash as Hash>::Engine) -> TapLeafHash

fn from_slice(sl: &[u8]) -> Result<TapLeafHash, Error>

fn from_inner(inner: <TapLeafHash as Hash>::Inner) -> TapLeafHash

fn into_inner(self) -> <TapLeafHash as Hash>::Inner

fn as_inner(&self) -> &<TapLeafHash as Hash>::Inner

fn all_zeros() -> TapLeafHash

impl Hash for TapSighashHash

type Engine = <Hash<TapSighashTag> as Hash>::Engine

type Inner = <Hash<TapSighashTag> as Hash>::Inner

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = false

fn engine() -> <TapSighashHash as Hash>::Engine

fn from_engine(e: <TapSighashHash as Hash>::Engine) -> TapSighashHash

fn from_slice(sl: &[u8]) -> Result<TapSighashHash, Error>

fn from_inner(inner: <TapSighashHash as Hash>::Inner) -> TapSighashHash

fn into_inner(self) -> <TapSighashHash as Hash>::Inner

fn as_inner(&self) -> &<TapSighashHash as Hash>::Inner

fn all_zeros() -> TapSighashHash

impl Hash for TapTweakHash

type Engine = <Hash<TapTweakTag> as Hash>::Engine

type Inner = <Hash<TapTweakTag> as Hash>::Inner

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = false

fn engine() -> <TapTweakHash as Hash>::Engine

fn from_engine(e: <TapTweakHash as Hash>::Engine) -> TapTweakHash

fn from_slice(sl: &[u8]) -> Result<TapTweakHash, Error>

fn from_inner(inner: <TapTweakHash as Hash>::Inner) -> TapTweakHash

fn into_inner(self) -> <TapTweakHash as Hash>::Inner

fn as_inner(&self) -> &<TapTweakHash as Hash>::Inner

fn all_zeros() -> TapTweakHash

impl Hash for Hash

const DISPLAY_BACKWARD: bool = false

sha256d has DISPLAY_BACKWARD as true

type Engine = HashEngine

type Inner = [u8; 32]

fn engine() -> HashEngine

fn from_engine(e: HashEngine) -> Hash

const LEN: usize = 32usize

fn from_slice(sl: &[u8]) -> Result<Hash, Error>

fn into_inner(self) -> <Hash as Hash>::Inner

fn as_inner(&self) -> &<Hash as Hash>::Inner

fn from_inner(inner: <Hash as Hash>::Inner) -> Hash

fn all_zeros() -> Hash

Implementors

impl Hash for bitcoin_hashes::hash160::Hash

type Engine = HashEngine

type Inner = [u8; 20]

const LEN: usize = 20usize

impl Hash for bitcoin_hashes::ripemd160::Hash

type Engine = HashEngine

type Inner = [u8; 20]

const LEN: usize = 20usize

impl Hash for bitcoin_hashes::sha1::Hash

type Engine = HashEngine

type Inner = [u8; 20]

const LEN: usize = 20usize

impl Hash for bitcoin_hashes::sha256::Hash

type Engine = HashEngine

type Inner = [u8; 32]

const LEN: usize = 32usize

impl Hash for bitcoin_hashes::sha256d::Hash

type Engine = HashEngine

type Inner = [u8; 32]

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = true

impl Hash for bitcoin_hashes::sha512::Hash

type Engine = HashEngine

type Inner = [u8; 64]

const LEN: usize = 64usize

impl Hash for bitcoin_hashes::siphash24::Hash

type Engine = HashEngine

type Inner = [u8; 8]

const LEN: usize = 8usize

impl Hash for TransactionId

type Engine = <Hash as Hash>::Engine

type Inner = <Hash as Hash>::Inner

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = false

impl<T> Hash for Hmac<T>

where T: Hash,

type Engine = HmacEngine<T>

type Inner = <T as Hash>::Inner

const LEN: usize = T::LEN

impl<T> Hash for bitcoin_hashes::sha256t::Hash<T>

where T: Tag,

type Engine = HashEngine

type Inner = [u8; 32]

const LEN: usize = 32usize

const DISPLAY_BACKWARD: bool = true