feat: Enhance relay with whitelist filtering capability for validator and builder selection

Dockerfile

@@ -1,5 +1,5 @@
 # syntax=docker/dockerfile:1
-FROM golang:1.21 as builder
+FROM golang:1.23 AS builder
 ARG VERSION
 WORKDIR /build
 

cmd/api.go

@@ -28,20 +28,22 @@ var (
 	apiDefaultInternalAPIEnabled = os.Getenv("ENABLE_INTERNAL_API") == "1"
 
 	// Default Builder, Data, and Proposer API as true.
-	apiDefaultBuilderAPIEnabled  = os.Getenv("DISABLE_BUILDER_API") != "1"
-	apiDefaultDataAPIEnabled     = os.Getenv("DISABLE_DATA_API") != "1"
-	apiDefaultProposerAPIEnabled = os.Getenv("DISABLE_PROPOSER_API") != "1"
-
-	apiListenAddr   string
-	apiPprofEnabled bool
-	apiSecretKey    string
-	apiBlockSimURL  string
-	apiDebug        bool
-	apiBuilderAPI   bool
-	apiDataAPI      bool
-	apiInternalAPI  bool
-	apiProposerAPI  bool
-	apiLogTag       string
+	apiDefaultBuilderAPIEnabled         = os.Getenv("DISABLE_BUILDER_API") != "1"
+	apiDefaultDataAPIEnabled            = os.Getenv("DISABLE_DATA_API") != "1"
+	apiDefaultProposerAPIEnabled        = os.Getenv("DISABLE_PROPOSER_API") != "1"
+	apiDefaultMevCommitFilteringEnabled = os.Getenv("DISABLE_MEV_COMMIT_FILTERING") != "1"
+
+	apiMevCommitFiltering bool
+	apiListenAddr         string
+	apiPprofEnabled       bool
+	apiSecretKey          string
+	apiBlockSimURL        string
+	apiDebug              bool
+	apiBuilderAPI         bool
+	apiDataAPI            bool
+	apiInternalAPI        bool
+	apiProposerAPI        bool
+	apiLogTag             string
 )
 
 func init() {
@@ -68,6 +70,7 @@ func init() {
 	apiCmd.Flags().BoolVar(&apiDataAPI, "data-api", apiDefaultDataAPIEnabled, "enable data API (/data/...)")
 	apiCmd.Flags().BoolVar(&apiInternalAPI, "internal-api", apiDefaultInternalAPIEnabled, "enable internal API (/internal/...)")
 	apiCmd.Flags().BoolVar(&apiProposerAPI, "proposer-api", apiDefaultProposerAPIEnabled, "enable proposer API (/proposer/...)")
+	apiCmd.Flags().BoolVar(&apiMevCommitFiltering, "mev-commit-filtering", apiDefaultMevCommitFilteringEnabled, "enable mev-commit-filtering")
 }
 
 var apiCmd = &cobra.Command{
@@ -155,21 +158,21 @@ var apiCmd = &cobra.Command{
 		}
 
 		opts := api.RelayAPIOpts{
-			Log:           log,
-			ListenAddr:    apiListenAddr,
-			BeaconClient:  beaconClient,
-			Datastore:     ds,
-			Redis:         redis,
-			Memcached:     mem,
-			DB:            db,
-			EthNetDetails: *networkInfo,
-			BlockSimURL:   apiBlockSimURL,
-
-			BlockBuilderAPI: apiBuilderAPI,
-			DataAPI:         apiDataAPI,
-			InternalAPI:     apiInternalAPI,
-			ProposerAPI:     apiProposerAPI,
-			PprofAPI:        apiPprofEnabled,
+			Log:                log,
+			ListenAddr:         apiListenAddr,
+			BeaconClient:       beaconClient,
+			Datastore:          ds,
+			Redis:              redis,
+			Memcached:          mem,
+			DB:                 db,
+			EthNetDetails:      *networkInfo,
+			BlockSimURL:        apiBlockSimURL,
+			MevCommitFiltering: apiMevCommitFiltering,
+			BlockBuilderAPI:    apiBuilderAPI,
+			DataAPI:            apiDataAPI,
+			InternalAPI:        apiInternalAPI,
+			ProposerAPI:        apiProposerAPI,
+			PprofAPI:           apiPprofEnabled,
 		}
 
 		// Decode the private key

cmd/housekeeper.go

@@ -5,10 +5,12 @@ import (
 	"os"
 	"strings"
 
+	gethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/flashbots/mev-boost-relay/beaconclient"
 	"github.com/flashbots/mev-boost-relay/common"
 	"github.com/flashbots/mev-boost-relay/database"
 	"github.com/flashbots/mev-boost-relay/datastore"
+	"github.com/flashbots/mev-boost-relay/mevcommitclient"
 	"github.com/flashbots/mev-boost-relay/services/housekeeper"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
@@ -35,6 +37,11 @@ func init() {
 
 	housekeeperCmd.Flags().BoolVar(&hkPprofEnabled, "pprof", hkDefaultPprofEnabled, "enable pprof API")
 	housekeeperCmd.Flags().StringVar(&hkPprofListenAddr, "pprof-listen-addr", hkDefaultPprofListenAddr, "listen address for pprof server")
+
+	housekeeperCmd.Flags().StringVar(&mevCommitRPC, "mev-commit-rpc", defaultMevCommitRPC, "mev-commit-chain RPC endpoint")
+	housekeeperCmd.Flags().StringVar(&ethereumL1RPC, "ethereum-l1-rpc", defaultEthereumL1RPC, "Ethereum L1 RPC endpoint")
+	housekeeperCmd.Flags().StringVar(&providerRegistryAddr, "provider-registry-addr", defaultProviderRegistryAddr, "mev-commit provider registry contract address")
+	housekeeperCmd.Flags().StringVar(&validatorOptInRouterAddr, "validator-optin-router-addr", defaultValidatorOptInRouterAddr, "mev-commit validator opt-in router contract address")
 }
 
 var housekeeperCmd = &cobra.Command{
@@ -84,6 +91,16 @@ var housekeeperCmd = &cobra.Command{
 			log.WithError(err).Fatalf("Failed to connect to Postgres database at %s%s", dbURL.Host, dbURL.Path)
 		}
 
+		mevCommitClient, err := mevcommitclient.NewMevCommitClient(
+			ethereumL1RPC,
+			mevCommitRPC,
+			gethCommon.HexToAddress(validatorOptInRouterAddr),
+			gethCommon.HexToAddress(providerRegistryAddr),
+		)
+		if err != nil {
+			log.WithError(err).Fatal("Failed to create mev-commit client")
+		}
+
 		opts := &housekeeper.HousekeeperOpts{
 			Log:          log,
 			Redis:        redis,
@@ -92,6 +109,8 @@ var housekeeperCmd = &cobra.Command{
 
 			PprofAPI:           hkPprofEnabled,
 			PprofListenAddress: hkPprofListenAddr,
+
+			MevCommitClient: mevCommitClient,
 		}
 		service := housekeeper.NewHousekeeper(opts)
 		log.Info("Starting housekeeper service...")

cmd/variables.go

@@ -7,15 +7,19 @@ import (
 )
 
 var (
-	defaultNetwork           = common.GetEnv("NETWORK", "")
-	defaultBeaconURIs        = common.GetSliceEnv("BEACON_URIS", []string{"http://localhost:3500"})
-	defaultBeaconPublishURIs = common.GetSliceEnv("BEACON_PUBLISH_URIS", []string{})
-	defaultRedisURI          = common.GetEnv("REDIS_URI", "localhost:6379")
-	defaultRedisReadonlyURI  = common.GetEnv("REDIS_READONLY_URI", "")
-	defaultPostgresDSN       = common.GetEnv("POSTGRES_DSN", "")
-	defaultMemcachedURIs     = common.GetSliceEnv("MEMCACHED_URIS", nil)
-	defaultLogJSON           = os.Getenv("LOG_JSON") != ""
-	defaultLogLevel          = common.GetEnv("LOG_LEVEL", "info")
+	defaultNetwork                  = common.GetEnv("NETWORK", "")
+	defaultBeaconURIs               = common.GetSliceEnv("BEACON_URIS", []string{"http://localhost:3500"})
+	defaultBeaconPublishURIs        = common.GetSliceEnv("BEACON_PUBLISH_URIS", []string{})
+	defaultRedisURI                 = common.GetEnv("REDIS_URI", "localhost:6379")
+	defaultRedisReadonlyURI         = common.GetEnv("REDIS_READONLY_URI", "")
+	defaultPostgresDSN              = common.GetEnv("POSTGRES_DSN", "")
+	defaultMemcachedURIs            = common.GetSliceEnv("MEMCACHED_URIS", nil)
+	defaultLogJSON                  = os.Getenv("LOG_JSON") != ""
+	defaultLogLevel                 = common.GetEnv("LOG_LEVEL", "info")
+	defaultMevCommitRPC             = common.GetEnv("MEV_COMMIT_RPC", "")
+	defaultEthereumL1RPC            = common.GetEnv("ETHEREUM_L1_RPC", "")
+	defaultProviderRegistryAddr     = common.GetEnv("PROVIDER_REGISTRY_ADDR", "")
+	defaultValidatorOptInRouterAddr = common.GetEnv("VALIDATOR_OPTIN_ROUTER_ADDR", "")
 
 	beaconNodeURIs        []string
 	beaconNodePublishURIs []string
@@ -24,6 +28,11 @@ var (
 	postgresDSN           string
 	memcachedURIs         []string
 
+	mevCommitRPC             string
+	ethereumL1RPC            string
+	providerRegistryAddr     string
+	validatorOptInRouterAddr string
+
 	logJSON  bool
 	logLevel string
 

common/types.go

@@ -188,9 +188,10 @@ func (p PubkeyHex) String() string {
 }
 
 type BuilderGetValidatorsResponseEntry struct {
-	Slot           uint64                                    `json:"slot,string"`
-	ValidatorIndex uint64                                    `json:"validator_index,string"`
-	Entry          *builderApiV1.SignedValidatorRegistration `json:"entry"`
+	Slot                 uint64                                    `json:"slot,string"`
+	ValidatorIndex       uint64                                    `json:"validator_index,string"`
+	Entry                *builderApiV1.SignedValidatorRegistration `json:"entry"`
+	IsMevCommitValidator bool                                      `json:"is_mev_commit"`
 }
 
 type BidTraceV2 struct {

datastore/datastore.go

@@ -51,6 +51,7 @@ type Datastore struct {
 }
 
 func NewDatastore(redisCache *RedisCache, memcached *Memcached, db database.IDatabaseService) (ds *Datastore, err error) {
+
 	ds = &Datastore{
 		db:                      db,
 		memcached:               memcached,
@@ -184,6 +185,11 @@ func (ds *Datastore) SetKnownValidator(pubkeyHex common.PubkeyHex, index uint64)
 	ds.knownValidatorsByIndex[index] = pubkeyHex
 }
 
+// IsMevCommitBlockBuilder checks if a builder is registered for mev-commit
+func (ds *Datastore) IsMevCommitBlockBuilder(builderPubkey common.PubkeyHex) (bool, error) {
+	return ds.redis.IsMevCommitBlockBuilder(builderPubkey)
+}
+
 // SaveValidatorRegistration saves a validator registration into both Redis and the database
 func (ds *Datastore) SaveValidatorRegistration(entry builderApiV1.SignedValidatorRegistration) error {
 	// First save in the database

datastore/redis.go

@@ -17,6 +17,7 @@ import (
 	"github.com/attestantio/go-eth2-client/spec/capella"
 	"github.com/flashbots/go-utils/cli"
 	"github.com/flashbots/mev-boost-relay/common"
+	"github.com/flashbots/mev-boost-relay/mevcommitclient"
 	"github.com/go-redis/redis/v9"
 )
 
@@ -95,6 +96,7 @@ type RedisCache struct {
 
 	// keys
 	keyValidatorRegistrationTimestamp string
+	keyMevCommitBlockBuilder          string
 
 	keyRelayConfig        string
 	keyStats              string
@@ -135,6 +137,7 @@ func NewRedisCache(prefix, redisURI, readonlyURI string) (*RedisCache, error) {
 		prefixFloorBidValue:               fmt.Sprintf("%s/%s:bid-floor-value", redisPrefix, prefix),                // prefix:slot_parentHash_proposerPubkey
 
 		keyValidatorRegistrationTimestamp: fmt.Sprintf("%s/%s:validator-registration-timestamp", redisPrefix, prefix),
+		keyMevCommitBlockBuilder:          fmt.Sprintf("%s/%s:mev-commit-block-builder", redisPrefix, prefix),
 		keyRelayConfig:                    fmt.Sprintf("%s/%s:relay-config", redisPrefix, prefix),
 
 		keyStats:              fmt.Sprintf("%s/%s:stats", redisPrefix, prefix),
@@ -241,6 +244,62 @@ func (r *RedisCache) GetValidatorRegistrationTimestamp(proposerPubkey common.Pub
 	return timestamp, err
 }
 
+func (r *RedisCache) SetMevCommitBlockBuilder(builder mevcommitclient.MevCommitProvider) error {
+	ctx := context.Background()
+
+	jsonBuilder, err := json.Marshal(builder)
+	if err != nil {
+		return fmt.Errorf("failed to marshal MevCommitProvider: %w", err)
+	}
+	err = r.client.HSet(ctx, r.keyMevCommitBlockBuilder, builder.Pubkey, string(jsonBuilder)).Err()
+	if err != nil {
+		return fmt.Errorf("failed to set mev-commit block builder: %w", err)
+	}
+
+	return nil
+}
+
+func (r *RedisCache) GetMevCommitBlockBuilders() ([]mevcommitclient.MevCommitProvider, error) {
+	ctx := context.Background()
+
+	// Retrieve all fields and values from the hash
+	entries, err := r.client.HGetAll(ctx, r.keyMevCommitBlockBuilder).Result()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get mev-commit block builders: %w", err)
+	}
+
+	// Convert map to MevCommitProvider slice
+	builders := make([]mevcommitclient.MevCommitProvider, 0, len(entries))
+	for _, value := range entries {
+		var builder mevcommitclient.MevCommitProvider
+		err := json.Unmarshal([]byte(value), &builder)
+		if err != nil {
+			return nil, fmt.Errorf("failed to unmarshal MevCommitProvider: %w", err)
+		}
+		builders = append(builders, builder)
+	}
+
+	return builders, nil
+}
+
+func (r *RedisCache) IsMevCommitBlockBuilder(builderPubkey common.PubkeyHex) (bool, error) {
+	ctx := context.Background()
+
+	// Check if the builder pubkey exists in the hash
+	exists, err := r.client.HExists(ctx, r.keyMevCommitBlockBuilder, builderPubkey.String()).Result()
+	if err != nil {
+		return false, fmt.Errorf("failed to check if builder is in mev-commit block builders hash: %w", err)
+	}
+
+	return exists, nil
+}
+
+func (r *RedisCache) DeleteMevCommitBlockBuilder(builderPubkey common.PubkeyHex) error {
+	ctx := context.Background()
+
+	return r.client.HDel(ctx, r.keyMevCommitBlockBuilder, builderPubkey.String()).Err()
+}
+
 func (r *RedisCache) SetValidatorRegistrationTimestampIfNewer(proposerPubkey common.PubkeyHex, timestamp uint64) error {
 	knownTimestamp, err := r.GetValidatorRegistrationTimestamp(proposerPubkey)
 	if err != nil {

datastore/redis_test.go

@@ -15,7 +15,9 @@ import (
 	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/bellatrix"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
+	gethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/flashbots/mev-boost-relay/common"
+	"github.com/flashbots/mev-boost-relay/mevcommitclient"
 	"github.com/go-redis/redis/v9"
 	"github.com/holiman/uint256"
 	"github.com/stretchr/testify/require"
@@ -101,6 +103,7 @@ func TestRedisProposerDuties(t *testing.T) {
 					Pubkey:       phase0.BLSPubKey{},
 				},
 			},
+			IsMevCommitValidator: true,
 		},
 	}
 	err := cache.SetProposerDuties(duties)
@@ -111,6 +114,9 @@ func TestRedisProposerDuties(t *testing.T) {
 
 	require.Len(t, duties2, 1)
 	require.Equal(t, duties[0].Entry.Message.FeeRecipient, duties2[0].Entry.Message.FeeRecipient)
+	require.Equal(t, duties[0].IsMevCommitValidator, duties2[0].IsMevCommitValidator)
+	require.Equal(t, duties[0].IsMevCommitValidator, true)
+
 }
 
 func TestBuilderBids(t *testing.T) {
@@ -444,6 +450,52 @@ func TestPipelineNilCheck(t *testing.T) {
 	require.Equal(t, big.NewInt(0), f)
 }
 
+func TestSetMevCommitBlockBuilders(t *testing.T) {
+	cache := setupTestRedis(t)
+
+	builderPubkey := "0xfa1ed37c3553d0ce1e9349b2c5063cf6e394d231c8d3e0df75e9462257c081543086109ffddaacc0aa76f33dc9661c83"
+	// Set a commit block builder
+	builder := mevcommitclient.MevCommitProvider{
+		Pubkey:     []byte(builderPubkey),
+		EOAAddress: gethCommon.HexToAddress("0x0000000000000000000000000000000000000001"),
+	}
+	err := cache.SetMevCommitBlockBuilder(builder)
+	require.NoError(t, err)
+
+	// Retrieve the list of mev-commit block builders
+	builders, err := cache.GetMevCommitBlockBuilders()
+	require.NoError(t, err)
+	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))
+	require.NoError(t, err)
+	require.True(t, isSet)
+
+	// Check if a non-existent commit block builder returns false
+	nonExistentBuilderPubkey := "0x2e02be2c9f9eccf9856478fdb7876598fed2da09f45c233969ba647a250231150ecf38bce5771adb6171c86b79a92f16"
+	isSet, err = cache.IsMevCommitBlockBuilder(common.PubkeyHex(nonExistentBuilderPubkey))
+	require.NoError(t, err)
+	require.False(t, isSet)
+
+	// Test removing a registered block builder
+	err = cache.DeleteMevCommitBlockBuilder(common.PubkeyHex(builderPubkey))
+	require.NoError(t, err)
+
+	// Check if the removed builder is no longer registered
+	isSet, err = cache.IsMevCommitBlockBuilder(common.PubkeyHex(builderPubkey))
+	require.NoError(t, err)
+	require.False(t, isSet)
+
+	// Verify the list of mev-commit block builders is now empty
+	builders, err = cache.GetMevCommitBlockBuilders()
+	require.NoError(t, err)
+	require.Empty(t, builders)
+}
+
 // func TestPipeline(t *testing.T) {
 // 	cache := setupTestRedis(t)