adding builder boost factor to proposer settings

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_bellatrix.go

@@ -92,15 +92,16 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 		// Use builder payload if the following in true:
 		// builder_bid_value * builderBoostFactor(default 100) > local_block_value * (local-block-value-boost + 100)
 		boost := params.BeaconConfig().LocalBlockValueBoost
-		higherValueBuilder := builderValueGwei*builderBoostFactor > localValueGwei*(100+boost)
-		if boost > 0 && builderBoostFactor != defaultBuilderBoostFactor {
+		if boost > 0 && builderBoostFactor > defaultBuilderBoostFactor {
 			log.WithFields(logrus.Fields{
 				"localGweiValue":       localValueGwei,
 				"localBoostPercentage": boost,
 				"builderGweiValue":     builderValueGwei,
 				"builderBoostFactor":   builderBoostFactor,
-			}).Warn("Proposer: both local boost and builder boost are using non default values")
+			}).Warn("Proposer: builder boost will be ignored, because local boost is activated and builder boost is above the default")
+			builderBoostFactor = defaultBuilderBoostFactor
 		}
+		higherValueBuilder := builderValueGwei*builderBoostFactor > localValueGwei*(100+boost)
 		builderValueGweiGauge.Set(float64(builderValueGwei))
 		localValueGweiGauge.Set(float64(localValueGwei))
 

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_bellatrix_test.go

@@ -290,7 +290,7 @@ func TestServer_setExecutionData(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, uint64(2), e.BlockNumber()) // builder block
 	})
-	t.Run("Builder builder has higher value but forced to local payload with builder boost factor", func(t *testing.T) {
+	t.Run("Builder has higher value but forced to local payload with builder boost factor at 0", func(t *testing.T) {
 		blk, err := blocks.NewSignedBeaconBlock(util.NewBlindedBeaconBlockCapella())
 		require.NoError(t, err)
 		require.NoError(t, vs.BeaconDB.SaveRegistrationsByValidatorIDs(ctx, []primitives.ValidatorIndex{blk.Block().ProposerIndex()},
@@ -370,6 +370,23 @@ func TestServer_setExecutionData(t *testing.T) {
 
 		require.LogsContain(t, hook, "builderGweiValue=1 localBoostPercentage=0 localGweiValue=2")
 	})
+	t.Run("Builder configured. Local block has higher value even with higher builder boost factor", func(t *testing.T) {
+		blk, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlockCapella())
+		require.NoError(t, err)
+		vs.ExecutionEngineCaller = &powtesting.EngineClient{PayloadIDBytes: id, ExecutionPayloadCapella: &v1.ExecutionPayloadCapella{BlockNumber: 3}, BlockValue: 2 * 1e9}
+		b := blk.Block()
+		localPayload, _, err := vs.getLocalPayload(ctx, b, capellaTransitionState)
+		require.NoError(t, err)
+		builderPayload, builderKzgCommitments, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex())
+		require.NoError(t, err)
+		require.DeepEqual(t, [][]uint8(nil), builderKzgCommitments)
+		require.NoError(t, setExecutionData(context.Background(), blk, localPayload, builderPayload, builderKzgCommitments, 99999))
+		e, err := blk.Block().Body().Execution()
+		require.NoError(t, err)
+		require.Equal(t, uint64(3), e.BlockNumber()) // Local block
+
+		require.LogsContain(t, hook, "builderGweiValue=1 localBoostPercentage=0 localGweiValue=2")
+	})
 	t.Run("Builder configured. Local block and local boost has higher value", func(t *testing.T) {
 		cfg := params.BeaconConfig().Copy()
 		cfg.LocalBlockValueBoost = 1 // Boost 1%.

cmd/beacon-chain/flags/base.go

@@ -27,8 +27,8 @@ var (
 	// LocalBlockValueBoost sets a percentage boost for local block construction while using a custom builder.
 	LocalBlockValueBoost = &cli.Uint64Flag{
 		Name: "local-block-value-boost",
-		Usage: "A percentage boost for local block construction as a Uint64. This is used to prioritize local block construction over relay/builder block construction" +
-			"Boost is an additional percentage to multiple local block value. Use builder block if: builder_bid_value * 100 > local_block_value * (local-block-value-boost + 100)",
+		Usage: "A percentage boost for local block construction as a Uint64. This is used to prioritize local block construction over relay/builder block construction. " +
+			"Boost is an additional percentage to multiple local block value. Use builder block if: builder_value * builder-boost-factor > local_value * (local-block-value-boost + 100)",
 		Value: 10,
 	}
 	// ExecutionEngineEndpoint provides an HTTP access endpoint to connect to an execution client on the execution layer

cmd/validator/flags/flags.go

@@ -366,6 +366,14 @@ var (
 		Value: fmt.Sprint(params.BeaconConfig().DefaultBuilderGasLimit),
 	}
 
+	// BuilderBoostFactorFlag sets a multiplier for builder block construction as a Uint64.
+	BuilderBoostFactorFlag = &cli.Uint64Flag{
+		Name: "builder-boost-factor",
+		Usage: "A multiplier for builder block construction as a Uint64. This is used to prioritize relay/builder block construction over local block construction. " +
+			"Boost factor is a multiplier against the builder value. Use builder block if: builder_value * builder-boost-factor > local_value * (local-block-value-boost + 100)",
+		Value: 100,
+	}
+
 	// ValidatorsRegistrationBatchSizeFlag sets the maximum size for one batch of validator registrations. Use a non-positive value to disable batching.
 	ValidatorsRegistrationBatchSizeFlag = &cli.IntFlag{
 		Name:  "validators-registration-batch-size",

cmd/validator/main.go

@@ -83,6 +83,7 @@ var appFlags = []cli.Flag{
 	flags.ProposerSettingsFlag,
 	flags.EnableBuilderFlag,
 	flags.BuilderGasLimitFlag,
+	flags.BuilderBoostFactorFlag,
 	flags.ValidatorsRegistrationBatchSizeFlag,
 	////////////////////
 	cmd.DisableMonitoringFlag,

cmd/validator/usage.go

@@ -121,6 +121,7 @@ var appHelpFlagGroups = []flagGroup{
 			flags.SuggestedFeeRecipientFlag,
 			flags.EnableBuilderFlag,
 			flags.BuilderGasLimitFlag,
+			flags.BuilderBoostFactorFlag,
 			flags.ValidatorsRegistrationBatchSizeFlag,
 			flags.EnableDistributed,
 		},

config/proposer/loader/loader.go

@@ -35,8 +35,9 @@ type settingsLoader struct {
 }
 
 type flagOptions struct {
-	builderConfig *proposer.BuilderConfig
-	gasLimit      *validator.Uint64
+	builderConfig      *proposer.BuilderConfig
+	gasLimit           *validator.Uint64
+	builderBoostFactor *uint64
 }
 
 // SettingsLoaderOption sets additional options that affect the proposer settings
@@ -74,6 +75,17 @@ func WithGasLimit() SettingsLoaderOption {
 	}
 }
 
+// WithBuilderBoostFactor applies the --builder-boost-factor flag to proposer settings
+func WithBuilderBoostFactor() SettingsLoaderOption {
+	return func(cliCtx *cli.Context, psl *settingsLoader) error {
+		if cliCtx.IsSet(flags.BuilderBoostFactorFlag.Name) {
+			bbf := cliCtx.Uint64(flags.BuilderBoostFactorFlag.Name)
+			psl.options.builderBoostFactor = &bbf
+		}
+		return nil
+	}
+}
+
 // NewProposerSettingsLoader returns a new proposer settings loader that can process the proposer settings based on flag options
 func NewProposerSettingsLoader(cliCtx *cli.Context, db iface.ValidatorDB, opts ...SettingsLoaderOption) (*settingsLoader, error) {
 	if cliCtx.IsSet(flags.ProposerSettingsFlag.Name) && cliCtx.IsSet(flags.ProposerSettingsURLFlag.Name) {
@@ -117,8 +129,11 @@ func (psl *settingsLoader) Load(cliCtx *cli.Context) (*proposer.Settings, error)
 	loadConfig := &validatorpb.ProposerSettingsPayload{}
 
 	// override settings based on other options
-	if psl.options.builderConfig != nil && psl.options.gasLimit != nil {
-		psl.options.builderConfig.GasLimit = *psl.options.gasLimit
+	if psl.options != nil && psl.options.builderConfig != nil {
+		if psl.options.gasLimit != nil {
+			psl.options.builderConfig.GasLimit = *psl.options.gasLimit
+		}
+		psl.options.builderConfig.BuilderBoostFactor = psl.options.builderBoostFactor
 	}
 
 	// check if database has settings already
@@ -205,20 +220,8 @@ func (psl *settingsLoader) processProposerSettings(loadedSettings, dbSettings *v
 	// loaded settings have higher priority than db settings
 	newSettings := &validatorpb.ProposerSettingsPayload{}
 
-	var builderConfig *validatorpb.BuilderConfig
-	var gasLimitOnly *validator.Uint64
-
-	if psl.options != nil {
-		if psl.options.builderConfig != nil {
-			builderConfig = psl.options.builderConfig.ToConsensus()
-		}
-		if psl.options.gasLimit != nil {
-			gasLimitOnly = psl.options.gasLimit
-		}
-	}
-
 	if dbSettings != nil && dbSettings.DefaultConfig != nil {
-		if builderConfig == nil {
+		if psl.options == nil || psl.options.builderConfig == nil {
 			dbSettings.DefaultConfig.Builder = nil
 		}
 		newSettings.DefaultConfig = dbSettings.DefaultConfig
@@ -229,12 +232,12 @@ func (psl *settingsLoader) processProposerSettings(loadedSettings, dbSettings *v
 
 	// process any builder overrides on defaults
 	if newSettings.DefaultConfig != nil {
-		newSettings.DefaultConfig.Builder = processBuilderConfig(newSettings.DefaultConfig.Builder, builderConfig, gasLimitOnly)
+		newSettings.DefaultConfig.Builder = processBuilderConfig(newSettings.DefaultConfig.Builder, psl.options)
 	}
 
 	if dbSettings != nil && len(dbSettings.ProposerConfig) != 0 {
 		for _, option := range dbSettings.ProposerConfig {
-			if builderConfig == nil {
+			if psl.options == nil || psl.options.builderConfig == nil {
 				option.Builder = nil
 			}
 		}
@@ -247,7 +250,7 @@ func (psl *settingsLoader) processProposerSettings(loadedSettings, dbSettings *v
 	// process any overrides for proposer config
 	for _, option := range newSettings.ProposerConfig {
 		if option != nil {
-			option.Builder = processBuilderConfig(option.Builder, builderConfig, gasLimitOnly)
+			option.Builder = processBuilderConfig(option.Builder, psl.options)
 		}
 	}
 
@@ -259,18 +262,38 @@ func (psl *settingsLoader) processProposerSettings(loadedSettings, dbSettings *v
 	return newSettings
 }
 
-func processBuilderConfig(current *validatorpb.BuilderConfig, override *validatorpb.BuilderConfig, gasLimitOnly *validator.Uint64) *validatorpb.BuilderConfig {
-	if current != nil {
-		current.GasLimit = reviewGasLimit(current.GasLimit)
-		if override != nil {
-			current.Enabled = override.Enabled
-		}
-		if gasLimitOnly != nil {
-			current.GasLimit = *gasLimitOnly
-		}
+func processBuilderConfig(current *validatorpb.BuilderConfig, options *flagOptions) *validatorpb.BuilderConfig {
+	// If there are no options, return what was passed in
+	if options == nil {
 		return current
 	}
-	return override
+
+	// Initialize an override variable
+	var override *validatorpb.BuilderConfig
+	if options.builderConfig != nil {
+		// Convert the builder config to consensus form if it exists
+		override = options.builderConfig.ToConsensus()
+	}
+	// If there's nothing to process further, return the override or current based on what's available
+	if current == nil {
+		return override
+	}
+
+	if override != nil {
+		current.Enabled = override.Enabled
+	}
+
+	if options.gasLimit != nil {
+		current.GasLimit = *options.gasLimit
+	}
+
+	current.GasLimit = reviewGasLimit(current.GasLimit)
+
+	if options.builderBoostFactor != nil {
+		current.BuilderBoostFactor = options.builderBoostFactor
+	}
+
+	return current
 }
 
 func reviewGasLimit(gasLimit validator.Uint64) validator.Uint64 {