Struct zebra_chain::transaction::unmined::VerifiedUnminedTx

pub struct VerifiedUnminedTx {
    pub transaction: UnminedTx,
    pub miner_fee: Amount<NonNegative>,
    pub legacy_sigop_count: u64,
    pub conventional_actions: u32,
    pub unpaid_actions: u32,
    pub fee_weight_ratio: f32,
}

A verified unmined transaction, and the corresponding transaction fee.

This transaction has been fully verified, in the context of the mempool.

Fields

transaction: UnminedTx

The unmined transaction.

miner_fee: Amount<NonNegative>

The transaction fee for this unmined transaction.

legacy_sigop_count: u64

The number of legacy signature operations in this transaction’s transparent inputs and outputs.

conventional_actions: u32

The number of conventional actions for transaction, as defined by ZIP-317.

The number of actions is limited by MAX_BLOCK_BYTES, so it fits in a u32.

unpaid_actions: u32

The number of unpaid actions for transaction, as defined by ZIP-317 for block production.

The number of actions is limited by MAX_BLOCK_BYTES, so it fits in a u32.

fee_weight_ratio: f32

The fee weight ratio for transaction, as defined by ZIP-317 for block production.

This is not consensus-critical, so we use f32 for efficient calculations when the mempool holds a large number of transactions.

Implementations

impl VerifiedUnminedTx

pub fn new( transaction: UnminedTx, miner_fee: Amount<NonNegative>, legacy_sigop_count: u64, ) -> Result<Self, Error>

Create a new verified unmined transaction from an unmined transaction, its miner fee, and its legacy sigop count.

pub fn pays_conventional_fee(&self) -> bool

Returns true if the transaction pays at least the ZIP-317 conventional fee.

pub fn cost(&self) -> u64

The cost in bytes of the transaction, as defined in ZIP-401.

A reflection of the work done by the network in processing them (proof and signature verification; networking overheads; size of in-memory data structures).

Each transaction has a cost, which is an integer defined as…

pub fn eviction_weight(&self) -> u64

The computed eviction weight of a verified unmined transaction as part of the mempool set, as defined in ZIP-317 and ZIP-401.

Standard Rule

Each transaction also has an eviction weight, which is cost + low_fee_penalty, where low_fee_penalty is 40000 if the transaction pays a fee less than the conventional fee, otherwise 0. The conventional fee is currently defined in ZIP-317.

zcashd and zebrad limit the size of the mempool as described in ZIP-401. This specifies a low fee penalty that is added to the “eviction weight” if the transaction pays a fee less than the conventional transaction fee. This threshold is modified to use the new conventional fee formula.

Trait Implementations

impl Arbitrary for VerifiedUnminedTx

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

type Strategy = BoxedStrategy<VerifiedUnminedTx>

The type of Strategy used to generate values of type Self.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for VerifiedUnminedTx

fn clone(&self) -> VerifiedUnminedTx

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VerifiedUnminedTx

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

Formats the value using the given formatter.

impl Display for VerifiedUnminedTx

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

Formats the value using the given formatter.

impl FromIterator<VerifiedUnminedTx> for AuthDataRoot

fn from_iter<I>(transactions: I) -> Self

where I: IntoIterator<Item = VerifiedUnminedTx>,

Creates a value from an iterator.

impl FromIterator<VerifiedUnminedTx> for Root

fn from_iter<I>(transactions: I) -> Self

where I: IntoIterator<Item = VerifiedUnminedTx>,

Creates a value from an iterator.

impl PartialEq for VerifiedUnminedTx

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