Struct Mempool

pub struct Mempool { /* private fields */ }

Available on non-WebAssembly only.

Holds the transactions that we broadcasted and are still in the mempool.

Implementations

impl Mempool

pub fn new(acc: Pollard<BitcoinNodeHash>, max_mempool_size: usize) -> Mempool

Creates a new mempool with a given maximum size and accumulator.

The acculator should have the same roots as the one inside our chainstate, or we won’t be able to validate proofs.

pub fn list_unprocessed(&self) -> Vec<Txid>

List transactions we are pending to process.

Usually, we don’t have a proof for these transactions, so we can’t add them to the mempool, a wire implementation should call this method and try to get a proof for these transactions.

pub fn list_mempool(&self) -> Vec<Txid>

List all transactions we’ve accepted to the mempool.

This won’t count transactions that are still in the queue.

pub fn get_prevouts(&self, tx: &Transaction) -> Vec<TxOut>

Returns the data of the prevouts that are being spent by a transaction.

This data isn’t part of the actual transaction, usually we would fetch it from the UTXO set, but we don’t have one. Instead, we keep track of the prevouts that are being spent by transactions in the mempool and use this method to get the data.

pub fn try_prove( &self, tx: &Transaction, block_hash: &impl BlockHashOracle, ) -> Result<MempoolProof, AcceptToMempoolError>

Proves that a mempool transaction is valid for the latest accumulator state.

This should return a proof that the transaction is valid, and the data for the prevouts that are being spent by the transaction.

pub fn get_block_template( &self, version: Version, prev_blockhash: BlockHash, time: u32, bits: CompactTarget, ) -> Block

Returns a list of transactions that are in the mempool up to the block weight limit.

Returns a candidate block to be mined.

pub fn consume_block( &mut self, block: &Block, proof: Proof, adds: &[PollardAddition<BitcoinNodeHash>], del_hashes: &[BitcoinNodeHash], block_height: u32, remember_all: bool, ) -> Result<Vec<Txid>, AcceptToMempoolError>

Consume a block and remove all transactions that were included in it.

This method will remove all transactions that is in the block from the mempool, update the local accumulator and return the txids that were included in the block.

pub fn get_block_proof( &self, block: &Block, get_block_hash: impl BlockHashOracle, ) -> Result<MempoolProof, AcceptToMempoolError>

Proves all transactions included in a block.

pub fn accept_to_mempool_no_acc( &mut self, transaction: Transaction, ) -> Result<(), AcceptToMempoolError>

Internal utility to add a transaction to the mempool.

This method should never be called for transactions coming from the wire, since it doesn’t check if the transaction is valid other than basic constraint checks. This method is used by the mempool itself to add transactions that are already known to be valid, such as wallet transactions. For transactions coming from the wire, use accept_to_mempool.

pub fn accept_to_mempool( &mut self, transaction: Transaction, proof: Proof, prevouts: &[(OutPoint, CompactLeafData)], del_hashes: &[BitcoinNodeHash], remembers: &[u64], ) -> Result<(), AcceptToMempoolError>

Add a transaction to the mempool.

pub fn get_from_mempool<'a>(&'a self, id: &Txid) -> Option<&'a Transaction>

Get a transaction from the mempool.

pub fn get_stale(&mut self) -> Vec<Txid>

Get all transactions that were in the mempool for more than 1 hour, if any

Trait Implementations

impl Debug for Mempool

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

Formats the value using the given formatter.

impl Send for Mempool