Struct zebrad::components::mempool::storage::Storage

pub struct Storage {
    verified: VerifiedSet,
    pub(super) pending_outputs: PendingOutputs,
    tip_rejected_exact: HashMap<UnminedTxId, ExactTipRejectionError>,
    tip_rejected_same_effects: HashMap<Hash, SameEffectsTipRejectionError>,
    chain_rejected_same_effects: HashMap<SameEffectsChainRejectionError, EvictionList>,
    eviction_memory_time: Duration,
    tx_cost_limit: u64,
}

Hold mempool verified and rejected mempool transactions.

Fields

verified: VerifiedSet

The set of verified transactions in the mempool.

pending_outputs: PendingOutputs

The set of outpoints with pending requests for their associated transparent::Output.

tip_rejected_exact: HashMap<UnminedTxId, ExactTipRejectionError>

The set of transactions rejected due to bad authorizations, or for other reasons, and their rejection reasons. These rejections only apply to the current tip.

Only transactions with the exact UnminedTxId are invalid.

tip_rejected_same_effects: HashMap<Hash, SameEffectsTipRejectionError>

A set of transactions rejected for their effects, and their rejection reasons. These rejections only apply to the current tip.

Any transaction with the same transaction::Hash is invalid.

chain_rejected_same_effects: HashMap<SameEffectsChainRejectionError, EvictionList>

Sets of transactions rejected for their effects, keyed by rejection reason. These rejections apply until a rollback or network upgrade.

Any transaction with the same transaction::Hash is invalid.

An EvictionList is used for both randomly evicted and expired transactions, even if it is only needed for the evicted ones. This was done just to simplify the existing code; there is no harm in having a timeout for expired transactions too since re-checking expired transactions is cheap.

eviction_memory_time: Duration

The mempool transaction eviction age limit. Same as config::Config::eviction_memory_time.

tx_cost_limit: u64

Max total cost of the verified mempool set, beyond which transactions are evicted to make room.

Implementations

impl Storage

pub(crate) fn new(config: &Config) -> Self

pub fn insert( &mut self, tx: VerifiedUnminedTx, spent_mempool_outpoints: Vec<OutPoint>, ) -> Result<UnminedTxId, MempoolError>

Insert a VerifiedUnminedTx into the mempool, caching any rejections.

Accepts the VerifiedUnminedTx being inserted and spent_mempool_outpoints, a list of transparent inputs of the provided VerifiedUnminedTx that were found as newly created transparent outputs in the mempool during transaction verification.

Returns an error if the mempool’s verified transactions or rejection caches prevent this transaction from being inserted. These errors should not be propagated to peers, because the transactions are valid.

If inserting this transaction evicts other transactions, they will be tracked as SameEffectsChainRejectionError::RandomlyEvicted.

pub fn remove_exact(&mut self, exact_wtxids: &HashSet<UnminedTxId>) -> usize

Remove transactions from the mempool via exact UnminedTxId.

For v5 transactions, transactions are matched by WTXID, using both the:

• non-malleable transaction ID, and
• authorizing data hash.

This matches the exact transaction, with identical blockchain effects, signatures, and proofs.

Returns the number of transactions which were removed.

Removes from the ‘verified’ set, if present. Maintains the order in which the other unmined transactions have been inserted into the mempool.

Does not add or remove from the ‘rejected’ tracking set.

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

Clears a list of mined transaction ids from the verified set’s tracked transaction dependencies.

pub fn reject_and_remove_same_effects( &mut self, mined_ids: &HashSet<Hash>, transactions: Vec<Arc<Transaction>>, ) -> usize

Reject and remove transactions from the mempool via non-malleable transaction::Hash.

• For v5 transactions, transactions are matched by TXID, using only the non-malleable transaction ID. This matches any transaction with the same effect on the blockchain state, even if its signatures and proofs are different.
• Returns the number of transactions which were removed.
• Removes from the ‘verified’ set, if present. Maintains the order in which the other unmined transactions have been inserted into the mempool.
• Prunes pending_outputs of any closed channels.

Reject and remove transactions from the mempool that contain any spent outpoints or revealed nullifiers from the passed in transactions.

Returns the number of transactions that were removed.

pub fn clear(&mut self)

Clears the whole mempool storage.

pub fn clear_tip_rejections(&mut self)

Clears rejections that only apply to the current tip.

fn limit_rejection_list_memory(&mut self)

Clears rejections that only apply to the current tip.

Security

This method must be called at the end of every method that adds rejections. Otherwise, peers could make our reject lists use a lot of RAM.

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

Returns the set of UnminedTxIds in the mempool.

pub fn transactions(&self) -> &HashMap<Hash, VerifiedUnminedTx>

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

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

pub fn transaction_dependencies(&self) -> &TransactionDependencies

Returns a reference to the TransactionDependencies in the verified 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 transactions in the mempool.

pub fn total_cost(&self) -> u64

Returns the cost of the transactions in the mempool, according to ZIP-401.

pub fn total_serialized_size(&self) -> usize

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

See VerifiedSet::total_serialized_size() for details.

pub fn transactions_exact( &self, tx_ids: HashSet<UnminedTxId>, ) -> impl Iterator<Item = &UnminedTx>

Returns the set of UnminedTxes with exactly matching tx_ids in the mempool.

This matches the exact transaction, with identical blockchain effects, signatures, and proofs.

pub fn transactions_same_effects( &self, tx_ids: HashSet<Hash>, ) -> impl Iterator<Item = &UnminedTx>

Returns the set of UnminedTxes with matching transaction::Hashes in the mempool.

This matches transactions with the same effects, regardless of transaction::AuthDigest.

pub fn contains_transaction_exact(&self, tx_id: &Hash) -> bool

Returns true if a transaction exactly matching an UnminedTxId is in the mempool.

This matches the exact transaction, with identical blockchain effects, signatures, and proofs.

pub fn rejected_transaction_count(&mut self) -> usize

Returns the number of rejected UnminedTxIds or transaction::Hashes.

Transactions on multiple rejected lists are counted multiple times.

pub fn reject(&mut self, tx_id: UnminedTxId, reason: RejectionError)

Add a transaction to the rejected list for the given reason.

pub fn rejection_error(&self, txid: &UnminedTxId) -> Option<MempoolError>

Returns the rejection error if a transaction matching an UnminedTxId is in any mempool rejected list.

This matches transactions based on each rejection list’s matching rule.

Returns an arbitrary error if the transaction is in multiple lists.

pub fn rejected_transactions( &self, tx_ids: HashSet<UnminedTxId>, ) -> impl Iterator<Item = UnminedTxId> + '_

Returns the set of UnminedTxIds matching tx_ids in the rejected list.

This matches transactions based on each rejection list’s matching rule.

pub fn contains_rejected(&self, txid: &UnminedTxId) -> bool

Returns true if a transaction matching the supplied UnminedTxId is in the mempool rejected list.

This matches transactions based on each rejection list’s matching rule.

pub fn reject_if_needed( &mut self, tx_id: UnminedTxId, e: TransactionDownloadVerifyError, )

Add a transaction that failed download and verification to the rejected list if needed, depending on the reason for the failure.

pub fn remove_expired_transactions( &mut self, tip_height: Height, ) -> HashSet<Hash>

Remove transactions from the mempool if they have not been mined after a specified height, per ZIP-203.

Transactions will have a new field, nExpiryHeight, which will set the block height after which transactions will be removed from the mempool if they have not been mined.

pub fn should_download_or_verify( &mut self, txid: UnminedTxId, ) -> Result<(), MempoolError>

Check if transaction should be downloaded and/or verified.

If it is already in the mempool (or in its rejected list) then it shouldn’t be downloaded/verified.

fn update_rejected_metrics(&mut self)

Update metrics related to the rejected lists.

Must be called every time the rejected lists change.

Trait Implementations

impl Drop for Storage

fn drop(&mut self)

Executes the destructor for this type.