Struct phoenix_core::note::Note

pub struct Note { /* private fields */ }

A note that does not encrypt its value

Implementations

impl Note

pub fn new<R: RngCore + CryptoRng>( rng: &mut R, note_type: NoteType, psk: &PublicSpendKey, value: u64, blinding_factor: JubJubScalar ) -> Self

Creates a new phoenix output note

pub fn transparent<R: RngCore + CryptoRng>( rng: &mut R, psk: &PublicSpendKey, value: u64 ) -> Self

Creates a new transparent note

The blinding factor will be constant zero since the value commitment exists only to shield the value. The value is not hidden for transparent notes, so this can be trivially treated as a constant.

pub fn transparent_stealth( stealth_address: StealthAddress, value: u64, nonce: BlsScalar ) -> Self

Creates a new transparent note

This is equivalent to [transparent] but taking only a stealth address, a value, and a nonce. This is done to be able to generate a note directly for a stealth address, as opposed to a public spend key.

pub fn obfuscated<R: RngCore + CryptoRng>( rng: &mut R, psk: &PublicSpendKey, value: u64, blinding_factor: JubJubScalar ) -> Self

Creates a new obfuscated note

The provided blinding factor will be used to calculate the value commitment of the note. The tuple (value, blinding_factor), known by the caller of this function, must be later used to prove the knowledge of the value commitment of this note.

pub fn deterministic( note_type: NoteType, r: &JubJubScalar, nonce: BlsScalar, psk: &PublicSpendKey, value: u64, blinding_factor: JubJubScalar ) -> Self

Create a new phoenix output note without inner randomness

pub fn gen_nullifier(&self, sk: &SecretSpendKey) -> BlsScalar

Create a unique nullifier for the note

This nullifier is represeted as H(sk_r · G', pos)

pub fn hash_inputs(&self) -> [BlsScalar; 6]

Return the internal representation of scalars to be hashed

pub fn hash(&self) -> BlsScalar

Return a hash represented by `H(note_type, value_commitment, H(StealthAddress), pos, encrypted_data)

pub const fn note(&self) -> NoteType

Return the type of the note

pub const fn pos(&self) -> &u64

Return the position of the note on the tree.

pub fn set_pos(&mut self, pos: u64)

Set the position of the note on the tree. This, naturally, won’t reflect immediatelly on the data storage

pub const fn nonce(&self) -> &BlsScalar

Nonce used for the encrypt / decrypt of data for this note

pub const fn value_commitment(&self) -> &JubJubExtended

Return the value commitment H(value, blinding_factor)

pub const fn cipher(&self) -> &[BlsScalar; 3]

Returns the cipher of the encrypted data

pub fn value(&self, vk: Option<&ViewKey>) -> Result<u64, Error>

Attempt to decrypt the note value provided a ViewKey. Always succeeds for transparent notes, might fails or return random values for obfuscated notes if the provided view key is wrong.

pub fn blinding_factor( &self, vk: Option<&ViewKey> ) -> Result<JubJubScalar, Error>

Decrypt the blinding factor with the provided ViewKey

If the decrypt fails, a random value is returned

Trait Implementations

impl Clone for Note

fn clone(&self) -> Note

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Note

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

Formats the value using the given formatter.

impl From<(Fee, Crossover)> for Note

fn from((fee, crossover): (Fee, Crossover)) -> Note

Converts to this type from the input type.

impl From<Remainder> for Note

fn from(remainder: Remainder) -> Note

Converts to this type from the input type.

impl Ownable for Note

fn stealth_address(&self) -> &StealthAddress

Returns the associated StealthAddress

impl PartialEq for Note

fn eq(&self, other: &Self) -> 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 Serializable<{ 137 + PoseidonCipher::SIZE }> for Note

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

Converts a Note into a byte representation

fn from_bytes(bytes: &[u8; 233]) -> Result<Self, Self::Error>

Attempts to convert a byte representation of a note into a Note, failing if the input is invalid

type Error = Error

The type returned in the event of a conversion error.

const SIZE: usize = N

The size of

impl TryFrom<Note> for (Fee, Crossover)

type Error = Error

The type returned in the event of a conversion error.

fn try_from(note: Note) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for Note

impl Eq for Note