Struct darkfi_money_contract::client::MoneyNote

pub struct MoneyNote {
    pub value: u64,
    pub token_id: TokenId,
    pub spend_hook: FuncId,
    pub user_data: Base,
    pub coin_blind: BaseBlind,
    pub value_blind: ScalarBlind,
    pub token_blind: BaseBlind,
    pub memo: Vec<u8>,
}

MoneyNote holds the inner attributes of a Coin It does not store the public key since it’s encrypted for that key, and so is not needed to infer the coin attributes. All other coin attributes must be present.

Fields

value: u64

Value of the coin

token_id: TokenId

Token ID of the coin

spend_hook: FuncId

Spend hook used for protocol-owned liquidity. Specifies which contract owns this coin.

user_data: Base

User data used by protocol when spend hook is enabled

coin_blind: BaseBlind

Blinding factor for the coin

value_blind: ScalarBlind

Blinding factor for the value pedersen commitment

token_blind: BaseBlind

Blinding factor for the token ID pedersen commitment

memo: Vec<u8>

Attached memo (arbitrary data)

Trait Implementations

impl AsyncDecodable for MoneyNote

where u64: AsyncDecodable, TokenId: AsyncDecodable, FuncId: AsyncDecodable, Base: AsyncDecodable, BaseBlind: AsyncDecodable, ScalarBlind: AsyncDecodable, Vec<u8>: AsyncDecodable,

fn decode_async<'life0, 'async_trait, D>( d: &'life0 mut D, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where D: 'async_trait + AsyncRead + Unpin + Send, Self: 'async_trait, 'life0: 'async_trait,

impl AsyncEncodable for MoneyNote

where u64: AsyncEncodable, TokenId: AsyncEncodable, FuncId: AsyncEncodable, Base: AsyncEncodable, BaseBlind: AsyncEncodable, ScalarBlind: AsyncEncodable, Vec<u8>: AsyncEncodable,

fn encode_async<'life0, 'life1, 'async_trait, S>( &'life0 self, s: &'life1 mut S, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where S: 'async_trait + AsyncWrite + Unpin + Send, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Asynchronously encode an object with a well-defined format. Should only ever error if the underlying AsyncWrite errors. Returns the number of bytes written on success.

impl Clone for MoneyNote

fn clone(&self) -> MoneyNote

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MoneyNote

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

Formats the value using the given formatter.

impl Decodable for MoneyNote

where u64: Decodable, TokenId: Decodable, FuncId: Decodable, Base: Decodable, BaseBlind: Decodable, ScalarBlind: Decodable, Vec<u8>: Decodable,

fn decode<D: Read>(d: &mut D) -> Result<Self, Error>

impl Encodable for MoneyNote

where u64: Encodable, TokenId: Encodable, FuncId: Encodable, Base: Encodable, BaseBlind: Encodable, ScalarBlind: Encodable, Vec<u8>: Encodable,

fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error>

Encode an object with a well-defined format. Should only ever error if the underlying Write errors. Returns the number of bytes written on success.

impl PartialEq for MoneyNote

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

impl StructuralPartialEq for MoneyNote