feat: faster filtering and more test coverage

datastore/redis_test.go

@@ -453,7 +453,7 @@ func TestSetMevCommitBlockBuilders(t *testing.T) {
 	// Set a commit block builder
 	builder := mevcommitclient.MevCommitProvider{
 		Pubkey:     []byte(builderPubkey),
-		EOAAddress: gethCommon.HexToAddress("0x0000000000000000000000000000000000000000"),
+		EOAAddress: gethCommon.HexToAddress("0x0000000000000000000000000000000000000001"),
 	}
 	err := cache.SetMevCommitBlockBuilder(builder)
 	require.NoError(t, err)
@@ -464,6 +464,7 @@ func TestSetMevCommitBlockBuilders(t *testing.T) {
 	require.Len(t, builders, 1)
 	require.Equal(t, builder, builders[0])
 	require.Equal(t, builderPubkey, string(builders[0].Pubkey))
+	require.Equal(t, gethCommon.HexToAddress("0x0000000000000000000000000000000000000001"), builders[0].EOAAddress)
 
 	// Check if the commit block builder is set correctly
 	isSet, err := cache.IsMevCommitBlockBuilder(common.PubkeyHex(builderPubkey))

mevcommitclient/mev_commit_client.go

@@ -105,34 +105,70 @@ func (m *MevCommitClient) GetOptInStatusForValidators(pubkeys [][]byte) ([]bool,
 }
 
 func (m *MevCommitClient) ListenForBuildersEvents() (<-chan MevCommitProvider, <-chan common.Address, error) {
-	startBlock := uint64(0)
-	opts := &bind.WatchOpts{
-		Start:   &startBlock, // Start from the latest block
+	// Get the latest block number from mev-commit-geth
+	latestBlock, err := m.mevCommitClient.BlockNumber(context.Background())
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to get latest block number from mev-commit-geth: %w", err)
+	}
+	filterOpts := &bind.FilterOpts{
+		Start:   0,
+		End:     &latestBlock, // Latest block
+		Context: context.Background(),
+	}
+	watchOpts := &bind.WatchOpts{
+		Start:   &latestBlock,
 		Context: context.Background(),
 	}
 	builderRegistryEventCh := make(chan MevCommitProvider)
 	builderUnregisteredEventCh := make(chan common.Address)
 
-	providerRegisteredEventCh := make(chan *providerRegistry.ProviderregistryProviderRegistered)
-	providerSlashedEventCh := make(chan *providerRegistry.ProviderregistryFundsSlashed)
+	providerRegisteredIterator, err := m.builderRegistryFilterer.FilterProviderRegistered(filterOpts, nil)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to filter ProviderRegistered events: %w", err)
+	}
 
-	providerRegisteredSub, err := m.builderRegistryFilterer.WatchProviderRegistered(opts, providerRegisteredEventCh, nil)
+	providerRegisteredEventCh := make(chan *providerRegistry.ProviderregistryProviderRegistered)
+	providerRegisteredSub, err := m.builderRegistryFilterer.WatchProviderRegistered(watchOpts, providerRegisteredEventCh, nil)
 	if err != nil {
+		providerRegisteredIterator.Close()
 		return nil, nil, fmt.Errorf("failed to watch ProviderRegistered events: %w", err)
 	}
 
-	providerSlashedSub, err := m.builderRegistryFilterer.WatchFundsSlashed(opts, providerSlashedEventCh, nil)
+	providerSlashedIterator, err := m.builderRegistryFilterer.FilterFundsSlashed(filterOpts, nil)
+	if err != nil {
+		providerRegisteredIterator.Close()
+		providerRegisteredSub.Unsubscribe()
+		return nil, nil, fmt.Errorf("failed to filter FundsSlashed events: %w", err)
+	}
+
+	providerSlashedEventCh := make(chan *providerRegistry.ProviderregistryFundsSlashed)
+	providerSlashedSub, err := m.builderRegistryFilterer.WatchFundsSlashed(watchOpts, providerSlashedEventCh, nil)
 	if err != nil {
+		providerRegisteredIterator.Close()
+		providerSlashedIterator.Close()
 		providerRegisteredSub.Unsubscribe()
 		return nil, nil, fmt.Errorf("failed to watch ProviderSlashed events: %w", err)
 	}
 
 	go func() {
+		defer providerRegisteredIterator.Close()
 		defer providerRegisteredSub.Unsubscribe()
+
+		for providerRegisteredIterator.Next() {
+			event := providerRegisteredIterator.Event
+			builderRegistryEventCh <- MevCommitProvider{
+				Pubkey:     event.BlsPublicKey,
+				EOAAddress: event.Provider,
+			}
+		}
+		if err := providerRegisteredIterator.Error(); err != nil {
+			fmt.Printf("error while iterating ProviderRegistered events: %v\n", err)
+		}
+
 		for {
 			select {
 			case err := <-providerRegisteredSub.Err():
-				fmt.Printf("error while watching ProviderRegistered events: %v\n", err)
+				fmt.Printf("error in ProviderRegistered subscription: %v\n", err)
 				close(builderRegistryEventCh)
 				return
 			case event := <-providerRegisteredEventCh:
@@ -146,6 +182,23 @@ func (m *MevCommitClient) ListenForBuildersEvents() (<-chan MevCommitProvider, <
 
 	go func() {
 		defer providerSlashedSub.Unsubscribe()
+		defer providerSlashedIterator.Close()
+
+		for providerSlashedIterator.Next() {
+			event := providerSlashedIterator.Event
+			isValid, err := m.IsBuilderValid(event.Provider)
+			if err != nil {
+				fmt.Printf("failed to check if builder is valid: %v\n", err)
+				continue
+			}
+			if !isValid {
+				builderUnregisteredEventCh <- event.Provider
+			}
+		}
+		if err := providerSlashedIterator.Error(); err != nil {
+			fmt.Printf("error while iterating FundsSlashed events: %v\n", err)
+		}
+
 		for {
 			select {
 			case err := <-providerSlashedSub.Err():

mevcommitclient/mev_commit_client_test.go

@@ -2,6 +2,7 @@ package mevcommitclient
 
 import (
 	"testing"
+	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/stretchr/testify/assert"
@@ -59,3 +60,30 @@ func TestGetOptInStatusForValidators(t *testing.T) {
 		assert.IsType(t, bool(true), status)
 	}
 }
+
+func TestListenForBuildersEvents(t *testing.T) {
+	client, err := NewMevCommitClient(
+		ethereumL1RPC,
+		"wss://chainrpc-wss.testnet.mev-commit.xyz",
+		common.HexToAddress(validatorOptInRouterAddr),
+		common.HexToAddress(providerRegistryAddr),
+	)
+	require.NoError(t, err)
+
+	builderRegisteredCh, _, err := client.ListenForBuildersEvents()
+	require.NoError(t, err)
+
+	// Start a goroutine to listen for events
+	go func() {
+		select {
+		case _ = <-builderRegisteredCh:
+
+		case <-time.After(10 * time.Second):
+			t.Log("No events received after 10 seconds")
+			t.Fail() // Add this line to fail the test if no events are received
+		}
+	}()
+
+	time.Sleep(15 * time.Second)
+
+}

services/housekeeper/housekeeper.go

@@ -73,6 +73,7 @@ func NewHousekeeper(opts *HousekeeperOpts) *Housekeeper {
 		pprofAPI:              opts.PprofAPI,
 		pprofListenAddress:    opts.PprofListenAddress,
 		proposersAlreadySaved: make(map[uint64]string),
+		mevCommitClient:       opts.MevCommitClient,
 	}
 
 	return server