Struct Note 

pub struct Note { /* private fields */ }

Phoenix Note struct

Implementations

impl Note

pub fn new<R>( rng: &mut R, note_type: NoteType, sender_pk: &PublicKey, receiver_pk: &PublicKey, value: u64, value_blinder: Fr, sender_blinder: [Fr; 2], ) -> Note

where R: RngCore + CryptoRng,

Creates a new phoenix output note

pub fn transparent<R>( rng: &mut R, sender_pk: &PublicKey, receiver_pk: &PublicKey, value: u64, sender_blinder: [Fr; 2], ) -> Note

where R: RngCore + CryptoRng,

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, sender: impl Into<Sender>, ) -> Note

Creates a new transparent note

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

pub fn obfuscated<R>( rng: &mut R, sender_pk: &PublicKey, receiver_pk: &PublicKey, value: u64, value_blinder: Fr, sender_blinder: [Fr; 2], ) -> Note

where R: RngCore + CryptoRng,

Creates a new obfuscated note

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

pub fn empty() -> Note

Creates a new empty Note

pub fn gen_nullifier(&self, sk: &SecretKey) -> Scalar

Create a unique nullifier for the note

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

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

Return the internal representation of scalars to be hashed

pub fn hash(&self) -> Scalar

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

pub const fn note_type(&self) -> NoteType

Return the type of the note

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

Return the position of the note on the tree.

pub const fn stealth_address(&self) -> &StealthAddress

Returns the the stealth address associated with the note.

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 value_commitment(&self) -> &AffinePoint

Return the value commitment H(value, value_blinder)

pub const fn value_enc(&self) -> &[u8; 68]

Returns the cipher of the encrypted data

pub const fn sender(&self) -> &Sender

Returns elgamal encryption of the sender’s PublicKey encrypted using the StealthAddress::note_pk so only the receiver of the Note can decrypt.

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 value_blinder(&self, vk: Option<&ViewKey>) -> Result<Fr, Error>

Decrypt the blinding factor with the provided ViewKey

If the decrypt fails, a random value is returned

Trait Implementations

impl Archive for Note

where NoteType: Archive, AffinePoint: Archive, StealthAddress: Archive, u64: Archive, [u8; 68]: Archive, Sender: Archive,

type Archived = ArchivedNote

The archived representation of this type.

type Resolver = NoteResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: <Note as Archive>::Resolver, out: *mut <Note as Archive>::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl AsRef<Note> for NoteLeaf

fn as_ref(&self) -> &Note

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Note

fn clone(&self) -> Note

Returns a duplicate 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<(), Error>

Formats the value using the given formatter.

impl<__D> Deserialize<Note, __D> for <Note as Archive>::Archived

where __D: Fallible + ?Sized, NoteType: Archive, <NoteType as Archive>::Archived: Deserialize<NoteType, __D>, AffinePoint: Archive, <AffinePoint as Archive>::Archived: Deserialize<AffinePoint, __D>, StealthAddress: Archive, <StealthAddress as Archive>::Archived: Deserialize<StealthAddress, __D>, u64: Archive, <u64 as Archive>::Archived: Deserialize<u64, __D>, [u8; 68]: Archive, <[u8; 68] as Archive>::Archived: Deserialize<[u8; 68], __D>, Sender: Archive, <Sender as Archive>::Archived: Deserialize<Sender, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Note, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl PartialEq for Note

fn eq(&self, other: &Note) -> 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 Serializable<phoenix_core::::note::{impl#4}::{constant#0}> for Note

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

Converts a Note into a byte representation

fn from_bytes( bytes: &[u8; 302], ) -> Result<Note, <Note as Serializable<phoenix_core::::note::{impl#4}::{constant#0}>>::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<__S> Serialize<__S> for Note

where __S: Fallible + ?Sized, NoteType: Serialize<__S>, AffinePoint: Serialize<__S>, StealthAddress: Serialize<__S>, u64: Serialize<__S>, [u8; 68]: Serialize<__S>, Sender: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Note as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Eq for Note