Validator client builder support

cmd/validator/flags/flags.go

@@ -343,6 +343,13 @@ var (
 		Usage: "Sets ALL validators' mapping to a suggested an eth address to receive gas fees when proposing a block. Overrides the --fee-recipient-config-file flag if set",
 		Value: field_params.EthBurnAddressHex,
 	}
+
+	// SuggestedBuilderFeeRecipientFlag defines the address of the fee recipient for custom builders.
+	SuggestedBuilderFeeRecipientFlag = &cli.StringFlag{
+		Name:  "suggested-builder-fee-recipient",
+		Usage: "Sets ALL validators' mapping to a suggested an eth address to receive gas fees when proposing a block for custom builders.",
+		Value: field_params.EthBurnAddressHex,
+	}
 )
 
 // DefaultValidatorDir returns OS-specific default validator directory.

config/fieldparams/mainnet.go

@@ -24,4 +24,5 @@ const (
 	LogsBloomLength                 = 256                                          // LogsBloomLength defines the byte length of a logs bloom.
 	VersionLength                   = 4                                            // VersionLength defines the byte length of a fork version number.
 	EthBurnAddressHex               = "0x0000000000000000000000000000000000000000" // EthBurnAddressHex defines the hex encoded address of the eth1.0 burn contract.
+	DefaultBuilderGasLimit          = uint64(30000000)                             // BuilderGasLimit is the default gas limit sent to the Builder API if not provided by the user.
 )

config/fieldparams/minimal.go

@@ -24,4 +24,5 @@ const (
 	LogsBloomLength                 = 256                                          // LogsBloomLength defines the byte length of a logs bloom.
 	VersionLength                   = 4                                            // VersionLength defines the byte length of a fork version number.
 	EthBurnAddressHex               = "0x0000000000000000000000000000000000000000" // EthBurnAddressHex defines the hex encoded address of the eth1.0 burn contract.
+	DefaultBuilderGasLimit          = uint64(30000000)                             // BuilderGasLimit is the default gas limit sent to the Builder API if not provided by the user.
 )

config/validator/service/fee-recipient-config.go

@@ -9,14 +9,15 @@ import (
 // ProposeConfig is the map of validator address to fee recipient options all in hex format.
 // DefaultConfig is the default fee recipient address for all validators unless otherwise specified in the propose config.required.
 type FeeRecipientFileConfig struct {
-	ProposeConfig map[string]*FeeRecipientFileOptions `json:"proposer_config"`
-	DefaultConfig *FeeRecipientFileOptions            `json:"default_config"`
+	ProposeConfig map[string]*FeeRecipientFileOptions `json:"proposer_config" yaml:"proposer_config"`
+	DefaultConfig *FeeRecipientFileOptions            `json:"default_config" yaml:"default_config"`
 }
 
 // FeeRecipientFileOptions is the struct representation of the JSON config file set in the validator through the CLI.
 // FeeRecipient is set to an eth address in hex string format with 0x prefix.
 type FeeRecipientFileOptions struct {
-	FeeRecipient string `json:"fee_recipient"`
+	FeeRecipient string `json:"fee_recipient" yaml:"fee_recipient"`
+	GasLimit     uint64 `json:"builder_fee_recipient_override" yaml:"builder_fee_recipient_override"`
 }
 
 // FeeRecipientConfig is a Prysm internal representation of the fee recipient config on the validator client.

proto/eth/service/validator_service.proto

@@ -20,7 +20,7 @@ import "google/protobuf/descriptor.proto";
 import "google/protobuf/empty.proto";
 
 import "proto/eth/v1/validator.proto";
-import "proto/eth/v2/ssz.proto";
+//import "proto/eth/v2/ssz.proto";
 import "proto/eth/v2/validator.proto";
 
 option csharp_namespace = "Ethereum.Eth.Service";

validator/client/BUILD.bazel

@@ -6,6 +6,7 @@ go_library(
         "aggregate.go",
         "attest.go",
         "attest_protect.go",
+        "builder_registration.go",
         "key_reload.go",
         "log.go",
         "metrics.go",

validator/client/validator.go

@@ -960,7 +960,7 @@ func (v *validator) UpdateFeeRecipient(ctx context.Context, km keymanager.IKeyma
 	if err != nil {
 		return err
 	}
-	feeRecipients, err := v.feeRecipients(ctx, pubkeys)
+	feeRecipients, registerValidatorRequests, err := v.buildValidatorRequests(ctx, pubkeys)
 	if err != nil {
 		return err
 	}
@@ -974,24 +974,32 @@ func (v *validator) UpdateFeeRecipient(ctx context.Context, km keymanager.IKeyma
 		return err
 	}
 	log.Infoln("Successfully prepared beacon proposer with fee recipient to validator index mapping.")
+	for _, request := range registerValidatorRequests {
+		// calls beacon API but used for custom builders
+		if err := SubmitBuilderValidatorRegistration(ctx, v.validatorClient, v.node, km.Sign, request); err != nil {
+			return errors.Wrap(err, fmt.Sprintf("failed to register validator for custom builder for %s", hexutil.Encode(request.Pubkey)))
+		}
+	}
 	return nil
 }
 
-func (v *validator) feeRecipients(ctx context.Context, pubkeys [][fieldparams.BLSPubkeyLength]byte) ([]*ethpb.PrepareBeaconProposerRequest_FeeRecipientContainer, error) {
-	var validatorToFeeRecipientArray []*ethpb.PrepareBeaconProposerRequest_FeeRecipientContainer
+func (v *validator) buildValidatorRequests(ctx context.Context, pubkeys [][fieldparams.BLSPubkeyLength]byte) ([]*ethpb.PrepareBeaconProposerRequest_FeeRecipientContainer, []*ethpb.ValidatorRegistrationV1, error) {
+	var validatorToFeeRecipients []*ethpb.PrepareBeaconProposerRequest_FeeRecipientContainer
+	var registerValidatorRequests []*ethpb.ValidatorRegistrationV1
 	// need to check for pubkey to validator index mappings
 	for _, key := range pubkeys {
+		skipAppendToFeeRecipientArray := false
 		feeRecipient := common.HexToAddress(fieldparams.EthBurnAddressHex)
+		gasLimit := fieldparams.DefaultBuilderGasLimit
 		validatorIndex, found := v.pubkeyToValidatorIndex[key]
 		// ignore updating fee recipient if validator index is not found
 		if !found {
 			ind, foundIndex, err := v.cacheValidatorPubkeyHexToValidatorIndex(ctx, key)
 			if err != nil {
-				return nil, err
+				return nil, nil, err
 			}
 			if !foundIndex {
-				//if still not found, skip this validator
-				continue
+				skipAppendToFeeRecipientArray = true
 			}
 			validatorIndex = ind
 			v.pubkeyToValidatorIndex[key] = validatorIndex
@@ -1009,12 +1017,22 @@ func (v *validator) feeRecipients(ctx context.Context, pubkeys [][fieldparams.BL
 		if hexutil.Encode(feeRecipient.Bytes()) == fieldparams.EthBurnAddressHex {
 			log.Warnln("Fee recipient is set to the burn address. You will not be rewarded transaction fees on this setting. Please set a different fee recipient.")
 		}
-		validatorToFeeRecipientArray = append(validatorToFeeRecipientArray, &ethpb.PrepareBeaconProposerRequest_FeeRecipientContainer{
-			ValidatorIndex: validatorIndex,
-			FeeRecipient:   feeRecipient[:],
+		if !skipAppendToFeeRecipientArray {
+			validatorToFeeRecipients = append(validatorToFeeRecipients, &ethpb.PrepareBeaconProposerRequest_FeeRecipientContainer{
+				ValidatorIndex: validatorIndex,
+				FeeRecipient:   feeRecipient[:],
+			})
+		}
+		//TODO: look at caching these values
+		registerValidatorRequests = append(registerValidatorRequests, &ethpb.ValidatorRegistrationV1{
+			FeeRecipient: feeRecipient[:],
+			GasLimit:     gasLimit,
+			Timestamp:    uint64(time.Now().UTC().Unix()),
+			Pubkey:       key[:],
 		})
+
 	}
-	return validatorToFeeRecipientArray, nil
+	return validatorToFeeRecipients, registerValidatorRequests, nil
 }
 
 func (v *validator) cacheValidatorPubkeyHexToValidatorIndex(ctx context.Context, pubkey [fieldparams.BLSPubkeyLength]byte) (types.ValidatorIndex, bool, error) {

validator/client/validator_test.go

@@ -1718,7 +1718,7 @@ func TestValidator_UdpateFeeRecipient(t *testing.T) {
 			pubkeys, err := km.FetchValidatingPublicKeys(ctx)
 			require.NoError(t, err)
 			if tt.feeRecipientMap != nil {
-				feeRecipients, err := v.feeRecipients(ctx, pubkeys)
+				feeRecipients, err := v.buildValidatorRequests(ctx, pubkeys)
 				require.NoError(t, err)
 				for _, recipient := range feeRecipients {
 					require.Equal(t, strings.ToLower(tt.feeRecipientMap[recipient.ValidatorIndex]), strings.ToLower(hexutil.Encode(recipient.FeeRecipient)))

validator/node/BUILD.bazel

@@ -72,6 +72,7 @@ go_library(
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",
+        "@in_gopkg_yaml_v2//:go_default_library",
         "@org_golang_google_protobuf//encoding/protojson:go_default_library",
     ],
 )

validator/node/node.go

@@ -54,6 +54,7 @@ import (
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 	"google.golang.org/protobuf/encoding/protojson"
+	"gopkg.in/yaml.v2"
 )
 
 // ValidatorClient defines an instance of an Ethereum validator that manages
@@ -785,26 +786,18 @@ func unmarshalFromFile(ctx context.Context, from string, to interface{}) error {
 	}
 	cleanpath := filepath.Clean(from)
 	fileExtension := filepath.Ext(cleanpath)
-	if fileExtension != ".json" {
-		return errors.Errorf("unsupported file extension %s , (ex. '.json')", fileExtension)
+	if fileExtension != ".json" && fileExtension != ".yaml" {
+		return errors.Errorf("unsupported file extension %s , (ex. '.json','.yaml')", fileExtension)
 	}
-	jsonFile, jsonerr := os.Open(cleanpath)
-	if jsonerr != nil {
-		return errors.Wrap(jsonerr, "failed to open json file")
-	}
-	// defer the closing of our jsonFile so that we can parse it later on
-	defer func(jsonFile *os.File) {
-		err := jsonFile.Close()
-		if err != nil {
-			log.WithError(err).Error("failed to close json file")
-		}
-	}(jsonFile)
-	byteValue, readerror := io.ReadAll(jsonFile)
-	if readerror != nil {
-		return errors.Wrap(readerror, "failed to read json file")
+
+	b, err := os.ReadFile(cleanpath)
+	if err != nil {
+		return errors.Wrap(err, "failed to open file")
 	}
-	if unmarshalerr := json.Unmarshal(byteValue, &to); unmarshalerr != nil {
-		return errors.Wrap(unmarshalerr, "failed to unmarshal json file")
+
+	if err := yaml.Unmarshal(b, to); err != nil {
+		return errors.Wrap(err, "failed to unmarshal yaml file")
 	}
+
 	return nil
 }

validator/node/node_test.go

@@ -4,12 +4,15 @@ import (
 	"context"
 	"flag"
 	"fmt"
+	"io/fs"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"testing"
 
+	"github.com/pkg/errors"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/prysmaticlabs/prysm/cmd/validator/flags"
@@ -191,70 +194,85 @@ func newWeb3SignerCli(t *testing.T, baseUrl string, publicKeysOrURL string) *cli
 }
 
 type test struct {
-	Foo string `json:"foo"`
-	Bar int    `json:"bar"`
+	Foo string `json:"foo" yaml:"foo"`
+	Bar int    `json:"bar" yaml:"bar"`
 }
 
 func TestUnmarshalFromFile(t *testing.T) {
 	ctx := context.Background()
 	type args struct {
 		File string
-		To   interface{}
+		To   *test
 	}
+	var pathError *fs.PathError
 	tests := []struct {
 		name        string
 		args        args
-		want        interface{}
+		want        *test
 		urlResponse string
-		wantErr     bool
+		err         error
 	}{
 		{
 			name: "Happy Path File",
 			args: args{
-				File: "./testdata/test-unmarshal-good.json",
+				File: "testdata/test-unmarshal-good.json",
+				To:   &test{},
+			},
+			want: &test{
+				Foo: "foo",
+				Bar: 1,
+			},
+		},
+		{
+			name: "Happy Path File Yaml",
+			args: args{
+				File: "testdata/test-unmarshal-good.yaml",
 				To:   &test{},
 			},
 			want: &test{
 				Foo: "foo",
 				Bar: 1,
 			},
-			wantErr: false,
 		},
 		{
 			name: "Bad File Path, not json",
 			args: args{
-				File: "./jsontools.go",
+				File: "jsontools.go",
 				To:   &test{},
 			},
-			want:    &test{},
-			wantErr: true,
+			want: &test{},
+			err:  pathError,
 		},
 		{
 			name: "Bad File Path",
 			args: args{
-				File: "./testdata/test-unmarshal-bad.json",
+				File: "testdata/test-unmarshal-bad.json",
 				To:   &test{},
 			},
-			want:    &test{},
-			wantErr: true,
+			want: &test{},
+			err:  pathError,
 		},
 		{
 			name: "Bad File Path, not found",
 			args: args{
-				File: "./test-notfound.json",
+				File: "test-notfound.json",
 				To:   &test{},
 			},
-			want:    &test{},
-			wantErr: true,
+			want: &test{},
+			err:  pathError,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if err := unmarshalFromFile(ctx, tt.args.File, tt.args.To); (err != nil) != tt.wantErr {
-				t.Errorf(" error = %v, wantErr %v", err, tt.wantErr)
+			to := tt.args.To
+			err := unmarshalFromFile(ctx, tt.args.File, to)
+			if tt.err != nil {
+				require.Equal(t, true, errors.As(err, &tt.err))
 				return
+			} else {
+				require.NoError(t, err)
 			}
-			require.DeepEqual(t, tt.want, tt.args.To)
+			require.DeepEqual(t, tt.want, to)
 		})
 	}
 }

validator/node/testdata/good-prepare-beacon-proposer-config.yaml

@@ -0,0 +1,6 @@
+---
+proposer_config:
+  '0xa057816155ad77931185101128655c0191bd0214c201ca48ed887f6c4c6adf334070efcd75140eada5ac83a92506dd7a':
+    fee_recipient: '0x50155530FCE8a85ec7055A5F8b2bE214B3DaeFd3'
+default_config:
+  fee_recipient: '0x6e35733c5af9B61374A128e6F85f553aF09ff89A'

validator/node/testdata/test-unmarshal-good.yaml

@@ -0,0 +1,3 @@
+---
+foo: foo
+bar: 1