Struct Fee 

pub struct Fee {
    pub gas_limit: u64,
    pub gas_price: u64,
    pub stealth_address: StealthAddress,
    pub sender: Sender,
}

The Fee structure

Fields

gas_limit: u64

Gas limit set for a phoenix transaction

gas_price: u64

Gas price set for a phoenix transaction

stealth_address: StealthAddress

Address to send the remainder note

sender: Sender

Sender to use for the remainder

Implementations

impl Fee

pub fn new<R: RngCore + CryptoRng>( rng: &mut R, refund_pk: &PublicKey, gas_limit: u64, gas_price: u64, ) -> Self

Create a new Fee with inner randomness

pub fn deterministic( r: &JubJubScalar, refund_pk: &PublicKey, gas_limit: u64, gas_price: u64, sender_blinder: &[JubJubScalar; 2], ) -> Self

Create a new Fee without inner randomness

pub fn max_fee(&self) -> u64

Calculate the max-fee.

pub fn hash(&self) -> BlsScalar

Return a hash represented by H(gas_limit, gas_price, H([note_pk]))

pub fn gen_remainder_note( &self, gas_consumed: u64, deposit: Option<u64>, ) -> Note

Generates a remainder from the fee and the given gas consumed.

If there is a deposit, it means that the deposit hasn’t been picked up by the contract. In this case, it is added to the remainder note.

Trait Implementations

impl Archive for Fee

where u64: Archive, StealthAddress: Archive, Sender: Archive,

type Archived = ArchivedFee

The archived representation of this type.

type Resolver = FeeResolver

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 Fee

fn clone(&self) -> Fee

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Fee

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

Formats the value using the given formatter.

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

where u64: Archive, Archived<u64>: Deserialize<u64, __D>, StealthAddress: Archive, Archived<StealthAddress>: Deserialize<StealthAddress, __D>, Sender: Archive, Archived<Sender>: Deserialize<Sender, __D>,

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

Deserializes using the given deserializer

impl PartialEq for Fee

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

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

Converts a Fee into it’s byte representation

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

Attempts to convert a byte representation of a fee into a Fee, 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: Fallible + ?Sized> Serialize<__S> for Fee

where u64: Serialize<__S>, StealthAddress: Serialize<__S>, Sender: 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 Copy for Fee

impl Eq for Fee