sequence data -> finalized block rename

Author: samliok

epoch.go

@@ -695,7 +695,7 @@ func (e *Epoch) indexFinalizationCertificates(startRound uint64) {
 		return
 	}
 	if round.fCert.Finalization.Seq != e.Storage.Height() {
-		e.Logger.Debug("Finalization certificate does not correspond to the next sequence to commit", 
+		e.Logger.Debug("Finalization certificate does not correspond to the next sequence to commit",
 			zap.Uint64("seq", round.fCert.Finalization.Seq), zap.Uint64("height", e.Storage.Height()))
 		return
 	}
@@ -852,7 +852,6 @@ func (e *Epoch) handleNotarizationMessage(message *Notarization, from NodeID) er
 	return e.persistNotarization(*message)
 }
 
-
 func (e *Epoch) handleBlockMessage(message *BlockMessage, from NodeID) error {
 	block := message.Block
 	if block == nil {
@@ -961,20 +960,22 @@ func (e *Epoch) handleBlockMessage(message *BlockMessage, from NodeID) error {
 	return nil
 }
 
-func (e *Epoch) processFinalizedBlock(sequenceData *SequenceData) error {
-	round, exists := e.rounds[sequenceData.FCert.Finalization.Round]
+// processFinalizedBlock processes a block that has a finalization certificate.
+// if the block has already been verified, it will index the finalization certificate,
+// otherwise it will verify the block first.
+func (e *Epoch) processFinalizedBlock(finalizedBlock *FinalizedBlock) error {
+	round, exists := e.rounds[finalizedBlock.FCert.Finalization.Round]
 	// dont create a block verification task if the block is already in the rounds map
 	if exists {
 		roundDigest := round.block.BlockHeader().Digest
-		seqDigest := sequenceData.FCert.Finalization.BlockHeader.Digest
+		seqDigest := finalizedBlock.FCert.Finalization.BlockHeader.Digest
 		if !bytes.Equal(roundDigest[:], seqDigest[:]) {
 			e.Logger.Warn("Received finalized block that is different from the one we have in the rounds map",
 				zap.Stringer("roundDigest", roundDigest), zap.Stringer("seqDigest", seqDigest))
 			return nil
 		}
-		round.fCert = &sequenceData.FCert
+		round.fCert = &finalizedBlock.FCert
 		e.indexFinalizationCertificates(round.num)
-		e.replicationState.maybeCollectFutureFinalizationCertificates(e.round, e.Storage.Height())
 		e.processReplicationState()
 		return e.maybeLoadFutureMessages()
 	}
@@ -984,14 +985,14 @@ func (e *Epoch) processFinalizedBlock(sequenceData *SequenceData) error {
 		e.Logger.Warn("Too many blocks being verified to ingest another one", zap.Int("pendingBlocks", pendingBlocks))
 		return nil
 	}
-	md := sequenceData.Block.BlockHeader()
-	if !e.verifyProposalIsPartOfOurChain(sequenceData.Block) {
+	md := finalizedBlock.Block.BlockHeader()
+	if !e.verifyProposalIsPartOfOurChain(finalizedBlock.Block) {
 		e.Logger.Debug("Got invalid block in a BlockMessage")
 		return nil
 	}
 
 	// Create a task that will verify the block in the future, after its predecessors have also been verified.
-	task := e.createBlockFinalizedVerificationTask(*sequenceData)
+	task := e.createBlockFinalizedVerificationTask(*finalizedBlock)
 
 	// isBlockReadyToBeScheduled checks if the block is known to us either from some previous round,
 	// or from storage. If so, then we have verified it in the past, since only verified blocks are saved in memory.
@@ -1053,8 +1054,8 @@ func (e *Epoch) createBlockVerificationTask(block Block, from NodeID, vote Vote)
 	}
 }
 
-func (e *Epoch) createBlockFinalizedVerificationTask(sequenceData SequenceData) func() Digest {
-	block := sequenceData.Block
+func (e *Epoch) createBlockFinalizedVerificationTask(finalizedBlock FinalizedBlock) func() Digest {
+	block := finalizedBlock.Block
 	return func() Digest {
 		md := block.BlockHeader()
 
@@ -1086,10 +1087,9 @@ func (e *Epoch) createBlockFinalizedVerificationTask(sequenceData SequenceData)
 			e.Logger.Error("programming error: round not found", zap.Uint64("round", md.Round))
 			return md.Digest
 		}
-		round.fCert = &sequenceData.FCert
+		round.fCert = &finalizedBlock.FCert
 
 		e.indexFinalizationCertificates(round.num)
-		e.replicationState.maybeCollectFutureFinalizationCertificates(e.round, e.Storage.Height())
 		e.processReplicationState()
 		err := e.maybeLoadFutureMessages()
 		if err != nil {

epoch_multinode_test.go

@@ -44,7 +44,7 @@ func (t *testNode) start() {
 	require.NoError(t.t, t.e.Start())
 }
 
-func newSimplexNodeWithStorage(t *testing.T, nodeID NodeID, net *inMemNetwork, bb BlockBuilder, storage []SequenceData) *testNode {
+func newSimplexNodeWithStorage(t *testing.T, nodeID NodeID, net *inMemNetwork, bb BlockBuilder, storage []FinalizedBlock) *testNode {
 	wal := newTestWAL(t)
 	conf := defaultTestNodeEpochConfig(t, nodeID, net, wal, bb)
 	for _, data := range storage {

message_handler.go

@@ -22,13 +22,13 @@ type FinalizationCertificateRequest struct {
 	Sequences []uint64
 }
 
-type SequenceData struct {
+type FinalizedBlock struct {
 	Block Block
 	FCert FinalizationCertificate
 }
 
 type FinalizationCertificateResponse struct {
-	Data []SequenceData
+	Data []FinalizedBlock
 }
 
 // HandleRequest processes a request and returns a response. It also sends a response to the sender.
@@ -48,15 +48,15 @@ func (e *Epoch) handleFinalizationCertificateRequest(req *FinalizationCertificat
 	e.Logger.Debug("Received finalization certificate request", zap.Int("num seqs", len(req.Sequences)))
 	seqs := req.Sequences
 	slices.Sort(seqs)
-	data := make([]SequenceData, len(seqs))
+	data := make([]FinalizedBlock, len(seqs))
 	for i, seq := range seqs {
 		block, fCert, exists := e.Storage.Retrieve(seq)
 		if !exists {
 			// since we are sorted, we can break early
 			data = data[:i]
 			break
 		}
-		data[i] = SequenceData{
+		data[i] = FinalizedBlock{
 			Block: block,
 			FCert: fCert,
 		}
@@ -83,7 +83,7 @@ func (e *Epoch) handleFinalizationCertificateResponse(resp *FinalizationCertific
 			continue
 		}
 
-		err := e.replicationState.StoreSequenceData(data)
+		err := e.replicationState.StoreFinalizedBlock(data)
 		if err != nil {
 			e.Logger.Error("Failed to store sequence data", zap.Error(err), zap.Uint64("seq", data.FCert.Finalization.Seq), zap.String("from", from.String()))
 			continue
@@ -95,14 +95,12 @@ func (e *Epoch) handleFinalizationCertificateResponse(resp *FinalizationCertific
 }
 
 func (e *Epoch) processReplicationState() {
-	// next sequence to commit
 	nextSeqToCommit := e.Storage.Height()
-	sequenceData, ok := e.replicationState.receivedFinalizationCertificates[nextSeqToCommit]
+	finalizedBlock, ok := e.replicationState.receivedFinalizationCertificates[nextSeqToCommit]
 	if !ok {
-		// we are missing the finalization certificate for the next sequence to commit
 		return
 	}
-	
-	// process block should not verify the block if its in e.round map
-	e.processFinalizedBlock(&sequenceData)
+
+	e.replicationState.maybeCollectFutureFinalizationCertificates(e.round, e.Storage.Height())
+	e.processFinalizedBlock(&finalizedBlock)
 }

replication.go

@@ -16,7 +16,7 @@ type ReplicationState struct {
 	maxRoundWindow uint64
 	comm           Communication
 	id             NodeID
-	quorumSize    int
+	quorumSize     int
 
 	// latest seq requested
 	lastSequenceRequested uint64
@@ -25,17 +25,17 @@ type ReplicationState struct {
 	highestFCertReceived *FinalizationCertificate
 
 	// received
-	receivedFinalizationCertificates map[uint64]SequenceData
+	receivedFinalizationCertificates map[uint64]FinalizedBlock
 }
 
 func NewReplicationState(logger Logger, comm Communication, id NodeID, maxRoundWindow uint64) *ReplicationState {
 	return &ReplicationState{
-		quorumSize: Quorum(len(comm.ListNodes())),
-		logger:         logger,
-		comm:           comm,
-		id:             id,
-		maxRoundWindow: maxRoundWindow,
-		receivedFinalizationCertificates: make(map[uint64]SequenceData),
+		quorumSize:                       Quorum(len(comm.ListNodes())),
+		logger:                           logger,
+		comm:                             comm,
+		id:                               id,
+		maxRoundWindow:                   maxRoundWindow,
+		receivedFinalizationCertificates: make(map[uint64]FinalizedBlock),
 	}
 }
 
@@ -118,7 +118,7 @@ func (r *ReplicationState) ShouldReplicate(round uint64) bool {
 	return r.highestFCertReceived.Finalization.BlockHeader.Round >= round
 }
 
-func (r *ReplicationState) StoreSequenceData(data SequenceData) (error) {
+func (r *ReplicationState) StoreFinalizedBlock(data FinalizedBlock) error {
 	// ensure the finalization certificate we get relates to the block
 	blockDigest := data.Block.BlockHeader().Digest
 	if !bytes.Equal(blockDigest[:], data.FCert.Finalization.BlockHeader.Digest[:]) {

replication_test.go

@@ -164,10 +164,10 @@ func TestReplicationStartsBeforeCurrentRound(t *testing.T) {
 	}
 }
 
-func createBlocks(t *testing.T, nodes []simplex.NodeID, bb simplex.BlockBuilder, seqCount uint64) []simplex.SequenceData {
+func createBlocks(t *testing.T, nodes []simplex.NodeID, bb simplex.BlockBuilder, seqCount uint64) []simplex.FinalizedBlock {
 	logger := testutil.MakeLogger(t, int(0))
 	ctx := context.Background()
-	data := make([]simplex.SequenceData, 0, seqCount)
+	data := make([]simplex.FinalizedBlock, 0, seqCount)
 	var prev simplex.Digest
 	for i := uint64(0); i < seqCount; i++ {
 		protocolMetadata := simplex.ProtocolMetadata{
@@ -180,7 +180,7 @@ func createBlocks(t *testing.T, nodes []simplex.NodeID, bb simplex.BlockBuilder,
 		require.True(t, ok)
 		prev = block.BlockHeader().Digest
 		fCert, _ := newFinalizationRecord(t, logger, &testSignatureAggregator{}, block, nodes)
-		data = append(data, simplex.SequenceData{
+		data = append(data, simplex.FinalizedBlock{
 			Block: block,
 			FCert: fCert,
 		})

util.go

@@ -24,7 +24,6 @@ func RetrieveLastIndexFromStorage(s Storage) (Block, *FinalizationCertificate, e
 	return lastBlock, &fCert, nil
 }
 
-
 func isFinalizationCertificateValid(fCert *FinalizationCertificate, quorumSize int, logger Logger) (bool, error) {
 	valid, err := validateFinalizationQC(fCert, quorumSize, logger)
 	if err != nil {