Struct ConsensusTransactionPool 

pub struct ConsensusTransactionPool { /* private fields */ }

A single epoch’s transaction pool, drained by the consensus proposer through the consensus_core::TransactionPool impl below. take() drains pings (zero block space), then the system lane FIFO, then the user lane in gas-price order — user transactions never delay system ones.

Backpressure for user RPCs is provided solely by the capacity limit of the user priority queue.

Implementations

impl ConsensusTransactionPool

pub fn new( epoch_store: Arc<AuthorityPerEpochStore>, max_pending_transactions: usize, metrics: Arc<AdmissionQueueMetrics>, adapter_metrics: ConsensusAdapterMetrics, ) -> Self

pub fn epoch(&self) -> EpochId

pub fn try_insert( &self, caller_epoch: EpochId, gas_price: u64, transactions: Vec<ConsensusTransaction>, ) -> SuiResult<(PositionReceiver, bool)>

Inserts user transactions to the pool. Returns the receiver for their eventual positions, and bool indicating whether all transactions in the group were newly inserted. Fails fast on epoch mismatch, a closed pool/user lane, block-limit violations, or when outbid by the eviction policy. gas_price is the entry’s priority in the user lane (proposed first, and outbids lower prices when the lane is full).

pub fn close(&self)

Permanently shuts the pool down, called before stopping the consensus authority. Pending user waiters are resolved with ValidatorHaltedAtEpochEnd so the RPC retry loop resubmits them in the next epoch; system and ping acks are dropped, which their submitters treat as consensus shutdown. Idempotent.

Trait Implementations

impl TransactionPool for ConsensusTransactionPool

fn take( &self, max_count: usize, max_bytes: usize, ) -> (Vec<Transaction>, Box<dyn FnOnce(BlockRef) + Send>, LimitReached)

Called by the proposer while building a block. Takes transactions to include, up to max_count transactions and max_bytes total serialized bytes. Returns the transactions in block order, an ack callback the proposer invokes with the created block’s reference after the block is durably created, and which limit stopped the take. Dropping the callback without invoking it means the transactions have not been included in a block, and the implementation may make them available to take again.

fn notify_committed(&self, own_committed_blocks: Vec<BlockRef>, gc_round: Round)

Called from the commit path with this authority’s own committed block refs and the current GC round. Own blocks at rounds <= gc_round that are not committed are GC’ed and will never commit.