Decouple Outgoing/Incoming Message Types

epoch.go

@@ -302,7 +302,7 @@ func (e *Epoch) resumeFromWal(records [][]byte) error {
 				return err
 			}
 			proposal := &Message{
-				BlockMessage: &BlockMessage{
+				VerifiedBlockMessage: &VerifiedBlockMessage{
 					VerifiedBlock: block,
 					Vote:          vote,
 				},
@@ -1665,7 +1665,7 @@ func (e *Epoch) proposeBlock(block VerifiedBlock) error {
 	}
 
 	proposal := &Message{
-		BlockMessage: &BlockMessage{
+		VerifiedBlockMessage: &VerifiedBlockMessage{
 			VerifiedBlock: block,
 			Vote:          vote,
 		},
@@ -2061,34 +2061,34 @@ func (e *Epoch) HandleReplicationRequest(req *ReplicationRequest, from NodeID) *
 	}
 	response := &ReplicationResponse{}
 	if req.FinalizationCertificateRequest != nil {
-		response.FinalizationCertificateResponse = e.handleFinalizationCertificateRequest(req.FinalizationCertificateRequest)
+		response.VerifiedFinalizationCertificateResponse = e.handleFinalizationCertificateRequest(req.FinalizationCertificateRequest)
 	}
 
 	msg := &Message{ReplicationResponse: response}
 	e.Comm.SendMessage(msg, from)
 	return response
 }
 
-func (e *Epoch) handleFinalizationCertificateRequest(req *FinalizationCertificateRequest) *FinalizationCertificateResponse {
+func (e *Epoch) handleFinalizationCertificateRequest(req *FinalizationCertificateRequest) *VerifiedFinalizationCertificateResponse {
 	e.Logger.Debug("Received finalization certificate request", zap.Int("num seqs", len(req.Sequences)))
 	seqs := req.Sequences
 	slices.Sort(seqs)
 
-	data := make([]FinalizedBlock, len(seqs))
+	data := make([]VerifiedFinalizedBlock, len(seqs))
 	for i, seq := range seqs {
 		block, fCert, found := e.locateSequence(seq)
 		if !found {
 			// since we are sorted, we can break early
 			data = data[:i]
 			break
 		}
-		data[i] = FinalizedBlock{
+		data[i] = VerifiedFinalizedBlock{
 			VerifiedBlock: block,
 			FCert:         fCert,
 		}
 	}
 	e.Logger.Debug("Sending finalization certificate response", zap.Int("num seqs", len(data)), zap.Any("seqs", seqs))
-	return &FinalizationCertificateResponse{
+	return &VerifiedFinalizationCertificateResponse{
 		Data: data,
 	}
 }

epoch_multinode_test.go

@@ -43,7 +43,7 @@ func (t *testNode) start() {
 	require.NoError(t.t, t.e.Start())
 }
 
-func newSimplexNodeWithStorage(t *testing.T, nodeID NodeID, net *inMemNetwork, bb BlockBuilder, storage []FinalizedBlock) *testNode {
+func newSimplexNodeWithStorage(t *testing.T, nodeID NodeID, net *inMemNetwork, bb BlockBuilder, storage []VerifiedFinalizedBlock) *testNode {
 	wal := newTestWAL(t)
 	conf := defaultTestNodeEpochConfig(t, nodeID, net, wal, bb, true)
 	for _, data := range storage {
@@ -279,16 +279,39 @@ func (c *testComm) SendMessage(msg *Message, destination NodeID) {
 
 func (c *testComm) maybeTranslateOutoingToIncomingMessageTypes(msg *Message) {
 	if msg.ReplicationResponse != nil {
-		data := make([]FinalizedBlock, 0, len(msg.ReplicationResponse.FinalizationCertificateResponse.Data))
+		verifiedFCertResponse := msg.ReplicationResponse.VerifiedFinalizationCertificateResponse
 
-		for _, datum := range msg.ReplicationResponse.FinalizationCertificateResponse.Data {
-			// Outgoing block is of type verified block but incoming block is of type Block,
-			// so we do a type cast because the test block implements both.
-			datum.Block = datum.VerifiedBlock.(Block)
-			data = append(data, datum)
+		if verifiedFCertResponse != nil {
+			data := make([]FinalizedBlock, 0, len(verifiedFCertResponse.Data))
+
+			for _, verifiedData := range verifiedFCertResponse.Data {
+				// Outgoing block is of type verified block but incoming block is of type Block,
+				// so we do a type cast because the test block implements both.
+				finalizedBlock := FinalizedBlock{
+					Block: verifiedData.VerifiedBlock.(Block),
+					FCert: verifiedData.FCert,
+				}
+				data = append(data, finalizedBlock)
+			}
+
+			require.Nil(
+				c.net.t,
+				msg.ReplicationResponse.FinalizationCertificateResponse,
+				"message cannot include FinalizationCertificateResponse & VerifiedFinalizationCertificateResponse",
+			)
+
+			msg.ReplicationResponse.FinalizationCertificateResponse = &FinalizationCertificateResponse{
+				Data: data,
+			}
 		}
+	}
 
-		msg.ReplicationResponse.FinalizationCertificateResponse.Data = data
+	if msg.VerifiedBlockMessage != nil {
+		require.Nil(c.net.t, msg.BlockMessage, "message cannot include BlockMessage & VerifiedBlockMessage")
+		msg.BlockMessage = &BlockMessage{
+			Block: msg.VerifiedBlockMessage.VerifiedBlock.(Block),
+			Vote:  msg.VerifiedBlockMessage.Vote,
+		}
 	}
 }
 
@@ -297,9 +320,7 @@ func (c *testComm) Broadcast(msg *Message) {
 		return
 	}
 
-	if msg.BlockMessage != nil {
-		msg.BlockMessage.Block = msg.BlockMessage.VerifiedBlock.(Block)
-	}
+	c.maybeTranslateOutoingToIncomingMessageTypes(msg)
 
 	for _, instance := range c.net.instances {
 		// Skip sending the message to yourself or disconnected nodes

msg.go

@@ -11,6 +11,7 @@ import (
 
 type Message struct {
 	BlockMessage            *BlockMessage
+	VerifiedBlockMessage    *VerifiedBlockMessage
 	EmptyNotarization       *EmptyNotarization
 	VoteMessage             *Vote
 	EmptyVoteMessage        *EmptyVote
@@ -184,7 +185,11 @@ func (n *Notarization) Verify() error {
 }
 
 type BlockMessage struct {
-	Block         Block
+	Block Block
+	Vote  Vote
+}
+
+type VerifiedBlockMessage struct {
 	VerifiedBlock VerifiedBlock
 	Vote          Vote
 }
@@ -220,7 +225,8 @@ type ReplicationRequest struct {
 }
 
 type ReplicationResponse struct {
-	FinalizationCertificateResponse *FinalizationCertificateResponse
+	FinalizationCertificateResponse         *FinalizationCertificateResponse
+	VerifiedFinalizationCertificateResponse *VerifiedFinalizationCertificateResponse
 }
 
 // request a finalization certificate for the given sequence number
@@ -229,11 +235,19 @@ type FinalizationCertificateRequest struct {
 }
 
 type FinalizedBlock struct {
-	Block         Block
+	Block Block
+	FCert FinalizationCertificate
+}
+
+type VerifiedFinalizedBlock struct {
 	VerifiedBlock VerifiedBlock
 	FCert         FinalizationCertificate
 }
 
 type FinalizationCertificateResponse struct {
 	Data []FinalizedBlock
 }
+
+type VerifiedFinalizationCertificateResponse struct {
+	Data []VerifiedFinalizedBlock
+}

replication_test.go

@@ -51,19 +51,19 @@ func TestHandleFinalizationCertificateRequest(t *testing.T) {
 		Sequences: sequences,
 	}}
 	resp := e.HandleReplicationRequest(req, nodes[1])
-	require.NotNil(t, resp.FinalizationCertificateResponse)
-	require.Equal(t, len(sequences), len(resp.FinalizationCertificateResponse.Data))
-	for i, data := range resp.FinalizationCertificateResponse.Data {
+	require.NotNil(t, resp.VerifiedFinalizationCertificateResponse)
+	require.Equal(t, len(sequences), len(resp.VerifiedFinalizationCertificateResponse.Data))
+	for i, data := range resp.VerifiedFinalizationCertificateResponse.Data {
 		require.Equal(t, seqs[i].FCert, data.FCert)
-		require.Equal(t, seqs[i].Block, data.Block)
+		require.Equal(t, seqs[i].VerifiedBlock, data.VerifiedBlock)
 	}
 
 	// request out of scope
 	req = &simplex.ReplicationRequest{FinalizationCertificateRequest: &simplex.FinalizationCertificateRequest{
 		Sequences: []uint64{11, 12, 13},
 	}}
 	resp = e.HandleReplicationRequest(req, nodes[1])
-	require.Zero(t, len(resp.FinalizationCertificateResponse.Data))
+	require.Zero(t, len(resp.VerifiedFinalizationCertificateResponse.Data))
 }
 
 func TestNilFinalizationCertificateResponse(t *testing.T) {
@@ -370,10 +370,10 @@ func advanceWithoutLeader(t *testing.T, net *inMemNetwork, bb *testControlledBlo
 	}
 }
 
-func createBlocks(t *testing.T, nodes []simplex.NodeID, bb simplex.BlockBuilder, seqCount uint64) []simplex.FinalizedBlock {
+func createBlocks(t *testing.T, nodes []simplex.NodeID, bb simplex.BlockBuilder, seqCount uint64) []simplex.VerifiedFinalizedBlock {
 	logger := testutil.MakeLogger(t, int(0))
 	ctx := context.Background()
-	data := make([]simplex.FinalizedBlock, 0, seqCount)
+	data := make([]simplex.VerifiedFinalizedBlock, 0, seqCount)
 	var prev simplex.Digest
 	for i := uint64(0); i < seqCount; i++ {
 		protocolMetadata := simplex.ProtocolMetadata{
@@ -386,7 +386,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.FinalizedBlock{
+		data = append(data, simplex.VerifiedFinalizedBlock{
 			VerifiedBlock: block,
 			FCert:         fCert,
 		})