pub struct Pool<B>where
B: BlockChain,{
pub entries: Vec<PoolEntry>,
pub blockchain: Arc<B>,
pub name: String,
}
Fields§
§entries: Vec<PoolEntry>
Entries in the pool (tx + info + timer) in simple insertion order.
blockchain: Arc<B>
The blockchain
name: String
Implementations§
source§impl<B> Pool<B>where
B: BlockChain,
impl<B> Pool<B>where
B: BlockChain,
pub fn new(chain: Arc<B>, name: String) -> Self
sourcepub fn contains_tx(&self, tx: &Transaction) -> bool
pub fn contains_tx(&self, tx: &Transaction) -> bool
Does the transaction pool contain an entry for the given transaction? Transactions are compared by their kernels.
sourcepub fn retrieve_tx_by_kernel_hash(&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.
sourcepub fn retrieve_transactions(
&self,
hash: Hash,
nonce: u64,
kern_ids: &[ShortId]
) -> (Vec<Transaction>, Vec<ShortId>)
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.
sourcepub fn prepare_mineable_transactions(
&self,
max_weight: u64
) -> Result<Vec<Transaction>, PoolError>
pub fn prepare_mineable_transactions( &self, max_weight: u64 ) -> 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>
sourcepub fn all_transactions_aggregate(
&self,
extra_tx: Option<Transaction>
) -> Result<Option<Transaction>, PoolError>
pub fn all_transactions_aggregate( &self, extra_tx: Option<Transaction> ) -> Result<Option<Transaction>, PoolError>
Return a single aggregate tx representing all txs in the pool. Takes an optional “extra tx” to include in the aggregation. Returns None if there is nothing to aggregate. Returns the extra tx if provided and pool is empty.
pub fn add_to_pool( &mut self, entry: PoolEntry, extra_tx: Option<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>
sourcepub fn locate_spends(
&self,
tx: &Transaction,
extra_tx: Option<Transaction>
) -> Result<(Vec<OutputIdentifier>, Vec<OutputIdentifier>), PoolError>
pub fn locate_spends( &self, tx: &Transaction, extra_tx: Option<Transaction> ) -> Result<(Vec<OutputIdentifier>, Vec<OutputIdentifier>), PoolError>
Lookup unspent outputs to be spent by the provided transaction. We look for unspent outputs in the current txpool and then in the current utxo.
pub fn reconcile( &mut self, extra_tx: Option<Transaction>, header: &BlockHeader ) -> Result<(), PoolError>
pub fn evict_transaction(&mut self)
sourcepub fn find_matching_transactions(
&self,
kernels: &[TxKernel]
) -> Vec<Transaction>
pub fn find_matching_transactions( &self, kernels: &[TxKernel] ) -> Vec<Transaction>
TODO - This is kernel based. How does this interact with NRD?
sourcepub fn reconcile_block(&mut self, block: &Block)
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.
sourcepub fn kernel_count(&self) -> usize
pub fn kernel_count(&self) -> usize
Number of transaction kernels in the pool. This may differ from the size (number of transactions) due to tx aggregation.