Struct VerifiedSet

pub struct VerifiedSet {
    transactions: HashMap<Hash, VerifiedUnminedTx>,
    transaction_dependencies: TransactionDependencies,
    created_outputs: HashMap<OutPoint, Output>,
    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 dependencies of transactions that spent the outputs of other transactions in the mempool
• the outputs of transactions in the mempool
• 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: HashMap<Hash, VerifiedUnminedTx>

The set of verified transactions in the mempool.

transaction_dependencies: TransactionDependencies

A map of dependencies between transactions in the mempool that spend or create outputs of other transactions in the mempool.

created_outputs: HashMap<OutPoint, Output>

The transparent::Outputs created by verified transactions in the mempool.

These outputs may be spent by other 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) -> &HashMap<Hash, VerifiedUnminedTx>

Returns a reference to the HashMap of VerifiedUnminedTxs in the set.

pub fn transaction_dependencies(&self) -> &TransactionDependencies

Returns a reference to the TransactionDependencies in the set.

pub fn created_output(&self, outpoint: &OutPoint) -> Option<Output>

Returns a transparent::Output created by a mempool transaction for the provided transparent::OutPoint if one exists, or None otherwise.

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: &Hash) -> bool

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

pub fn clear(&mut self)

Clear the set of verified transactions.

Also clears all internal caches.

pub fn insert( &mut self, transaction: VerifiedUnminedTx, spent_mempool_outpoints: Vec<OutPoint>, pending_outputs: &mut PendingOutputs, ) -> 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 and any transactions that directly or indirectly depend on its outputs from the set, returns the victim transaction and any dependent transactions.

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.

This function is equivalent to EvictTransaction in ZIP-401.

pub fn clear_mined_dependencies(&mut self, mined_ids: &HashSet<Hash>)

Clears a list of mined transaction ids from the lists of dependencies for any other transactions in the mempool and removes their dependents.

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, key_to_remove: &Hash) -> Vec<VerifiedUnminedTx>

Accepts a transaction id for a transaction to remove from the verified set.

Removes the transaction and any transactions that directly or indirectly depend on it from the set.

Returns a list of transactions that have been removed with the target transaction as the last item.

Also removes the outputs of any removed transactions 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 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.