Struct CommitFinalizer

pub struct CommitFinalizer { /* private fields */ }

CommitFinalizer accepts a continuous stream of CommittedSubDag and outputs them when they are finalized. In finalized commits, every transaction is either finalized or rejected. It runs in a separate thread, to reduce the load on the core thread.

Life of a finalized commit:

For efficiency, finalization happens first for transactions without reject votes (common case). The pending undecided transactions with reject votes are individually finalized or rejected. When there is no more pending transactions, the commit is finalized.

This is correct because regardless if a commit leader was directly or indirectly committed, every committed block can be considered finalized, because at least one leader certificate of the commit will be committed, which can also serve as a certificate for the block and its transactions.

From the earliest buffered commit, pending blocks are checked to see if they are now finalized. New finalized blocks are removed from the pending blocks, and its transactions are moved to the finalized, rejected or pending state. If the commit now has no pending blocks or transactions, the commit is finalized and popped from the buffer. The next earliest commit is then processed similarly, until either the buffer becomes empty or a commit with pending blocks or transactions is encountered.

Implementations

impl CommitFinalizer

pub fn new( context: Arc<Context>, dag_state: Arc<RwLock<DagState>>, transaction_certifier: TransactionCertifier, commit_sender: UnboundedSender<CommittedSubDag>, ) -> Self

pub async fn process_commit( &mut self, committed_sub_dag: CommittedSubDag, ) -> Vec<CommittedSubDag>