Struct Zec 

pub struct Zec<C: Constraint>(Amount<C>);

A wrapper type that formats Amounts as ZEC, using double-precision floating point.

This formatting is accurate to the nearest zatoshi, as long as the number of floating-point calculations is very small. This is because MAX_MONEY uses 51 bits, but f64 has 53 bits of precision.

Rust uses roundTiesToEven, which can lose one bit of precision per calculation in the worst case. (Assuming the platform implements it correctly.)

Unlike zcashd, Zebra doesn’t have control over its JSON number precision, because it uses serde_json’s formatter. But zcashd uses a fixed-point calculation: https://github.com/zcash/zcash/blob/f6a4f68115ea4c58d55c8538579d0877ba9c8f79/src/rpc/server.cpp#L134

Tuple Fields

0: Amount<C>

Implementations

impl<C: Constraint> Zec<C>

pub fn lossy_zec(&self) -> f64

Returns the f64 ZEC value for the inner amount.

The returned value should not be used for consensus-critical calculations, because it is lossy.

pub fn from_lossy_zec(lossy_zec: f64) -> Result<Self, BoxError>

Converts a f64 ZEC value to a Zec amount.

This method should not be used for consensus-critical calculations, because it is lossy.

Methods from Deref<Target = Amount<C>>

pub fn zatoshis(&self) -> i64

Returns the number of zatoshis in this amount.

pub fn to_bytes(&self) -> [u8; 8]

To little endian byte array

pub fn is_zero(&self) -> bool

Returns true if this amount is zero.

Trait Implementations

impl<C: Clone + Constraint> Clone for Zec<C>

fn clone(&self) -> Zec<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Constraint> Debug for Zec<C>

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

Formats the value using the given formatter.

impl<C: Default + Constraint> Default for Zec<C>

fn default() -> Zec<C>

Returns the “default value” for a type.

impl<C: Constraint> Deref for Zec<C>

type Target = Amount<C>

The resulting type after dereferencing.

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

Dereferences the value.

impl<C: Constraint> DerefMut for Zec<C>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, C> Deserialize<'de> for Zec<C>

where C: Constraint + Clone,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C: Constraint> Display for Zec<C>

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

Formats the value using the given formatter.

impl<C: Constraint> From<Amount<C>> for Zec<C>

fn from(amount: Amount<C>) -> Self

Converts to this type from the input type.

impl<C: Constraint> From<Zec<C>> for Amount<C>

fn from(zec: Zec<C>) -> Amount<C>

Converts to this type from the input type.

impl<C: Constraint> From<Zec<C>> for f64

fn from(zec: Zec<C>) -> f64

Converts to this type from the input type.

impl<C: Constraint> From<Zec<C>> for i64

fn from(zec: Zec<C>) -> i64

Converts to this type from the input type.

impl<C: Constraint> FromStr for Zec<C>

type Err = Box<dyn Error + Sync + Send>

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<C: Constraint> Hash for Zec<C>

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

Zecs with the same value are equal, even if they have different constraints

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<C1: Constraint, C2: Constraint> PartialEq<Amount<C2>> for Zec<C1>

fn eq(&self, other: &Amount<C2>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<C: Constraint> PartialEq<Zec<C>> for i64

fn eq(&self, other: &Zec<C>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<C1: Constraint, C2: Constraint> PartialEq<Zec<C2>> for Amount<C1>

fn eq(&self, other: &Zec<C2>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<C1: Constraint, C2: Constraint> PartialEq<Zec<C2>> for Zec<C1>

fn eq(&self, other: &Zec<C2>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<C: Constraint> PartialEq<i64> for Zec<C>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<C> Serialize for Zec<C>

where C: Constraint + Clone,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<C: Constraint> TryFrom<f64> for Zec<C>

type Error = Box<dyn Error + Sync + Send>

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<C: Constraint> TryFrom<i64> for Zec<C>

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<C: Copy + Constraint> Copy for Zec<C>

impl<C: Constraint> Eq for Zec<C>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes