Struct ethcore_miner::pool::scoring::NonceAndGasPrice

pub struct NonceAndGasPrice {
    pub strategy: PrioritizationStrategy,
    pub block_base_fee: Option<U256>,
}

Simple, gas-price based scoring for transactions.

NOTE: Currently penalization does not apply to new transactions that enter the pool. We might want to store penalization status in some persistent state.

Fields

strategy: PrioritizationStrategy

Strategy for prioritization

block_base_fee: Option<U256>

Block base fee. Exists if the EIP 1559 is activated.

Implementations

impl NonceAndGasPrice

pub fn should_reject_early(
    &self,
    old: &VerifiedTransaction,
    new: &Transaction
) -> bool

Decide if the transaction should even be considered into the pool (if the pool is full).

Used by Verifier to quickly reject transactions that don’t have any chance to get into the pool later on, and save time on more expensive checks like sender recovery, etc.

NOTE The method is never called for zero-gas-price transactions or local transactions (such transactions are always considered to the pool and potentially rejected later on)

Trait Implementations

impl Clone for NonceAndGasPrice

fn clone(&self) -> NonceAndGasPrice

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NonceAndGasPrice

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

Formats the value using the given formatter.

impl<P> Scoring<P> for NonceAndGasPrice where
    P: ScoredTransaction + VerifiedTransaction, 

type Score = U256

A score of a transaction.

type Event = ScoringEvent

Custom scoring update event type.

fn compare(&self, old: &P, other: &P) -> Ordering

Decides on ordering of Ts from a particular sender.

fn choose(&self, old: &P, new: &P) -> Choice

Decides how to deal with two transactions from a sender that seem to occupy the same slot in the queue.

fn update_scores(
    &self,
    txs: &[Transaction<P>],
    scores: &mut [U256],
    change: Change<ScoringEvent>
)

Updates the transaction scores given a list of transactions and a change to previous scoring. NOTE: you can safely assume that both slices have the same length. (i.e. score at index i represents transaction at the same index)

fn should_ignore_sender_limit(&self, new: &P) -> bool

Decides if the transaction should ignore per-sender limit in the pool.