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 transactons 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 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>) -> boolwhere
    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.