Struct chain_path_derivation::Derivation

pub struct Derivation(u32);

a derivation value that can be used to derive keys

There is 2 kind of derivations, the soft and the hard derivations. SoftDerivation are expected to allow derivation of the private keys and of the public keys. HardDerivation are expected to allow only the derivation of the private keys.

Tuple Fields

0: u32

Implementations

impl Derivation

pub const fn new(v: u32) -> Self

create a new derivation with the given index

pub fn is_soft_derivation(self) -> bool

test if the given derivation is a soft derivation

Example

let derivation = Derivation::new(42);
assert!(derivation.is_soft_derivation());

pub fn is_hard_derivation(self) -> bool

test if the given derivation is a hard derivation

Example

let derivation = Derivation::new(0x8000_0010);
assert!(derivation.is_hard_derivation());

pub const fn max_value() -> Self

returns the max derivation index value

let max = Derivation::max_value();
assert_eq!(max, Derivation::new(4294967295));

pub const fn min_value() -> Self

returns the min derivation index value

let min = Derivation::min_value();
assert_eq!(min, Derivation::new(0));

pub const fn overflowing_add(self, rhs: u32) -> (Self, bool)

calculate derivation + rhs

Returns the tuple of the addition along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

Examples

Basic usage:

assert_eq!(
    Derivation::new(5).overflowing_add(2),
    (Derivation::new(7), false)
);
assert_eq!(
    Derivation::max_value().overflowing_add(1),
    (Derivation::new(0), true)
);

pub fn saturating_add(self, rhs: u32) -> Self

saturating integer addition. Computes self + rhs, saturating at the numeric bounds instead of overflowing.

Examples

Basic usage:

assert_eq!(Derivation::new(100).saturating_add(1), Derivation::new(101));
assert_eq!(Derivation::max_value().saturating_add(2048), Derivation::max_value());

pub fn checked_add(self, rhs: u32) -> Option<Self>

checked integer addition. Computes self + rhs, returning None if overflow would occurred.

Examples

Basic usage:

assert_eq!(Derivation::new(100).checked_add(1), Some(Derivation::new(101)));
assert_eq!(Derivation::max_value().checked_add(2048), None);

pub const fn wrapping_add(self, rhs: u32) -> Self

Wrapping (modular) addition. Computes self + rhs, wrapping around the boundary of the type.

Examples

Basic usage:

assert_eq!(Derivation::new(100).wrapping_add(1), Derivation::new(101));
assert_eq!(Derivation::max_value().wrapping_add(1), Derivation::new(0));

fn saturating_sub(self, rhs: u32) -> Self

Methods from Deref<Target = u32>

pub const MIN: u32 = 0u32

pub const MAX: u32 = 4_294_967_295u32

pub const BITS: u32 = 32u32

Trait Implementations

impl Clone for Derivation

fn clone(&self) -> Derivation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Derivation

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

Formats the value using the given formatter.

impl Default for Derivation

fn default() -> Derivation

Returns the “default value” for a type.

impl Deref for Derivation

type Target = u32

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Display for Derivation

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

Formats the value using the given formatter.

impl From<Derivation> for u32

fn from(d: Derivation) -> Self

Converts to this type from the input type.

impl From<HardDerivation> for Derivation

fn from(d: HardDerivation) -> Self

Converts to this type from the input type.

impl From<SoftDerivation> for Derivation

fn from(d: SoftDerivation) -> Self

Converts to this type from the input type.

impl From<u32> for Derivation

fn from(v: u32) -> Derivation

Converts to this type from the input type.

impl FromIterator<Derivation> for DerivationPath<AnyScheme>

fn from_iter<T: IntoIterator<Item = Derivation>>(iter: T) -> Self

Creates a value from an iterator.

impl FromStr for Derivation

type Err = ParseDerivationError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Derivation

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 Derivation

fn cmp(&self, other: &Derivation) -> 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<Derivation> for Derivation

fn eq(&self, other: &Derivation) -> 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<Derivation> for Derivation

fn partial_cmp(&self, other: &Derivation) -> 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 TryFrom<Derivation> for HardDerivation

type Error = DerivationError

The type returned in the event of a conversion error.

fn try_from(value: Derivation) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Derivation> for SoftDerivation

type Error = DerivationError

The type returned in the event of a conversion error.

fn try_from(value: Derivation) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for Derivation

impl Eq for Derivation

impl StructuralEq for Derivation

impl StructuralPartialEq for Derivation