Struct Target 

pub struct Target(/* private fields */);

A 256-bit proof-of-work target, big-endian.

Implementations

impl Target

pub const MAX: Target

The largest target, 2²⁵⁶ − 1: every hash meets it.

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

A target from its 32 big-endian bytes.

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

The 32 big-endian bytes.

pub fn from_hex(s: &str) -> Result<Self, Error>

A target from 64 hex characters, most significant first — the form a chain document’s powLimit takes (SPEC 3).

use sidestr_header::Target;
let lim = Target::from_hex("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
assert_eq!(lim.to_compact(), 0x207f_ffff);

pub fn from_compact(bits: u32) -> Result<Self, Error>

Expands compact bits (Core’s SetCompact): the low 23 bits are the mantissa, the top byte the size in bytes of the big-endian number the mantissa is the leading three bytes of.

use sidestr_header::Target;
// Bitcoin's genesis bits.
let t = Target::from_compact(0x1d00_ffff).unwrap();
assert_eq!(hex::encode(t.to_be_bytes()),
           "00000000ffff0000000000000000000000000000000000000000000000000000");
// A well-known Core example: 0x1b0404cb.
let t = Target::from_compact(0x1b04_04cb).unwrap();
assert_eq!(hex::encode(t.to_be_bytes()),
           "00000000000404cb000000000000000000000000000000000000000000000000");

pub fn to_compact(self) -> u32

Compact-encodes the target (Core’s GetCompact, the kernel’s compactFromTarget), including the mantissa truncation that makes the encoding lossy: from_compact(t.to_compact()) keeps only the three most significant bytes of t.

use sidestr_header::Target;
assert_eq!(Target::from_compact(0x1d00_ffff).unwrap().to_compact(), 0x1d00_ffff);
assert_eq!(Target::MAX.to_compact(), 0x2100_ffff); // top byte 0xff would read as a sign bit

pub fn is_zero(self) -> bool

Whether the target is zero, which no hash but zero can meet.

Trait Implementations

impl Clone for Target

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Target

impl Debug for Target

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

Formats the value using the given formatter.

impl Display for Target

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

Formats the value using the given formatter.

impl Eq for Target

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 Ord for Target

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Target

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Target

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl StructuralPartialEq for Target