Struct zebra_chain::transaction::unmined::VerifiedUnminedTx

pub struct VerifiedUnminedTx {
    pub transaction: UnminedTx,
    pub miner_fee: Amount<NonNegative>,
    pub legacy_sigop_count: u64,
    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.

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 ) -> Self

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:

max(serialized transaction size in bytes, 4000)

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 16000 if the transaction pays a fee less than the conventional fee, otherwise 0.

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 = (<UnminedTx as Arbitrary>::Parameters, <Amount<NonNegative> as Arbitrary>::Parameters, <u64 as Arbitrary>::Parameters, <u32 as Arbitrary>::Parameters, <f32 as Arbitrary>::Parameters)

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

type Strategy = Map<(<UnminedTx as Arbitrary>::Strategy, <Amount<NonNegative> as Arbitrary>::Strategy, <u64 as Arbitrary>::Strategy, <u32 as Arbitrary>::Strategy, <f32 as Arbitrary>::Strategy), fn(_: (UnminedTx, Amount<NonNegative>, u64, u32, f32)) -> VerifiedUnminedTx>

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

fn arbitrary_with(_top: 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.

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) -> Selfwhere I: IntoIterator<Item = VerifiedUnminedTx>,

Creates a value from an iterator.

impl FromIterator<VerifiedUnminedTx> for Root

fn from_iter<I>(transactions: I) -> Selfwhere I: IntoIterator<Item = VerifiedUnminedTx>,

Creates a value from an iterator.

impl PartialEq<VerifiedUnminedTx> for VerifiedUnminedTx

fn eq(&self, other: &VerifiedUnminedTx) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for VerifiedUnminedTx