@lodestar/validator 1.47.0-dev.d2f4b96574 → 1.47.0-dev.d79d81f994

package/src/services/validatorStore.ts

@@ -1,6 +1,7 @@
-import {SecretKey} from "@chainsafe/blst";
+import {SecretKey} from "@chainsafe/lodestar-z/blst";
 import {BitArray} from "@chainsafe/ssz";
 import {routes} from "@lodestar/api";
+import {BuilderConfigData, BuilderEntryConfig} from "@lodestar/api/keymanager";
 import {BeaconConfig} from "@lodestar/config";
 import {
   DOMAIN_AGGREGATE_AND_PROOF,
@@ -8,6 +9,7 @@ import {
   DOMAIN_BEACON_ATTESTER,
   DOMAIN_BEACON_BUILDER,
   DOMAIN_BEACON_PROPOSER,
+  DOMAIN_BUILDER_REQUEST_AUTH,
   DOMAIN_CONTRIBUTION_AND_PROOF,
   DOMAIN_PROPOSER_PREFERENCES,
   DOMAIN_PTC_ATTESTER,
@@ -16,6 +18,7 @@ import {
   DOMAIN_SYNC_COMMITTEE,
   DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF,
   ForkSeq,
+  MAX_BUILDER_AUTH_DATA_SIZE,
 } from "@lodestar/params";
 import {
   ZERO_HASH,
@@ -46,7 +49,7 @@ import {
   phase0,
   ssz,
 } from "@lodestar/types";
-import {fromHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
+import {fromHex, isValidAsciiHttpUrl, toHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../metrics.js";
 import {ISlashingProtection} from "../slashingProtection/index.js";
 import {PubkeyHex} from "../types.js";
@@ -80,10 +83,13 @@ type DefaultProposerConfig = {
   strictFeeRecipientCheck: boolean;
   feeRecipient: ExecutionAddress;
   builder: {
-    gasLimit: number;
     // Left undefined when not configured so the fork-appropriate default can be resolved per slot
+    gasLimit?: number;
     selection?: routes.validator.BuilderSelection;
     boostFactor: bigint;
+    minBid: bigint;
+    maxExecutionPayment: bigint;
+    builders?: BuilderEntryConfig[];
   };
 };
 
@@ -95,9 +101,23 @@ export type ProposerConfig = {
     gasLimit?: number;
     selection?: routes.validator.BuilderSelection;
     boostFactor?: bigint;
+    minBid?: bigint;
+    maxExecutionPayment?: bigint;
+    /** Per-key builder entries, replacing the validator client's builders */
+    builders?: BuilderEntryConfig[];
   };
 };
 
+/** A builder entry with every omitted value resolved against the key and validator client defaults */
+export type ResolvedBuilderEntry = {
+  url: string;
+  authData: Uint8Array;
+  builderPubkeys: Uint8Array[];
+  maxExecutionPayment: bigint;
+  minBid: bigint;
+  builderBoostFactor: bigint;
+};
+
 export type ValidatorProposerConfig = {
   proposerConfig: {[index: PubkeyHex]: ProposerConfig};
   defaultConfig: ProposerConfig;
@@ -132,6 +152,8 @@ export type Signer = SignerLocal | SignerRemote;
 type ValidatorData = ProposerConfig & {
   signer: Signer;
   builderData?: BuilderData;
+  /** Pre-signed builder request auths keyed by proposal slot and auth data, pruned by proposal slot */
+  builderRequestAuths?: Map<string, gloas.SignedBuilderRequestAuth>;
 };
 
 export const defaultOptions = {
@@ -139,7 +161,10 @@ export const defaultOptions = {
   defaultGasLimit: 60_000_000,
   builderSelection: routes.validator.BuilderSelection.ExecutionOnly,
   builderAliasSelection: routes.validator.BuilderSelection.Default,
-  builderBoostFactor: BigInt(100),
+  builderBoostFactor: 100n,
+  builderMinBid: 0n,
+  // Only trustless payments via the builder's staked collateral are counted by default
+  builderMaxExecutionPayment: 0n,
   // spec asks for gossip validation by default
   broadcastValidation: routes.beacon.BroadcastValidation.gossip,
   // should request fetching the locally produced block in blinded format
@@ -148,6 +173,32 @@ export const defaultOptions = {
 
 export const MAX_BUILDER_BOOST_FACTOR = 2n ** 64n - 1n;
 
+/** Pre-Gloas there is no in-protocol builder so the default is local-only, post-Gloas bids are used */
+export function getDefaultBuilderSelection(isPostGloas: boolean): routes.validator.BuilderSelection {
+  return isPostGloas ? defaultOptions.builderAliasSelection : defaultOptions.builderSelection;
+}
+
+/** Boost factor implied by a builder selection, `configuredBoostFactor` only applies to `maxprofit` */
+export function getBuilderBoostFactor(
+  selection: routes.validator.BuilderSelection,
+  configuredBoostFactor: bigint
+): bigint {
+  switch (selection) {
+    case routes.validator.BuilderSelection.Default:
+      // Default value slightly favors local block to improve censorship resistance of Ethereum
+      // The people have spoken and so it shall be https://x.com/lodestar_eth/status/1772679499928191044
+      return BigInt(90);
+    case routes.validator.BuilderSelection.MaxProfit:
+      return configuredBoostFactor;
+    case routes.validator.BuilderSelection.BuilderAlways:
+    case routes.validator.BuilderSelection.BuilderOnly:
+      return MAX_BUILDER_BOOST_FACTOR;
+    case routes.validator.BuilderSelection.ExecutionAlways:
+    case routes.validator.BuilderSelection.ExecutionOnly:
+      return BigInt(0);
+  }
+}
+
 /**
  * Service that sets up and handles validator attester duties.
  */
@@ -182,9 +233,12 @@ export class ValidatorStore {
       strictFeeRecipientCheck: defaultConfig.strictFeeRecipientCheck ?? false,
       feeRecipient: defaultConfig.feeRecipient ?? defaultOptions.suggestedFeeRecipient,
       builder: {
-        gasLimit: defaultConfig.builder?.gasLimit ?? defaultOptions.defaultGasLimit,
+        gasLimit: defaultConfig.builder?.gasLimit,
         selection: defaultConfig.builder?.selection,
         boostFactor: builderBoostFactor,
+        minBid: defaultConfig.builder?.minBid ?? defaultOptions.builderMinBid,
+        maxExecutionPayment: defaultConfig.builder?.maxExecutionPayment ?? defaultOptions.builderMaxExecutionPayment,
+        builders: defaultConfig.builder?.builders,
       },
     };
 
@@ -281,43 +335,45 @@ export class ValidatorStore {
 
   getBuilderSelectionParams(
     pubkeyHex: PubkeyHex,
-    slot?: Slot
+    slot: Slot
   ): {selection: routes.validator.BuilderSelection; boostFactor: bigint} {
-    // Builder bids post-gloas are in-protocol over p2p, so the default strategy uses them
-    // (as if `--builder` was set), unless the validator explicitly opted out. Pre-gloas
-    // there is no in-protocol builder, so the default remains local-only (executiononly).
-    const defaultSelection =
-      slot !== undefined && this.config.getForkSeq(slot) >= ForkSeq.gloas
-        ? defaultOptions.builderAliasSelection
-        : defaultOptions.builderSelection;
-    const selection =
-      this.validators.get(pubkeyHex)?.builder?.selection ??
-      this.defaultProposerConfig.builder.selection ??
-      defaultSelection;
-
-    let boostFactor: bigint;
-    switch (selection) {
-      case routes.validator.BuilderSelection.Default:
-        // Default value slightly favors local block to improve censorship resistance of Ethereum
-        // The people have spoken and so it shall be https://x.com/lodestar_eth/status/1772679499928191044
-        boostFactor = BigInt(90);
-        break;
-
-      case routes.validator.BuilderSelection.MaxProfit:
-        boostFactor =
-          this.validators.get(pubkeyHex)?.builder?.boostFactor ?? this.defaultProposerConfig.builder.boostFactor;
-        break;
-
-      case routes.validator.BuilderSelection.BuilderAlways:
-      case routes.validator.BuilderSelection.BuilderOnly:
-        boostFactor = MAX_BUILDER_BOOST_FACTOR;
-        break;
-
-      case routes.validator.BuilderSelection.ExecutionAlways:
-      case routes.validator.BuilderSelection.ExecutionOnly:
-        boostFactor = BigInt(0);
+    // Builder bids post-gloas are in-protocol, so the default strategy uses them regardless of
+    // whether they are received over p2p or through a builder API. Pre-gloas there is no
+    // in-protocol builder, so the default remains local-only (executiononly).
+    const isPostGloas = this.config.getForkSeq(slot) >= ForkSeq.gloas;
+    return this.resolveBuilderSelectionParams(pubkeyHex, isPostGloas);
+  }
+
+  private resolveBuilderSelectionParams(
+    pubkeyHex: PubkeyHex,
+    isPostGloas: boolean
+  ): {selection: routes.validator.BuilderSelection; boostFactor: bigint} {
+    const validatorBuilder = this.validators.get(pubkeyHex)?.builder;
+    const defaultSelection = getDefaultBuilderSelection(isPostGloas);
+    let selection = validatorBuilder?.selection ?? this.defaultProposerConfig.builder.selection ?? defaultSelection;
+
+    // The standard per-key builder config directly controls the post-Gloas boost. It takes
+    // precedence over the legacy selection aliases when explicitly configured.
+    if (isPostGloas && validatorBuilder?.boostFactor !== undefined) {
+      return {selection: routes.validator.BuilderSelection.MaxProfit, boostFactor: validatorBuilder.boostFactor};
     }
 
+    // Post-Gloas block production uses standard builder boost factor. Need to normalize the
+    // gloas-deprecated "builderonly" and "executiononly" to the gloas fallback "builderalways"
+    // and "executionalways" equivalent before deriving the boost factor.
+    if (isPostGloas) {
+      if (selection === routes.validator.BuilderSelection.BuilderOnly) {
+        selection = routes.validator.BuilderSelection.BuilderAlways;
+      } else if (selection === routes.validator.BuilderSelection.ExecutionOnly) {
+        selection = routes.validator.BuilderSelection.ExecutionAlways;
+      }
+    }
+
+    const boostFactor = getBuilderBoostFactor(
+      selection,
+      validatorBuilder?.boostFactor ?? this.defaultProposerConfig.builder.boostFactor
+    );
+
     return {selection, boostFactor};
   }
 
@@ -327,12 +383,33 @@ export class ValidatorStore {
     );
   }
 
-  getGasLimit(pubkeyHex: PubkeyHex): number {
+  getConfiguredDefaultGasLimit(): number | undefined {
+    return this.defaultProposerConfig.builder.gasLimit;
+  }
+
+  getGasLimit(pubkeyHex: PubkeyHex, slot: Slot, logger?: LoggerVc): number {
     const validatorData = this.validators.get(pubkeyHex);
     if (validatorData === undefined) {
       throw Error(`Validator pubkey ${pubkeyHex} not known`);
     }
-    return validatorData?.builder?.gasLimit ?? this.defaultProposerConfig.builder.gasLimit;
+
+    const configuredGasLimit = validatorData.builder?.gasLimit ?? this.defaultProposerConfig.builder.gasLimit;
+    const scheduledGasLimit = this.config.getScheduledGasLimit(computeEpochAtSlot(slot));
+
+    if (configuredGasLimit !== undefined) {
+      if (scheduledGasLimit !== undefined && configuredGasLimit > scheduledGasLimit) {
+        logger?.warn("Configured gas limit exceeds recommended maximum", {
+          pubkey: pubkeyHex,
+          slot,
+          configuredGasLimit,
+          recommendedGasLimit: scheduledGasLimit,
+        });
+      }
+
+      return configuredGasLimit;
+    }
+
+    return scheduledGasLimit ?? defaultOptions.defaultGasLimit;
   }
 
   setGasLimit(pubkeyHex: PubkeyHex, gasLimit: number): void {
@@ -379,6 +456,126 @@ export class ValidatorStore {
     delete validatorData.builder?.boostFactor;
   }
 
+  getBuilderMinBid(pubkeyHex: PubkeyHex): bigint {
+    const validatorData = this.validators.get(pubkeyHex);
+    if (validatorData === undefined) {
+      throw Error(`Validator pubkey ${pubkeyHex} not known`);
+    }
+    return validatorData?.builder?.minBid ?? this.defaultProposerConfig.builder.minBid;
+  }
+
+  getBuilderMaxExecutionPayment(pubkeyHex: PubkeyHex): bigint {
+    const validatorData = this.validators.get(pubkeyHex);
+    if (validatorData === undefined) {
+      throw Error(`Validator pubkey ${pubkeyHex} not known`);
+    }
+    return validatorData?.builder?.maxExecutionPayment ?? this.defaultProposerConfig.builder.maxExecutionPayment;
+  }
+
+  /**
+   * Resolve the builder entries for this key. Per-key entries replace the validator client's
+   * builders. A value omitted on an entry takes this key's default, then the validator
+   * client's configuration, while omitted auth data is derived from the entry url instead.
+   */
+  getResolvedBuilderEntries(pubkeyHex: PubkeyHex, boostFactor?: bigint): ResolvedBuilderEntry[] {
+    const validatorData = this.validators.get(pubkeyHex);
+    if (validatorData === undefined) {
+      throw Error(`Validator pubkey ${pubkeyHex} not known`);
+    }
+
+    const keyMinBid = validatorData.builder?.minBid ?? this.defaultProposerConfig.builder.minBid;
+    const keyBoostFactor =
+      boostFactor ?? validatorData.builder?.boostFactor ?? this.defaultProposerConfig.builder.boostFactor;
+    const keyMaxExecutionPayment =
+      validatorData.builder?.maxExecutionPayment ?? this.defaultProposerConfig.builder.maxExecutionPayment;
+
+    // The key's defaults apply to the validator client's own builders all the same
+    const builders = validatorData.builder?.builders ?? this.defaultProposerConfig.builder.builders ?? [];
+    return builders.map((entry) => ({
+      url: entry.url,
+      authData: entry.authData !== undefined ? fromHex(entry.authData) : new TextEncoder().encode(entry.url),
+      builderPubkeys: (entry.builderPubkeys ?? []).map(fromHex),
+      maxExecutionPayment: entry.maxExecutionPayment ?? keyMaxExecutionPayment,
+      minBid: entry.minBid ?? keyMinBid,
+      builderBoostFactor: entry.builderBoostFactor ?? keyBoostFactor,
+    }));
+  }
+
+  /** Return the builder configuration in effect for this key, with omitted values resolved */
+  getBuilderConfig(pubkeyHex: PubkeyHex): BuilderConfigData {
+    const validatorData = this.validators.get(pubkeyHex);
+    if (validatorData === undefined) {
+      throw Error(`Validator pubkey ${pubkeyHex} not known`);
+    }
+    const {boostFactor} = this.resolveBuilderSelectionParams(pubkeyHex, true);
+
+    return {
+      minBid: validatorData.builder?.minBid ?? this.defaultProposerConfig.builder.minBid,
+      builderBoostFactor: boostFactor,
+      builders: this.getResolvedBuilderEntries(pubkeyHex, boostFactor).map((entry) => ({
+        url: entry.url,
+        authData: toHex(entry.authData),
+        builderPubkeys: entry.builderPubkeys.map(toPubkeyHex),
+        maxExecutionPayment: entry.maxExecutionPayment,
+        minBid: entry.minBid,
+        builderBoostFactor: entry.builderBoostFactor,
+      })),
+    };
+  }
+
+  /** Set the builder configuration for this key, replacing any stored configuration in full */
+  setBuilderConfig(pubkeyHex: PubkeyHex, config: BuilderConfigData): void {
+    const validatorData = this.validators.get(pubkeyHex);
+    if (validatorData === undefined) {
+      throw Error(`Validator pubkey ${pubkeyHex} not known`);
+    }
+
+    for (const value of [config.minBid, config.builderBoostFactor]) {
+      if (value !== undefined && value > MAX_BUILDER_BOOST_FACTOR) {
+        throw Error(`Invalid builder config value=${value} exceeds uint64`);
+      }
+    }
+
+    // No two entries may share both their url and their auth data, an omitted auth data is
+    // compared as the value derived from the entry url
+    const seenEntries = new Set<string>();
+    for (const entry of config.builders ?? []) {
+      if (!isValidAsciiHttpUrl(entry.url)) {
+        throw Error(`Invalid builder url: ${entry.url}`);
+      }
+      const authData =
+        entry.authData !== undefined ? toHex(fromHex(entry.authData)) : toHex(new TextEncoder().encode(entry.url));
+      const entryKey = `${entry.url}|${authData}`;
+      if (seenEntries.has(entryKey)) {
+        throw Error(`Duplicate builder entry url=${entry.url} authData=${authData}`);
+      }
+      seenEntries.add(entryKey);
+      for (const value of [entry.maxExecutionPayment, entry.minBid, entry.builderBoostFactor]) {
+        if (value !== undefined && value > MAX_BUILDER_BOOST_FACTOR) {
+          throw Error(`Invalid builder entry value=${value} exceeds uint64`);
+        }
+      }
+    }
+
+    validatorData.builder = {
+      ...validatorData.builder,
+      minBid: config.minBid,
+      boostFactor: config.builderBoostFactor,
+      builders: config.builders,
+    };
+  }
+
+  /** Remove the builder configuration for this key, and revert to the validator client configuration */
+  deleteBuilderConfig(pubkeyHex: PubkeyHex): void {
+    const validatorData = this.validators.get(pubkeyHex);
+    if (validatorData === undefined) {
+      throw Error(`Validator pubkey ${pubkeyHex} not known`);
+    }
+    delete validatorData.builder?.minBid;
+    delete validatorData.builder?.boostFactor;
+    delete validatorData.builder?.builders;
+  }
+
   /** Return true if `index` is active part of this validator client */
   hasValidatorIndex(index: ValidatorIndex): boolean {
     return this.indicesService.index2pubkey.has(index);
@@ -400,7 +597,10 @@ export class ValidatorStore {
       feeRecipient !== undefined ||
       builder?.gasLimit !== undefined ||
       builder?.selection !== undefined ||
-      builder?.boostFactor !== undefined
+      builder?.boostFactor !== undefined ||
+      builder?.minBid !== undefined ||
+      builder?.maxExecutionPayment !== undefined ||
+      builder?.builders !== undefined
     ) {
       proposerConfig = {graffiti, strictFeeRecipientCheck, feeRecipient, builder};
     }
@@ -849,6 +1049,71 @@ export class ValidatorStore {
     };
   }
 
+  async signBuilderRequestAuth(
+    pubkeyMaybeHex: BLSPubkeyMaybeHex,
+    data: Uint8Array,
+    proposalSlot: Slot
+  ): Promise<gloas.SignedBuilderRequestAuth> {
+    if (data.length === 0 || data.length > MAX_BUILDER_AUTH_DATA_SIZE) {
+      throw Error(
+        `Invalid builder request auth data length=${data.length}, must be within 1 and ${MAX_BUILDER_AUTH_DATA_SIZE} bytes`
+      );
+    }
+
+    const message: gloas.BuilderRequestAuth = {data, slot: proposalSlot};
+
+    const signingSlot = 0;
+    const domain = computeDomain(DOMAIN_BUILDER_REQUEST_AUTH, this.config.GENESIS_FORK_VERSION, ZERO_HASH);
+    const signingRoot = computeSigningRoot(ssz.gloas.BuilderRequestAuth, message, domain);
+
+    const signableMessage: SignableMessage = {
+      type: SignableMessageType.BUILDER_REQUEST_AUTH,
+      data: message,
+    };
+
+    return {
+      message,
+      signature: await this.getSignature(pubkeyMaybeHex, signingRoot, signingSlot, signableMessage),
+    };
+  }
+
+  /**
+   * Return a pre-signed builder request auth for the auth data and proposal slot, or sign and cache a new
+   * one. Signing happens off the block proposal hot path when preferences are submitted ahead of
+   * time, cached auths are then used just-in-time when requesting bids at proposal time.
+   */
+  async getBuilderRequestAuth(
+    pubkeyMaybeHex: BLSPubkeyMaybeHex,
+    data: Uint8Array,
+    proposalSlot: Slot,
+    currentSlot: Slot
+  ): Promise<gloas.SignedBuilderRequestAuth> {
+    const pubkeyHex = typeof pubkeyMaybeHex === "string" ? pubkeyMaybeHex : toPubkeyHex(pubkeyMaybeHex);
+    const authKey = `${proposalSlot}-${toHex(data)}`;
+    const validatorData = this.validators.get(pubkeyHex);
+    const cached = validatorData?.builderRequestAuths?.get(authKey);
+    if (cached !== undefined) {
+      return cached;
+    }
+
+    const signedRequestAuth = await this.signBuilderRequestAuth(pubkeyMaybeHex, data, proposalSlot);
+
+    if (validatorData !== undefined) {
+      const builderRequestAuths =
+        validatorData.builderRequestAuths ?? new Map<string, gloas.SignedBuilderRequestAuth>();
+      // Prune auths for proposal slots that are already in the past
+      for (const key of builderRequestAuths.keys()) {
+        if (Number(key.slice(0, key.indexOf("-"))) < currentSlot) {
+          builderRequestAuths.delete(key);
+        }
+      }
+      builderRequestAuths.set(authKey, signedRequestAuth);
+      validatorData.builderRequestAuths = builderRequestAuths;
+    }
+
+    return signedRequestAuth;
+  }
+
   async getValidatorRegistration(
     pubkeyMaybeHex: BLSPubkeyMaybeHex,
     regAttributes: {feeRecipient: ExecutionAddress; gasLimit: number},

package/src/types.ts

@@ -1,4 +1,4 @@
-import {SecretKey} from "@chainsafe/blst";
+import {SecretKey} from "@chainsafe/lodestar-z/blst";
 import {DatabaseController} from "@lodestar/db";
 import {BLSPubkey} from "@lodestar/types";
 

package/src/util/externalSignerClient.ts

@@ -36,6 +36,7 @@ export enum SignableMessageType {
   EXECUTION_PAYLOAD_ENVELOPE = "EXECUTION_PAYLOAD_ENVELOPE",
   PAYLOAD_ATTESTATION = "PAYLOAD_ATTESTATION",
   PROPOSER_PREFERENCES = "PROPOSER_PREFERENCES",
+  BUILDER_REQUEST_AUTH = "BUILDER_REQUEST_AUTH",
 }
 
 const AggregationSlotType = new ContainerType({
@@ -87,7 +88,8 @@ export type SignableMessage =
   | {type: SignableMessageType.VALIDATOR_REGISTRATION; data: ValidatorRegistrationV1}
   | {type: SignableMessageType.EXECUTION_PAYLOAD_ENVELOPE; data: gloas.ExecutionPayloadEnvelope}
   | {type: SignableMessageType.PAYLOAD_ATTESTATION; data: gloas.PayloadAttestationData}
-  | {type: SignableMessageType.PROPOSER_PREFERENCES; data: gloas.ProposerPreferences};
+  | {type: SignableMessageType.PROPOSER_PREFERENCES; data: gloas.ProposerPreferences}
+  | {type: SignableMessageType.BUILDER_REQUEST_AUTH; data: gloas.BuilderRequestAuth};
 
 const requiresForkInfo: Record<SignableMessageType, boolean> = {
   [SignableMessageType.AGGREGATION_SLOT]: true,
@@ -105,6 +107,7 @@ const requiresForkInfo: Record<SignableMessageType, boolean> = {
   [SignableMessageType.EXECUTION_PAYLOAD_ENVELOPE]: true,
   [SignableMessageType.PAYLOAD_ATTESTATION]: true,
   [SignableMessageType.PROPOSER_PREFERENCES]: true,
+  [SignableMessageType.BUILDER_REQUEST_AUTH]: false,
 };
 
 type Web3SignerSerializedRequest = {
@@ -285,6 +288,9 @@ function serializerSignableMessagePayload(config: BeaconConfig, payload: Signabl
 
     case SignableMessageType.PROPOSER_PREFERENCES:
       return {proposer_preferences: ssz.gloas.ProposerPreferences.toJson(payload.data)};
+
+    case SignableMessageType.BUILDER_REQUEST_AUTH:
+      return {builder_request_auth: ssz.gloas.BuilderRequestAuth.toJson(payload.data)};
   }
 }
 

package/src/validator.ts

@@ -9,13 +9,14 @@ import {
 import {Clock, ClockOptions, IClock, computeEpochAtSlot, getCurrentSlot} from "@lodestar/state-transition";
 import {BLSPubkey, phase0, ssz} from "@lodestar/types";
 import {Genesis} from "@lodestar/types/phase0";
-import {Logger, toPrintableUrl, toRootHex} from "@lodestar/utils";
+import {Logger, prettyGweiToEth, toPrintableUrl, toRootHex} from "@lodestar/utils";
 import {waitForGenesis} from "./genesis.js";
 import {Metrics} from "./metrics.js";
 import {MetaDataRepository} from "./repositories/metaDataRepository.js";
 import {AttestationService} from "./services/attestation.js";
 import {BlockProposingService} from "./services/block.js";
 import {BlockDutiesService} from "./services/blockDuties.js";
+import {BuilderPreferencesService} from "./services/builderPreferences.js";
 import {ChainHeaderTracker} from "./services/chainHeaderTracker.js";
 import {DoppelgangerService} from "./services/doppelgangerService.js";
 import {ValidatorEventEmitter} from "./services/emitter.js";
@@ -26,7 +27,14 @@ import {ProposerPreferencesService} from "./services/proposerPreferences.js";
 import {PtcService} from "./services/ptc.js";
 import {SyncCommitteeService} from "./services/syncCommittee.js";
 import {SyncingStatusTracker} from "./services/syncingStatusTracker.js";
-import {Signer, ValidatorProposerConfig, ValidatorStore, defaultOptions} from "./services/validatorStore.js";
+import {
+  Signer,
+  ValidatorProposerConfig,
+  ValidatorStore,
+  defaultOptions,
+  getBuilderBoostFactor,
+  getDefaultBuilderSelection,
+} from "./services/validatorStore.js";
 import {ISlashingProtection, Interchange, InterchangeFormatVersion} from "./slashingProtection/index.js";
 import {LodestarValidatorDatabaseController, ProcessShutdownCallback, PubkeyHex} from "./types.js";
 import {getLoggerVc} from "./util/index.js";
@@ -98,7 +106,7 @@ export class Validator {
   private readonly syncCommitteeService: SyncCommitteeService;
   private readonly config: BeaconConfig;
   private readonly api: ApiClient;
-  private readonly clock: IClock;
+  readonly clock: IClock;
   private readonly chainHeaderTracker: ChainHeaderTracker;
   readonly syncingStatusTracker: SyncingStatusTracker;
   private readonly logger: Logger;
@@ -313,6 +321,7 @@ export class Validator {
     );
 
     new ProposerPreferencesService(config, loggerVc, api, clock, validatorStore, blockDutiesService, metrics);
+    new BuilderPreferencesService(config, loggerVc, api, clock, validatorStore, blockDutiesService, metrics);
 
     return new Validator({
       opts,
@@ -367,8 +376,9 @@ export class Validator {
     logger.info("Verified connected beacon node and validator have the same genesisValidatorRoot");
 
     const {broadcastValidation = defaultOptions.broadcastValidation, valProposerConfig} = opts;
+    const gloasScheduled = config.GLOAS_FORK_EPOCH !== Infinity;
     const defaultBuilderSelection =
-      valProposerConfig?.defaultConfig.builder?.selection ?? defaultOptions.builderSelection;
+      valProposerConfig?.defaultConfig.builder?.selection ?? getDefaultBuilderSelection(gloasScheduled);
     const strictFeeRecipientCheck = valProposerConfig?.defaultConfig.strictFeeRecipientCheck ?? false;
     const suggestedFeeRecipient = valProposerConfig?.defaultConfig.feeRecipient ?? defaultOptions.suggestedFeeRecipient;
 
@@ -381,6 +391,23 @@ export class Validator {
 
     metrics?.defaultConfiguration.set({builderSelection: defaultBuilderSelection, broadcastValidation}, 1);
 
+    if (gloasScheduled) {
+      const defaultBuilderConfig = valProposerConfig?.defaultConfig.builder;
+      const defaultBuilders = defaultBuilderConfig?.builders ?? [];
+
+      logger.info("Builder config", {
+        builders: defaultBuilders.map((entry) => toPrintableUrl(entry.url)).join(",") || "p2p only",
+        boostFactor: getBuilderBoostFactor(
+          defaultBuilderSelection,
+          defaultBuilderConfig?.boostFactor ?? defaultOptions.builderBoostFactor
+        ),
+        minBid: prettyGweiToEth(defaultBuilderConfig?.minBid ?? defaultOptions.builderMinBid),
+        maxExecutionPayment: prettyGweiToEth(
+          defaultBuilderConfig?.maxExecutionPayment ?? defaultOptions.builderMaxExecutionPayment
+        ),
+      });
+    }
+
     // Instantiates block and attestation services and runs them once the chain has been started.
     return Validator.init(opts, genesis, metrics);
   }