Struct zebrad::components::mempool::storage::verified_set::VerifiedSet

pub struct VerifiedSet {
    transactions: VecDeque<VerifiedUnminedTx>,
    transactions_serialized_size: usize,
    total_cost: u64,
    spent_outpoints: HashSet<OutPoint>,
    sprout_nullifiers: HashSet<Nullifier>,
    sapling_nullifiers: HashSet<Nullifier>,
    orchard_nullifiers: HashSet<Nullifier>,
}

The set of verified transactions stored in the mempool.

This also caches the all the spent outputs from the transactions in the mempool. The spent outputs include:

• the transparent outpoints spent by transactions in the mempool
• the Sprout nullifiers revealed by transactions in the mempool
• the Sapling nullifiers revealed by transactions in the mempool
• the Orchard nullifiers revealed by transactions in the mempool

Fields

transactions: VecDeque<VerifiedUnminedTx>

The set of verified transactions in the mempool.

transactions_serialized_size: usize

The total size of the transactions in the mempool if they were serialized.

total_cost: u64

The total cost of the verified transactions in the set.

spent_outpoints: HashSet<OutPoint>

The set of spent out points by the verified transactions.

sprout_nullifiers: HashSet<Nullifier>

The set of revealed Sprout nullifiers.

sapling_nullifiers: HashSet<Nullifier>

The set of revealed Sapling nullifiers.

orchard_nullifiers: HashSet<Nullifier>

The set of revealed Orchard nullifiers.

Implementations

impl VerifiedSet

pub fn transactions(&self) -> impl Iterator<Item = &UnminedTx> + '_

Returns an iterator over the UnminedTx in the set.

pub fn full_transactions(&self) -> impl Iterator<Item = &VerifiedUnminedTx> + '_

Returns an iterator over the VerifiedUnminedTx in the set.

Each VerifiedUnminedTx contains an UnminedTx, and adds extra fields from the transaction verifier result.

pub fn transaction_count(&self) -> usize

Returns the number of verified transactions in the set.

pub fn total_cost(&self) -> u64

Returns the total cost of the verified transactions in the set.

pub fn total_serialized_size(&self) -> usize

Returns the total serialized size of the verified transactions in the set.

This can be less than the total cost, because the minimum transaction cost is based on the MEMPOOL_TRANSACTION_COST_THRESHOLD.

pub fn contains(&self, id: &UnminedTxId) -> bool

Returns true if the set of verified transactions contains the transaction with the specified UnminedTxId.

pub fn clear(&mut self)

Clear the set of verified transactions.

Also clears all internal caches.

pub fn insert( &mut self, transaction: VerifiedUnminedTx ) -> Result<(), SameEffectsTipRejectionError>

Insert a transaction into the set.

Returns an error if the transaction has spend conflicts with any other transaction already in the set.

Two transactions have a spend conflict if they spend the same UTXO or if they reveal the same nullifier.

pub fn evict_one(&mut self) -> Option<VerifiedUnminedTx>

Evict one transaction from the set, returns the victim transaction.

Removes a transaction with probability in direct proportion to the eviction weight, as per ZIP-401.

Consensus 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. The conventional fee is currently defined as 1000 zatoshis

Note

Collecting and calculating weights is O(n). But in practice n is limited to 20,000 (mempooltxcostlimit/min(cost)), so the actual cost shouldn’t be too bad.

pub fn remove_all_that( &mut self, predicate: impl Fn(&VerifiedUnminedTx) -> bool ) -> usize

Removes all transactions in the set that match the predicate.

Returns the amount of transactions removed.

fn remove(&mut self, transaction_index: usize) -> VerifiedUnminedTx

Removes a transaction from the set.

Also removes its outputs from the internal caches.

fn has_spend_conflicts(&self, unmined_tx: &UnminedTx) -> bool

Returns true if the given transaction has any spend conflicts with transactions in the mempool.

Two transactions have a spend conflict if they spend the same UTXO or if they reveal the same nullifier.

fn cache_outputs_from(&mut self, tx: &Transaction)

Inserts the transaction’s outputs into the internal caches.

fn remove_outputs(&mut self, unmined_tx: &UnminedTx)

Removes the tracked transaction outputs from the mempool.

fn has_conflicts<T>(set: &HashSet<T>, list: impl Iterator<Item = T>) -> bool

where T: Eq + Hash,

Returns true if the two sets have common items.

fn remove_from_set<'t, T>( set: &mut HashSet<T>, items: impl IntoIterator<Item = Cow<'t, T>> )

where T: Clone + Eq + Hash + 't,

Removes some items from a HashSet.

Each item in the list of items should be wrapped in a Cow. This allows this generic method to support both borrowed and owned items.

fn update_metrics(&mut self)

Trait Implementations

impl Default for VerifiedSet

fn default() -> VerifiedSet

Returns the “default value” for a type.

impl Drop for VerifiedSet

fn drop(&mut self)

Executes the destructor for this type.