Struct BlockBuilder 

pub struct BlockBuilder<T: NodeType> {

    instance: Arc<T::InstanceState>,
    membership: EpochMembershipCoordinator<T>,
    retry_pending: HashMap<Commitment<T::Transaction>, RetryEntry<T>>,
    retry_order: BTreeSet<(ViewNumber, Commitment<T::Transaction>)>,
    retry_total_bytes: u64,
    leader_buffer: HashMap<Commitment<T::Transaction>, PoolEntry<T>>,
    leader_order: BTreeSet<(ViewNumber, Commitment<T::Transaction>)>,
    leader_total_bytes: u64,
    dedups: BTreeMap<ViewNumber, HashSet<Commitment<T::Transaction>>>,
    undecided: BTreeMap<(ViewNumber, VidCommitment2), Vec<Commitment<T::Transaction>>>,
    decided: BTreeSet<(ViewNumber, VidCommitment2)>,
    config: BlockBuilderConfig,
    upgrade_lock: UpgradeLock<T>,
    current_view: ViewNumber,
    calculations: BTreeMap<(ViewNumber, Commitment<Leaf2<T>>), AbortHandle>,
    view_transactions: BTreeMap<ViewNumber, PooledBlock<T>>,
    tasks: JoinSet<Result<BlockBuilderOutput<T>, BlockError>>,
    commitments_duration_metric: Option<Arc<dyn Histogram>>,
    tracer: Option<LeaderTracerHandle>,
}

Fields

instance: Arc<T::InstanceState>

membership: EpochMembershipCoordinator<T>

retry_pending: HashMap<Commitment<T::Transaction>, RetryEntry<T>>

retry_order: BTreeSet<(ViewNumber, Commitment<T::Transaction>)>

retry_total_bytes: u64

leader_buffer: HashMap<Commitment<T::Transaction>, PoolEntry<T>>

leader_order: BTreeSet<(ViewNumber, Commitment<T::Transaction>)>

leader_total_bytes: u64

dedups: BTreeMap<ViewNumber, HashSet<Commitment<T::Transaction>>>

undecided: BTreeMap<(ViewNumber, VidCommitment2), Vec<Commitment<T::Transaction>>>

decided: BTreeSet<(ViewNumber, VidCommitment2)>

config: BlockBuilderConfig

upgrade_lock: UpgradeLock<T>

current_view: ViewNumber

calculations: BTreeMap<(ViewNumber, Commitment<Leaf2<T>>), AbortHandle>

view_transactions: BTreeMap<ViewNumber, PooledBlock<T>>

The transactions taken for the first block of each view, with their hashes.

Every later block for the view is built from exactly these. A leader disperses a block as soon as it is built, and peers keep one share per leader and view, so a second block for the view is votable only if its payload is the same. It is the same whenever the new parent does not change how the payload is built.

tasks: JoinSet<Result<BlockBuilderOutput<T>, BlockError>>

commitments_duration_metric: Option<Arc<dyn Histogram>>

tracer: Option<LeaderTracerHandle>

Records the four block-builder events (request, payload start, commitments start/end), when set.

Implementations

impl<T: NodeType> BlockBuilder<T>

pub fn new( instance: Arc<T::InstanceState>, membership: EpochMembershipCoordinator<T>, config: BlockBuilderConfig, upgrade_lock: UpgradeLock<T>, ) -> Self

pub fn with_tracer(self, tracer: Option<LeaderTracerHandle>) -> Self

Registers the leader tracer; builder-style like with_metrics.

pub fn with_metrics( self, commitments_duration: Option<Arc<dyn Histogram>>, ) -> Self

pub fn request_block(&mut self, request: BlockAndHeaderRequest<T>)

fn transactions_for(&mut self, view: ViewNumber) -> PooledBlock<T>

fn take_block( &mut self, view: ViewNumber, ) -> (Vec<T::Transaction>, Vec<Commitment<T::Transaction>>)

Removes up to one block of pooled transactions, those sent for the earliest views first, and returns them with their hashes.

fn remove_pooled( &mut self, hash: &Commitment<T::Transaction>, ) -> Option<T::Transaction>

pub async fn next( &mut self, ) -> Option<Result<BlockBuilderOutput<T>, BlockError>>

pub fn gc(&mut self, view_number: ViewNumber)

pub fn fanout(&self) -> NonZeroU64

pub fn start_at(&mut self, view: ViewNumber)

Starts the builder at view instead of genesis. Transactions can be submitted before the first on_view_changed, and would otherwise target the leaders of the first views and expire at the first view change.

pub fn outstanding_transactions(&self) -> (usize, usize)

pub fn on_submit_transaction( &mut self, tx: T::Transaction, ) -> Result<Option<TransactionMessage<T>>, SubmitError>

Returns the message for the upcoming leaders, addressed to the view SEND_LEAD ahead, which the coordinator sends on to the leaders of the fanout views from there. Resubmitting a queued transaction succeeds without queueing or sending it twice.

pub fn on_transactions(&mut self, msg: TransactionMessage<T>)

pub fn on_dedup_manifest(&mut self, manifest: DedupManifest<T>)

pub fn on_view_changed( &mut self, view: ViewNumber, ) -> Option<TransactionMessage<T>>

Returns the pending transactions to send again, within one block and one message, addressed like on_submit_transaction. A transaction is sent again only once every leader it went to has had its turn without including it.

fn resend_batch(&mut self, view: ViewNumber) -> Vec<T::Transaction>

fn expire_pooled(&mut self, view: ViewNumber)

Drops pooled transactions sent for views more than ttl behind view: their senders have stopped retrying them.

fn expire_block_records(&mut self, view: ViewNumber)

Drops the records of blocks more than ttl views behind view: everything submitted before such a block was built has expired by now, so its record can no longer clear anything from retry_pending.

fn remove_pending(&mut self, hash: &Commitment<T::Transaction>)

fn block_size(&self, view: ViewNumber) -> u64

The block size of the protocol version running at view.

pub fn on_block_reconstructed( &mut self, view: ViewNumber, payload_commitment: VidCommitment2, tx_commitments: Vec<Commitment<T::Transaction>>, )

Call for every block this node proposes or reconstructs, so it drops copies of the block’s transactions that reach it later. It keeps forwarding its own submissions until Self::on_blocks_decided confirms the block: a proposed, or even locked, block can still be abandoned, and its transactions would otherwise be lost.

pub fn on_blocks_decided( &mut self, blocks: impl IntoIterator<Item = (ViewNumber, VidCommitment2)>, )

Call with every decided block. Its transactions leave retry_pending. The records of older blocks stay: a view that decides after a newer one is a gap fill, not an abandoned branch, and records expire with the retry TTL anyway.

fn mark_included( &mut self, view: ViewNumber, hashes: Vec<Commitment<T::Transaction>>, )