Struct grin_pool::transaction_pool::TransactionPool

pub struct TransactionPool<B, P, V> where
    B: BlockChain,
    P: PoolAdapter,
    V: VerifierCache,  {
    pub config: PoolConfig,
    pub txpool: Pool<B, V>,
    pub stempool: Pool<B, V>,
    pub reorg_cache: Arc<RwLock<VecDeque<PoolEntry>>>,
    pub blockchain: Arc<B>,
    pub verifier_cache: Arc<RwLock<V>>,
    pub adapter: Arc<P>,
}

Transaction pool implementation.

Fields

config: PoolConfig

Pool Config

txpool: Pool<B, V>

Our transaction pool.

stempool: Pool<B, V>

Our Dandelion "stempool".

reorg_cache: Arc<RwLock<VecDeque<PoolEntry>>>

Cache of previous txs in case of a re-org.

blockchain: Arc<B>

The blockchain

verifier_cache: Arc<RwLock<V>>

adapter: Arc<P>

The pool adapter

Implementations

impl<B, P, V> TransactionPool<B, P, V> where
    B: BlockChain,
    P: PoolAdapter,
    V: VerifierCache + 'static, 

pub fn new(
    config: PoolConfig,
    chain: Arc<B>,
    verifier_cache: Arc<RwLock<V>>,
    adapter: Arc<P>
) -> Self

Create a new transaction pool

pub fn chain_head(&self) -> Result<BlockHeader, PoolError>

pub fn add_to_pool(
    &mut self,
    src: TxSource,
    tx: Transaction,
    stem: bool,
    header: &BlockHeader
) -> Result<(), PoolError>

Add the given tx to the pool, directing it to either the stempool or txpool based on stem flag provided.

pub fn evict_from_txpool(&mut self)

pub fn truncate_reorg_cache(&mut self, cutoff: DateTime<Utc>)

pub fn reconcile_reorg_cache(
    &mut self,
    header: &BlockHeader
) -> Result<(), PoolError>

pub fn reconcile_block(&mut self, block: &Block) -> Result<(), PoolError>

Reconcile the transaction pool (both txpool and stempool) against the provided block.

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

Retrieve individual transaction for the given kernel hash.

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

Retrieve all transactions matching the provided "compact block" based on the kernel set. Note: we only look in the txpool for this (stempool is under embargo).

pub fn total_size(&self) -> usize

Get the total size of the pool. Note: we only consider the txpool here as stempool is under embargo.

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

Returns a vector of transactions from the txpool so we can build a block from them.