core/consensus: add new consensus round timer

app/featureset/featureset.go

@@ -45,6 +45,9 @@ const (
 	// The feature gets automatically enabled when the current network is gnosis|chiado,
 	// unless the user disabled this feature explicitly.
 	GnosisBlockHotfix Feature = "gnosis_block_hotfix"
+
+	// Exponential enables Exponential round timer for consensus rounds.
+	Exponential Feature = "exponential"
 )
 
 var (
@@ -56,6 +59,7 @@ var (
 		AggSigDBV2:           statusAlpha,
 		JSONRequests:         statusAlpha,
 		GnosisBlockHotfix:    statusAlpha,
+		Exponential:          statusAlpha,
 		// Add all features and there status here.
 	}
 

app/featureset/featureset_internal_test.go

@@ -16,6 +16,7 @@ func TestAllFeatureStatus(t *testing.T) {
 		ConsensusParticipate,
 		JSONRequests,
 		GnosisBlockHotfix,
+		Exponential,
 	}
 
 	for _, feature := range features {

core/consensus/utils/roundtimer.go

@@ -3,6 +3,7 @@
 package utils
 
 import (
+	"math"
 	"strings"
 	"sync"
 	"time"
@@ -23,7 +24,14 @@
 type TimerFunc func(core.Duty) RoundTimer
 
 // GetTimerFunc returns a timer function based on the enabled features.
 func GetTimerFunc() TimerFunc {
+
+	if featureset.Enabled(featureset.Exponential) {
+		return func(core.Duty) RoundTimer {
+			return NewExponentialRoundTimer()
+		}
+	}
+
 	if featureset.Enabled(featureset.EagerDoubleLinear) {
 		return func(core.Duty) RoundTimer {
 			return NewDoubleEagerLinearRoundTimer()
@@ -47,6 +55,7 @@
 const (
 	TimerIncreasing        TimerType = "inc"
 	TimerEagerDoubleLinear TimerType = "eager_dlinear"
+	Exponential            TimerType = "exponential"
 )
 
 // increasingRoundTimeout returns the duration for a round that starts at incRoundStart in round 1
@@ -150,3 +159,40 @@
 
 	return timer.Chan(), func() { timer.Stop() }
 }
+
+// exponentialRoundTimer implements a round timerType with the following properties:
+//
+// The first round has one second to complete consensus
+// If this round fails then other peers already had time to fetch proposal and therefore
+// won't need as much time to reach a consensus. Therefore start timeout with lower value
+// which will increase exponentially
+type exponentialRoundTimer struct {
+	clock clockwork.Clock
+}
+
+func (*exponentialRoundTimer) Type() TimerType {
+	return Exponential
+}
+
+func (t *exponentialRoundTimer) Timer(round int64) (<-chan time.Time, func()) {
+	var timer clockwork.Timer
+	if round == 1 {
+		// First round has 1 second
+		timer = t.clock.NewTimer(time.Second)
+	} else {
+		// Subsequent rounds have exponentially more time starting at 200 milliseconds
+		timer = t.clock.NewTimer(time.Millisecond * time.Duration(math.Pow(2, float64(round-1))*100))
+	}
+	return timer.Chan(), func() { timer.Stop() }
+}
+
+// NewExponentialRoundTimer returns a new exponential round timer type.
+func NewExponentialRoundTimer() RoundTimer {
+	return NewExponentialRoundTimerWithClock(clockwork.NewRealClock())
+}
+
+func NewExponentialRoundTimerWithClock(clock clockwork.Clock) RoundTimer {
+	return &exponentialRoundTimer{
+		clock: clock,
+	}
+}

core/consensus/utils/roundtimer_test.go

@@ -111,6 +111,58 @@ func TestDoubleEagerLinearRoundTimer(t *testing.T) {
 	stop()
 }
 
+func TestExponentialRoundTimer(t *testing.T) {
+	tests := []struct {
+		name  string
+		round int64
+		want  time.Duration
+	}{
+		{
+			name:  "round 1",
+			round: 1,
+			want:  1000 * time.Millisecond,
+		},
+		{
+			name:  "round 2",
+			round: 2,
+			want:  200 * time.Millisecond,
+		},
+		{
+			name:  "round 3",
+			round: 3,
+			want:  400 * time.Millisecond,
+		},
+		{
+			name:  "round 4",
+			round: 4,
+			want:  800 * time.Millisecond,
+		},
+	}
+
+	for _, tt := range tests {
+		fakeClock := clockwork.NewFakeClock()
+		timer := utils.NewExponentialRoundTimerWithClock(fakeClock)
+
+		t.Run(tt.name, func(t *testing.T) {
+			// Start the timerType
+			timerC, stop := timer.Timer(tt.round)
+
+			// Advance the fake clock
+			fakeClock.Advance(tt.want)
+
+			// Check if the timerType fires
+			select {
+			case <-timerC:
+			default:
+				require.Fail(t, "Fail", "Timer(round %d) did not fire, want %v", tt.round, tt.want)
+			}
+
+			// Stop the timerType
+			stop()
+		})
+	}
+}
+
 func TestGetTimerFunc(t *testing.T) {
 	timerFunc := utils.GetTimerFunc()
 	require.Equal(t, utils.TimerEagerDoubleLinear, timerFunc(core.NewAttesterDuty(0)).Type())