Try to collect an empty notarization after sending an empty vote (#94)

A node might be the last node among a quorum that times out.
It therefore receives the empty votes before sending the empty vote itself,
so it should check if it is possible to assemble an empty notarization right after
sending the empty vote, because otherwise it might never get a trigger to check
if an empty notarization can be assembled.

Signed-off-by: Yacov Manevich <yacov.manevich@avalabs.org>

Author: yacovm

epoch.go

@@ -1587,6 +1587,11 @@ func (e *Epoch) triggerProposalWaitTimeExpired(round uint64) {
 	emptyVotes.votes[string(e.ID)] = &signedEV
 
 	e.Comm.Broadcast(&Message{EmptyVoteMessage: &signedEV})
+
+	if err := e.maybeAssembleEmptyNotarization(); err != nil {
+		e.Logger.Error("Failed assembling empty notarization", zap.Error(err))
+		e.haltedError = err
+	}
 }
 
 func (e *Epoch) monitorProgress(round uint64) {

epoch_failover_test.go

@@ -15,6 +15,108 @@ import (
 	"go.uber.org/zap/zapcore"
 )
 
+func TestEpochLeaderFailoverReceivesEmptyVotesEarly(t *testing.T) {
+	l := testutil.MakeLogger(t, 1)
+
+	bb := &testBlockBuilder{out: make(chan *testBlock, 1), blockShouldBeBuilt: make(chan struct{}, 1)}
+	storage := newInMemStorage()
+
+	nodes := []NodeID{{1}, {2}, {3}, {4}}
+	quorum := Quorum(len(nodes))
+
+	wal := newTestWAL(t)
+
+	start := time.Now()
+	conf := EpochConfig{
+		MaxProposalWait:     DefaultMaxProposalWaitTime,
+		StartTime:           start,
+		Logger:              l,
+		ID:                  nodes[0],
+		Signer:              &testSigner{},
+		WAL:                 wal,
+		Verifier:            &testVerifier{},
+		Storage:             storage,
+		Comm:                noopComm(nodes),
+		BlockBuilder:        bb,
+		SignatureAggregator: &testSignatureAggregator{},
+	}
+
+	e, err := NewEpoch(conf)
+	require.NoError(t, err)
+
+	require.NoError(t, e.Start())
+
+	// Run through 3 blocks, to make the block proposals be:
+	// 1 --> 2 --> 3 --> X (node 4 doesn't propose a block)
+
+	// Then, don't do anything and wait for our node
+	// to start complaining about a block not being notarized
+
+	for round := uint64(0); round < 3; round++ {
+		notarizeAndFinalizeRound(t, nodes, round, round, e, bb, quorum, storage, false)
+	}
+
+	lastBlock, _, ok := storage.Retrieve(storage.Height() - 1)
+	require.True(t, ok)
+
+	prev := lastBlock.BlockHeader().Digest
+
+	emptyBlockMd := ProtocolMetadata{
+		Round: 3,
+		Seq:   2,
+		Prev:  prev,
+	}
+
+	emptyVoteFrom1 := createEmptyVote(emptyBlockMd, nodes[1])
+	emptyVoteFrom2 := createEmptyVote(emptyBlockMd, nodes[2])
+
+	e.HandleMessage(&Message{
+		EmptyVoteMessage: emptyVoteFrom1,
+	}, nodes[1])
+	e.HandleMessage(&Message{
+		EmptyVoteMessage: emptyVoteFrom2,
+	}, nodes[2])
+
+	bb.blockShouldBeBuilt <- struct{}{}
+
+	waitForBlockProposerTimeout(t, e, start)
+
+	wal.lock.Lock()
+	walContent, err := wal.ReadAll()
+	require.NoError(t, err)
+	wal.lock.Unlock()
+
+	rawEmptyVote, rawEmptyNotarization, rawProposal := walContent[len(walContent)-3], walContent[len(walContent)-2], walContent[len(walContent)-1]
+	emptyVote, err := ParseEmptyVoteRecord(rawEmptyVote)
+	require.NoError(t, err)
+	require.Equal(t, createEmptyVote(emptyBlockMd, nodes[0]).Vote, emptyVote)
+
+	emptyNotarization, err := EmptyNotarizationFromRecord(rawEmptyNotarization, &testQCDeserializer{t: t})
+	require.NoError(t, err)
+	require.Equal(t, emptyVoteFrom1.Vote, emptyNotarization.Vote)
+	require.Equal(t, uint64(3), emptyNotarization.Vote.Round)
+	require.Equal(t, uint64(2), emptyNotarization.Vote.Seq)
+	require.Equal(t, uint64(3), storage.Height())
+
+	header, _, err := ParseBlockRecord(rawProposal)
+	require.NoError(t, err)
+	require.Equal(t, uint64(4), header.Round)
+	require.Equal(t, uint64(3), header.Seq)
+
+	// Ensure our node proposes block with sequence 3 for round 4
+	block := <-bb.out
+
+	for i := 1; i <= quorum; i++ {
+		injectTestFinalization(t, e, block, nodes[i])
+	}
+
+	block2 := storage.waitForBlockCommit(3)
+	require.Equal(t, block, block2)
+	require.Equal(t, uint64(4), storage.Height())
+	require.Equal(t, uint64(4), block2.BlockHeader().Round)
+	require.Equal(t, uint64(3), block2.BlockHeader().Seq)
+}
+
 func TestEpochLeaderFailover(t *testing.T) {
 	l := testutil.MakeLogger(t, 1)