Enum OutputNoteState 

pub enum OutputNoteState {
    ExpectedPartial,
    ExpectedFull {
        recipient: NoteRecipient,
    },
    CommittedPartial {
        inclusion_proof: NoteInclusionProof,
    },
    CommittedFull {
        recipient: NoteRecipient,
        inclusion_proof: NoteInclusionProof,
    },
    Consumed {
        block_height: BlockNumber,
        recipient: NoteRecipient,
    },
}

Possible states for a single output note. They describe the note’s state and dictate its lifecycle.

Variants

ExpectedPartial

Note without known recipient is expected to be committed on chain.

ExpectedFull

Note with known recipient is expected to be committed on chain.

Fields

recipient: NoteRecipient

Details needed consume the note.

CommittedPartial

Note without known recipient has been committed on chain, and can be consumed in a transaction.

Fields

inclusion_proof: NoteInclusionProof

Inclusion proof for the note inside the chain block.

CommittedFull

Note with known recipient has been committed on chain, and can be consumed in a transaction.

Fields

recipient: NoteRecipient

Details needed to consume the note.

inclusion_proof: NoteInclusionProof

Inclusion proof for the note inside the chain block.

Consumed

Note has been nullified on chain.

Fields

block_height: BlockNumber

Block height at which the note was consumed.

recipient: NoteRecipient

Details needed to consume the note.

Implementations

impl OutputNoteState

pub const STATE_EXPECTED_PARTIAL: u8 = 0

pub const STATE_EXPECTED_FULL: u8 = 1

pub const STATE_COMMITTED_PARTIAL: u8 = 2

pub const STATE_COMMITTED_FULL: u8 = 3

pub const STATE_CONSUMED: u8 = 4

pub fn discriminant(&self) -> u8

Returns a unique identifier for each note state.

pub fn recipient(&self) -> Option<&NoteRecipient>

pub fn inclusion_proof(&self) -> Option<&NoteInclusionProof>

pub fn inclusion_proof_received( &self, inclusion_proof: NoteInclusionProof, ) -> Result<Option<OutputNoteState>, NoteRecordError>

pub fn nullifier_received( &self, block_height: BlockNumber, ) -> Result<Option<OutputNoteState>, NoteRecordError>

Trait Implementations

impl Clone for OutputNoteState

fn clone(&self) -> OutputNoteState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OutputNoteState

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

Formats the value using the given formatter.

impl Deserializable for OutputNoteState

fn read_from<R>(source: &mut R) -> Result<OutputNoteState, DeserializationError>

where R: ByteReader,

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

impl Display for OutputNoteState

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

Formats the value using the given formatter.

impl PartialEq for OutputNoteState

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

fn write_into<W>(&self, target: &mut W)

where W: ByteWriter,

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl Eq for OutputNoteState

impl StructuralPartialEq for OutputNoteState