Struct bitcoin::pow::Target

pub struct Target(_);

A 256 bit integer representing target.

The SHA-256 hash of a block’s header must be lower than or equal to the current target for the block to be accepted by the network. The lower the target, the more difficult it is to generate a block. (See also Work.)

ref: https://en.bitcoin.it/wiki/Target

Implementations

impl Target

pub const ZERO: Target = _

When parsing nBits, Bitcoin Core converts a negative target threshold into a target of zero.

pub const MAX: Self = _

The maximum possible target.

This value is used to calculate difficulty, which is defined as how difficult the current target makes it to find a block relative to how difficult it would be at the highest possible target. Remember highest target == lowest difficulty.

ref: https://en.bitcoin.it/wiki/Target

pub const fn max_value() -> Self

The maximum possible target (see Target::MAX).

This is provided for consistency with Rust 1.41.1, newer code should use Target::MAX.

pub fn from_compact(c: CompactTarget) -> Target

Computes the Target value from a compact representation.

ref: https://developer.bitcoin.org/reference/block_chain.html#target-nbits

pub fn to_compact_lossy(self) -> CompactTarget

Computes the compact value from a Target representation.

The compact form is by definition lossy, this means that t == Target::from_compact(t.to_compact_lossy()) does not always hold.

pub fn is_met_by(&self, hash: BlockHash) -> bool

Returns true if block hash is less than or equal to this Target.

Proof-of-work validity for a block requires the hash of the block to be less than or equal to the target.

pub fn to_work(self) -> Work

Converts this Target to Work.

“Work” is defined as the work done to mine a block with this target value (recorded in the block header in compact form as nBits). This is not the same as the difficulty to mine a block with this target (see Self::difficulty).

pub fn difficulty(&self) -> u128

Computes the popular “difficulty” measure for mining.

Difficulty represents how difficult the current target makes it to find a block, relative to how difficult it would be at the highest possible target (highest target == lowest difficulty).

For example, a difficulty of 6,695,826 means that at a given hash rate, it will, on average, take ~6.6 million times as long to find a valid block as it would at a difficulty of 1, or alternatively, it will take, again on average, ~6.6 million times as many hashes to find a valid block

Note

Difficulty is calculated using the following algorithm max / current where max is defined for the Bitcoin network and current is the current target for this block. As such, a low target implies a high difficulty. Since Target is represented as a 256 bit integer but difficulty() returns only 128 bits this means for targets below approximately 0xffff_ffff_ffff_ffff_ffff_ffff difficulty() will saturate at u128::MAX.

pub fn difficulty_float(&self) -> f64

Computes the popular “difficulty” measure for mining and returns a float value of f64.

See difficulty for details.

impl Target

pub fn from_be_bytes(bytes: [u8; 32]) -> Target

Creates Self from a big-endian byte array.

pub fn from_le_bytes(bytes: [u8; 32]) -> Target

Creates Self from a little-endian byte array.

pub fn to_be_bytes(self) -> [u8; 32]

Converts self to a big-endian byte array.

pub fn to_le_bytes(self) -> [u8; 32]

Converts self to a little-endian byte array.

Trait Implementations

impl Clone for Target

fn clone(&self) -> Target

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Target

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Target

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Target

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<CompactTarget> for Target

fn from(c: CompactTarget) -> Self

Converts to this type from the input type.

impl Hash for Target

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl LowerHex for Target

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Ord for Target

fn cmp(&self, other: &Target) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Target> for Target

fn eq(&self, other: &Target) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Target> for Target

fn partial_cmp(&self, other: &Target) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Target

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl UpperHex for Target

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Copy for Target

impl Eq for Target

impl StructuralEq for Target

impl StructuralPartialEq for Target