Struct grin_pool::Pool

pub struct Pool {
    pub entries: Vec<PoolEntry>,
    pub blockchain: Arc<dyn BlockChain>,
    pub verifier_cache: Arc<RwLock<dyn VerifierCache>>,
    pub name: String,
}

Fields

entries: Vec<PoolEntry>

Entries in the pool (tx + info + timer) in simple insertion order.

blockchain: Arc<dyn BlockChain>

The blockchain

verifier_cache: Arc<RwLock<dyn VerifierCache>>

name: String

Methods

impl Pool

pub fn new(
    chain: Arc<dyn BlockChain>,
    verifier_cache: Arc<RwLock<dyn VerifierCache>>,
    name: String
) -> Pool

pub fn contains_tx(&self, hash: Hash) -> bool

Does the transaction pool contain an entry for the given transaction?

pub fn get_tx(&self, hash: Hash) -> Option<Transaction>

pub fn retrieve_tx_by_kernel_hash(&self, hash: Hash) -> Option<Transaction>

Query the tx pool for an individual tx matching the given kernel hash.

pub fn retrieve_transactions(
    &self,
    hash: Hash,
    nonce: u64,
    kern_ids: &[ShortId]
) -> (Vec<Transaction>, Vec<ShortId>)

Query the tx pool for all known txs based on kernel short_ids from the provided compact_block. Note: does not validate that we return the full set of required txs. The caller will need to validate that themselves.

pub fn prepare_mineable_transactions(
    &self,
    max_weight: usize
) -> Result<Vec<Transaction>, PoolError>

Take pool transactions, filtering and ordering them in a way that's appropriate to put in a mined block. Aggregates chains of dependent transactions, orders by fee over weight and ensures the total weight does not exceed the provided max_weight (miner defined block weight).

pub fn all_transactions(&self) -> Vec<Transaction>

pub fn all_transactions_aggregate(
    &self
) -> Result<Option<Transaction>, PoolError>

Return a single aggregate tx representing all txs in the txpool. Returns None if the txpool is empty.

pub fn add_to_pool(
    &mut self,
    entry: PoolEntry,
    extra_txs: Vec<Transaction>,
    header: &BlockHeader
) -> Result<(), PoolError>

pub fn validate_raw_txs(
    &self,
    txs: &[Transaction],
    extra_tx: Option<Transaction>,
    header: &BlockHeader,
    weighting: Weighting
) -> Result<Vec<Transaction>, PoolError>

pub fn reconcile(
    &mut self,
    extra_tx: Option<Transaction>,
    header: &BlockHeader
) -> Result<(), PoolError>

pub fn bucket_transactions(&self, weighting: Weighting) -> Vec<Transaction>

Buckets consist of a vec of txs and track the aggregate fee_to_weight. We aggregate (cut-through) dependent transactions within a bucket unless adding a tx would reduce the aggregate fee_to_weight, in which case we start a new bucket. Note this new bucket will by definition have a lower fee_to_weight than the bucket containing the tx it depends on. Sorting the buckets by fee_to_weight will therefore preserve dependency ordering, maximizing both cut-through and overall fees.

pub fn find_matching_transactions(
    &self,
    kernels: &[TxKernel]
) -> Vec<Transaction>

pub fn reconcile_block(&mut self, block: &Block)

Quick reconciliation step - we can evict any txs in the pool where inputs or kernels intersect with the block.

pub fn size(&self) -> usize

Size of the pool.

pub fn is_empty(&self) -> bool

Is the pool empty?