Update tests

config/config.go

@@ -685,7 +685,6 @@ type P2PConfig struct { //nolint: maligned
 
 	// List of node IDs, to which a connection will be (re)established ignoring any existing limits
 	UnconditionalPeerIDs string `mapstructure:"unconditional-peer-ids"`
-
 }
 
 // DefaultP2PConfig returns a default configuration for the peer-to-peer layer
@@ -913,10 +912,6 @@ type StateSyncConfig struct {
 
 	// Timeout before considering light block verification failed
 	VerifyLightBlockTimeout time.Duration `mapstructure:"verify-light-block-timeout"`
-
-	// Minimum time bad witnesses must spend in blacklist before potentially being
-	// added back as a provider again.
-	BlackListTTL time.Duration `mapstructure:"black-list-ttl"`
 }
 
 func (cfg *StateSyncConfig) TrustHashBytes() []byte {
@@ -938,7 +933,6 @@ func DefaultStateSyncConfig() *StateSyncConfig {
 		BackfillBlocks:          0,
 		BackfillDuration:        0 * time.Second,
 		VerifyLightBlockTimeout: 60 * time.Second,
-		BlackListTTL:            30000 * time.Millisecond,
 	}
 }
 
@@ -1004,10 +998,6 @@ func (cfg *StateSyncConfig) ValidateBasic() error {
 		return errors.New("fetchers is required")
 	}
 
-	if cfg.BlackListTTL < 0 {
-		return errors.New("black-list-ttl must not be negative")
-	}
-
 	return nil
 }
 

config/toml.go

@@ -345,6 +345,7 @@ recv-rate = {{ .P2P.RecvRate }}
 # List of node IDs, to which a connection will be (re)established ignoring any existing limits
 unconditional-peer-ids = "{{ .P2P.UnconditionalPeerIDs }}"
 
+
 #######################################################
 ###          Mempool Configuration Option          ###
 #######################################################
@@ -459,10 +460,6 @@ fetchers = "{{ .StateSync.Fetchers }}"
 
 verify-light-block-timeout = "{{ .StateSync.VerifyLightBlockTimeout }}"
 
-# Minimum time bad witnesses must spend in blacklist before potentially being
-# added back as a provider again.
-black-list-ttl = "{{ .P2P.BlackListTTL }}"
-
 #######################################################
 ###         Consensus Configuration Options         ###
 #######################################################

light/client_test.go

@@ -76,6 +76,7 @@ func TestClient(t *testing.T) {
 		l3 = &types.LightBlock{SignedHeader: h3, ValidatorSet: vals}
 		id1 = "id1"
 		id2 = "id2"
+		id3 = "id3"
 	)
 	t.Run("ValidateTrustOptions", func(t *testing.T) {
 		testCases := []struct {
@@ -697,19 +698,22 @@ func TestClient(t *testing.T) {
 
 		mockFullNode := &provider_mocks.Provider{}
 		mockFullNode.On("LightBlock", mock.Anything, mock.Anything).Return(l1, nil)
-		mockFullNode.On("ID", mock.Anything, mock.Anything).Return(id1, nil)
+
+		mockFullNode1 := &provider_mocks.Provider{}
+		mockFullNode1.On("LightBlock", mock.Anything, mock.Anything).Return(l1, nil)
+		mockFullNode1.On("ID", mock.Anything, mock.Anything).Return(id2, nil)
+
 		mockDeadNode := &provider_mocks.Provider{}
 		mockDeadNode.On("LightBlock", mock.Anything, mock.Anything).Return(nil, provider.ErrNoResponse)
-		mockFullNode.On("ID", mock.Anything, mock.Anything).Return(id2, nil)
+		mockDeadNode.On("ID", mock.Anything, mock.Anything).Return(id3, nil)
 
 		logger := log.NewNopLogger()
-
 		c, err := light.NewClient(
 			ctx,
 			chainID,
 			trustOptions,
 			mockDeadNode,
-			[]provider.Provider{mockDeadNode, mockFullNode},
+			[]provider.Provider{mockDeadNode, mockFullNode, mockFullNode1},
 			dbs.New(dbm.NewMemDB()),
 			light.Logger(logger),
 		)
@@ -721,10 +725,9 @@ func TestClient(t *testing.T) {
 		// the primary should no longer be the deadNode
 		assert.NotEqual(t, c.Primary(), mockDeadNode)
 
-		// we should still have the dead node as a witness because it
-		// hasn't repeatedly been unresponsive yet
-		assert.Equal(t, 2, len(c.Witnesses()))
+		assert.Equal(t, 1, len(c.Witnesses()))
 		mockDeadNode.AssertExpectations(t)
+		mockFullNode1.AssertExpectations(t)
 		mockFullNode.AssertExpectations(t)
 	})
 	t.Run("ReplacesPrimaryWithWitnessIfPrimaryDoesntHaveBlock", func(t *testing.T) {
@@ -753,9 +756,7 @@ func TestClient(t *testing.T) {
 		_, err = c.Update(ctx, bTime.Add(2*time.Hour))
 		require.NoError(t, err)
 
-		// we should still have the dead node as a witness because it
-		// hasn't repeatedly been unresponsive yet
-		assert.Equal(t, 2, len(c.Witnesses()))
+		assert.Equal(t, 1, len(c.Witnesses()))
 		mockFullNode.AssertExpectations(t)
 	})
 	t.Run("BackwardsVerification", func(t *testing.T) {
@@ -902,9 +903,9 @@ func TestClient(t *testing.T) {
 		}
 		mockBadNode2 := mockNodeFromHeadersAndVals(headers2, vals2)
 		mockBadNode2.On("LightBlock", mock.Anything, mock.Anything).Return(nil, provider.ErrLightBlockNotFound)
-		mockBadNode2.On("ID", mock.Anything, mock.Anything).Return(id2, nil)
 
 		mockFullNode := mockNodeFromHeadersAndVals(headerSet, valSet)
+		mockFullNode.On("ID", mock.Anything, mock.Anything).Return(id3, nil)
 
 		ctx, cancel := context.WithCancel(context.Background())
 		defer cancel()
@@ -935,7 +936,7 @@ func TestClient(t *testing.T) {
 		// remaining witnesses don't have light block -> error
 		_, err = c.VerifyLightBlockAtHeight(ctx, 3, bTime.Add(2*time.Hour))
 		if assert.Error(t, err) {
-			assert.Equal(t, light.ErrFailedHeaderCrossReferencing, err)
+			assert.Equal(t, light.ErrNoWitnesses, err)
 		}
 		// witness does not have a light block -> left in the list
 		assert.EqualValues(t, 1, len(c.Witnesses()))
@@ -973,7 +974,6 @@ func TestClient(t *testing.T) {
 				1: vals,
 				2: vals,
 			})
-		mockFullNode.On("ID", mock.Anything, mock.Anything).Return(id1, nil)
 
 		c, err := light.NewClient(
 			ctx,

light/detector_test.go

@@ -283,6 +283,7 @@ func TestLightClientAttackEvidence_ForwardLunatic(t *testing.T) {
 	lastBlock, _ = mockWitness.LightBlock(ctx, latestHeight)
 	mockWitness.On("LightBlock", mock.Anything, int64(0)).Return(lastBlock, nil).Once()
 	mockWitness.On("LightBlock", mock.Anything, int64(12)).Return(nil, provider.ErrHeightTooHigh)
+	mockWitness.On("ID", mock.Anything, mock.Anything).Return("mockWitness", nil)
 
 	mockWitness.On("ReportEvidence", mock.Anything, mock.MatchedBy(func(evidence types.Evidence) bool {
 		// Check evidence was sent to the witness against the full node
@@ -358,6 +359,7 @@ func TestLightClientAttackEvidence_ForwardLunatic(t *testing.T) {
 	// in enough time
 	mockLaggingWitness := mockNodeFromHeadersAndVals(witnessHeaders, witnessValidators)
 	mockLaggingWitness.On("LightBlock", mock.Anything, int64(12)).Return(nil, provider.ErrHeightTooHigh)
+	mockLaggingWitness.On("ID", mock.Anything, mock.Anything).Return("mockLaggingWitness", nil)
 	lastBlock, _ = mockLaggingWitness.LightBlock(ctx, latestHeight)
 	mockLaggingWitness.On("LightBlock", mock.Anything, int64(0)).Return(lastBlock, nil)
 	c, err = light.NewClient(
@@ -449,7 +451,7 @@ func TestClientDivergentTraces2(t *testing.T) {
 
 	_, err = c.VerifyLightBlockAtHeight(ctx, 2, bTime.Add(1*time.Hour))
 	assert.NoError(t, err)
-	assert.Equal(t, 3, len(c.Witnesses()))
+	assert.Equal(t, 1, len(c.Witnesses()))
 	mockDeadNode.AssertExpectations(t)
 	mockPrimaryNode.AssertExpectations(t)
 }