Struct PhoenixTransactionEvent 

pub struct PhoenixTransactionEvent {
    pub nullifiers: Vec<BlsScalar>,
    pub notes: Vec<Note>,
    pub memo: Vec<u8>,
    pub gas_spent: u64,
    pub refund_note: Option<Note>,
}

Event data emitted on a phoenix transaction’s completion.

Fields

nullifiers: Vec<BlsScalar>

Nullifiers of the notes spent during the transaction.

notes: Vec<Note>

Notes produced during the transaction.

memo: Vec<u8>

The memo included in the transaction.

gas_spent: u64

Gas spent by the transaction.

refund_note: Option<Note>

Optional gas-refund note if the refund is positive.

Trait Implementations

impl Archive for PhoenixTransactionEvent

where Vec<BlsScalar>: Archive, Vec<Note>: Archive, Vec<u8>: Archive, u64: Archive, Option<Note>: Archive,

type Archived = ArchivedPhoenixTransactionEvent

The archived representation of this type.

type Resolver = PhoenixTransactionEventResolver

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: Self::Resolver, out: *mut Self::Archived, )

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

impl Clone for PhoenixTransactionEvent

fn clone(&self) -> PhoenixTransactionEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PhoenixTransactionEvent

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<PhoenixTransactionEvent, __D> for Archived<PhoenixTransactionEvent>

where Vec<BlsScalar>: Archive, Archived<Vec<BlsScalar>>: Deserialize<Vec<BlsScalar>, __D>, Vec<Note>: Archive, Archived<Vec<Note>>: Deserialize<Vec<Note>, __D>, Vec<u8>: Archive, Archived<Vec<u8>>: Deserialize<Vec<u8>, __D>, u64: Archive, Archived<u64>: Deserialize<u64, __D>, Option<Note>: Archive, Archived<Option<Note>>: Deserialize<Option<Note>, __D>,

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

Deserializes using the given deserializer

impl PartialEq for PhoenixTransactionEvent

fn eq(&self, other: &PhoenixTransactionEvent) -> 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<__S: Fallible + ?Sized> Serialize<__S> for PhoenixTransactionEvent

where Vec<BlsScalar>: Serialize<__S>, Vec<Note>: Serialize<__S>, Vec<u8>: Serialize<__S>, u64: Serialize<__S>, Option<Note>: Serialize<__S>,

fn serialize(&self, serializer: &mut __S) -> Result<Self::Resolver, __S::Error>

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

impl StructuralPartialEq for PhoenixTransactionEvent