@lodestar/validator 1.47.0-dev.9d19aee2e7 → 1.47.0-dev.9ecc10f386

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lodestar/validator",
-  "version": "1.47.0-dev.9d19aee2e7",
+  "version": "1.47.0-dev.9ecc10f386",
   "description": "A Typescript implementation of the validator client",
   "author": "ChainSafe Systems",
   "license": "Apache-2.0",
@@ -48,23 +48,23 @@
     "blockchain"
   ],
   "dependencies": {
-    "@chainsafe/blst": "^2.2.0",
-    "@chainsafe/ssz": "^1.6.2",
-    "@lodestar/api": "^1.47.0-dev.9d19aee2e7",
-    "@lodestar/config": "^1.47.0-dev.9d19aee2e7",
-    "@lodestar/db": "^1.47.0-dev.9d19aee2e7",
-    "@lodestar/params": "^1.47.0-dev.9d19aee2e7",
-    "@lodestar/state-transition": "^1.47.0-dev.9d19aee2e7",
-    "@lodestar/types": "^1.47.0-dev.9d19aee2e7",
-    "@lodestar/utils": "^1.47.0-dev.9d19aee2e7",
+    "@chainsafe/lodestar-z": "catalog:",
+    "@chainsafe/ssz": "^1.6.3",
+    "@lodestar/api": "^1.47.0-dev.9ecc10f386",
+    "@lodestar/config": "^1.47.0-dev.9ecc10f386",
+    "@lodestar/db": "^1.47.0-dev.9ecc10f386",
+    "@lodestar/params": "^1.47.0-dev.9ecc10f386",
+    "@lodestar/state-transition": "^1.47.0-dev.9ecc10f386",
+    "@lodestar/types": "^1.47.0-dev.9ecc10f386",
+    "@lodestar/utils": "^1.47.0-dev.9ecc10f386",
     "strict-event-emitter-types": "^2.0.0"
   },
   "devDependencies": {
-    "@lodestar/logger": "^1.47.0-dev.9d19aee2e7",
-    "@lodestar/spec-test-util": "^1.47.0-dev.9d19aee2e7",
-    "@lodestar/test-utils": "^1.47.0-dev.9d19aee2e7",
+    "@lodestar/logger": "^1.47.0-dev.9ecc10f386",
+    "@lodestar/spec-test-util": "^1.47.0-dev.9ecc10f386",
+    "@lodestar/test-utils": "^1.47.0-dev.9ecc10f386",
     "@vekexasia/bigint-buffer2": "^1.1.1",
     "rimraf": "^4.4.1"
   },
-  "gitHead": "7bcb13bb1874a0d514f22c13a8629eabc69eabe8"
+  "gitHead": "d9f5a350881754b896bbbc33887c8c22ad93acff"
 }

package/src/services/block.ts

@@ -194,6 +194,8 @@ export class BlockProposingService {
     const {broadcastValidation, payloadLocal} = this.opts;
     const {selection: builderSelection, boostFactor: builderBoostFactor} =
       this.validatorStore.getBuilderSelectionParams(pubkeyHex, slot);
+    const builderMinBid = this.validatorStore.getBuilderMinBid(pubkeyHex);
+    const builderEntries = this.validatorStore.getResolvedBuilderEntries(pubkeyHex, builderBoostFactor);
 
     this.logger.debug("Producing block", {
       ...debugLogCtx,
@@ -202,9 +204,35 @@ export class BlockProposingService {
       payloadLocal,
       builderSelection,
       builderBoostFactor,
+      builderMinBid,
+      builderUrls: builderEntries.map((entry) => entry.url).join(","),
     });
     this.metrics?.proposerStepCallProduceBlock.observe(this.clock.secFromSlot(slot));
 
+    // One entry per resolved builder, authenticated by a request auth signed over the entry's
+    // auth data. The auth is usually pre-signed when preferences are submitted ahead of the
+    // proposal. An entry whose auth cannot be signed is skipped so it never fails the proposal.
+    const builders: routes.validator.BuilderEntry[] = (
+      await Promise.all(
+        builderEntries.map(async (entry) => {
+          try {
+            const auth = await this.validatorStore.getBuilderRequestAuth(pubkey, entry.authData, slot, slot);
+            return {
+              url: new TextEncoder().encode(entry.url),
+              auth,
+              builderPubkeys: entry.builderPubkeys,
+              maxExecutionPayment: entry.maxExecutionPayment,
+              minBid: entry.minBid,
+              builderBoostFactor: entry.builderBoostFactor,
+            };
+          } catch (e) {
+            this.logger.warn("Failed to sign builder request auth", {...logCtx, builderUrl: entry.url}, e as Error);
+            return null;
+          }
+        })
+      )
+    ).filter((entry) => entry !== null);
+
     // Step 1: Produce beacon block with execution payload bid
     const blockRes = await this.api.validator
       .produceBlockV4({
@@ -214,7 +242,11 @@ export class BlockProposingService {
         feeRecipient,
         strictFeeRecipientCheck,
         includePayload: !payloadLocal,
-        builderBoostFactor,
+        builderConfig: {
+          minBid: builderMinBid,
+          builderBoostFactor,
+          builders,
+        },
       })
       .catch((e: Error) => {
         this.metrics?.blockProposingErrors.inc({error: "produce"});
@@ -250,6 +282,8 @@ export class BlockProposingService {
         .publishBlockV2({
           signedBlockContents: {signedBlock},
           broadcastValidation,
+          // Echo the winning builder url so any beacon node can forward the block to the builder
+          builderUrl: blockMeta.builderUrl,
         })
         .catch((e: Error) => {
           this.metrics?.blockProposingErrors.inc({error: "publish"});

package/src/services/builderPreferences.ts

@@ -0,0 +1,142 @@
+import {ApiClient, routes} from "@lodestar/api";
+import {ChainForkConfig} from "@lodestar/config";
+import {SLOTS_PER_EPOCH, isForkPostGloas} from "@lodestar/params";
+import {IClock, computeEpochAtSlot} from "@lodestar/state-transition";
+import {Epoch, RootHex, Slot} from "@lodestar/types";
+import {toPubkeyHex} from "@lodestar/utils";
+import {Metrics} from "../metrics.js";
+import {LoggerVc} from "../util/index.js";
+import {BlockDutiesService} from "./blockDuties.js";
+import {ValidatorStore} from "./validatorStore.js";
+
+/**
+ * Submit a proposer's builder preferences this many slots before the proposal slot.
+ * Same pacing as `ProposerPreferencesService`, builders must have the preferences
+ * before the bid request arrives at proposal time.
+ */
+const SUBMIT_BEFORE_PROPOSAL_SLOTS = Math.floor(SLOTS_PER_EPOCH / 4);
+
+/** Per-epoch tracking of preferences already submitted under the current dependent_root. */
+type SubmittedAtEpoch = {dependentRoot: RootHex; slots: Set<Slot>};
+
+/**
+ * Signs and submits builder preferences for any local validator that will propose within the
+ * next `SUBMIT_BEFORE_PROPOSAL_SLOTS` and has external builders configured. Signing the request
+ * auths here also pre-fills the auth cache used at proposal time.
+ *
+ * The beacon node submits each entry to the builder at the entry's url. Re-submits automatically
+ * when the proposer dependent root for an epoch shifts (e.g. after a reorg) since the proposer
+ * for a slot may have changed.
+ */
+export class BuilderPreferencesService {
+  private readonly submitted = new Map<Epoch, SubmittedAtEpoch>();
+
+  constructor(
+    private readonly config: ChainForkConfig,
+    private readonly logger: LoggerVc,
+    private readonly api: ApiClient,
+    clock: IClock,
+    private readonly validatorStore: ValidatorStore,
+    private readonly blockDutiesService: BlockDutiesService,
+    _metrics: Metrics | null
+  ) {
+    clock.runEverySlot(this.runBuilderPreferencesTask);
+  }
+
+  private runBuilderPreferencesTask = async (slot: Slot): Promise<void> => {
+    // Start running once the submission window (`slot + SUBMIT_BEFORE_PROPOSAL_SLOTS`) reaches
+    // Gloas, i.e. already in the epoch before the fork. This allows builders to prepare and
+    // submit bids for the first Gloas slots.
+    if (!isForkPostGloas(this.config.getForkName(slot + SUBMIT_BEFORE_PROPOSAL_SLOTS))) {
+      return;
+    }
+
+    const currentEpoch = computeEpochAtSlot(slot);
+    const entries: routes.validator.BuilderPreferencesEntry[] = [];
+    // Track which `(submission, slot)` pairs are pending an API submission so we can mark
+    // them only after the network call succeeds. Marking before would silently drop a
+    // preference on transient API failure (no retry until dependent_root shifts).
+    const pending: {submission: SubmittedAtEpoch; slot: Slot}[] = [];
+
+    for (const epoch of [currentEpoch, currentEpoch + 1]) {
+      const dutiesAtEpoch = this.blockDutiesService.getProposersAtEpoch(epoch);
+      if (!dutiesAtEpoch) continue;
+
+      // Reset submission tracking if the dependent root for this epoch has shifted
+      // (e.g. due to a reorg). The proposer for a slot may have changed.
+      let submission = this.submitted.get(epoch);
+      if (submission === undefined || submission.dependentRoot !== dutiesAtEpoch.dependentRoot) {
+        if (submission !== undefined) {
+          this.logger.info("Proposer-shuffling dependent root shifted; resubmitting builder preferences", {
+            epoch,
+            priorDependentRoot: submission.dependentRoot,
+            dependentRoot: dutiesAtEpoch.dependentRoot,
+          });
+        }
+        submission = {dependentRoot: dutiesAtEpoch.dependentRoot, slots: new Set()};
+        this.submitted.set(epoch, submission);
+      }
+
+      for (const duty of dutiesAtEpoch.data) {
+        if (duty.slot <= slot) continue;
+        if (duty.slot > slot + SUBMIT_BEFORE_PROPOSAL_SLOTS) continue;
+        if (!isForkPostGloas(this.config.getForkName(duty.slot))) continue;
+        if (submission.slots.has(duty.slot)) continue;
+
+        const pubkeyHex = toPubkeyHex(duty.pubkey);
+        const {selection} = this.validatorStore.getBuilderSelectionParams(pubkeyHex, duty.slot);
+        if (selection === routes.validator.BuilderSelection.ExecutionOnly) continue;
+
+        const builderEntries = this.validatorStore.getResolvedBuilderEntries(pubkeyHex);
+        if (builderEntries.length === 0) continue;
+
+        try {
+          // Collect entries per duty and only add them to the batch if signing
+          // succeeded for all builders, else the duty is retried on the next tick
+          const dutyEntries: routes.validator.BuilderPreferencesEntry[] = [];
+          for (const entry of builderEntries) {
+            const auth = await this.validatorStore.getBuilderRequestAuth(duty.pubkey, entry.authData, duty.slot, slot);
+            dutyEntries.push({
+              proposerPubkey: duty.pubkey,
+              url: new TextEncoder().encode(entry.url),
+              auth,
+              maxExecutionPayment: entry.maxExecutionPayment,
+            });
+          }
+          entries.push(...dutyEntries);
+          pending.push({submission, slot: duty.slot});
+        } catch (e) {
+          this.logger.error(
+            "Error signing builder preferences",
+            {slot: duty.slot, validatorIndex: duty.validatorIndex},
+            e as Error
+          );
+        }
+      }
+    }
+
+    // Prune tracking for past epochs
+    for (const epoch of this.submitted.keys()) {
+      if (epoch < currentEpoch) {
+        this.submitted.delete(epoch);
+      }
+    }
+
+    if (entries.length === 0) {
+      return;
+    }
+
+    try {
+      (await this.api.validator.submitBuilderPreferences({builderPreferences: entries})).assertOk();
+      // Only mark as submitted after the API call succeeds; a thrown error, including per-entry
+      // failures reported by index, leaves all slots eligible for retry on the next tick.
+      // Re-submitting preferences a builder already accepted is harmless.
+      for (const {submission, slot: submittedSlot} of pending) {
+        submission.slots.add(submittedSlot);
+      }
+      this.logger.debug("Submitted builder preferences", {count: entries.length});
+    } catch (e) {
+      this.logger.error("Error submitting builder preferences", {count: entries.length}, e as Error);
+    }
+  };
+}

package/src/services/externalSignerSync.ts

@@ -1,4 +1,4 @@
-import {PublicKey} from "@chainsafe/blst";
+import {PublicKey} from "@chainsafe/lodestar-z/blst";
 import {ChainForkConfig} from "@lodestar/config";
 import {SLOTS_PER_EPOCH} from "@lodestar/params";
 import {fromHex, toPrintableUrl} from "@lodestar/utils";

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";
@@ -84,6 +87,9 @@ type DefaultProposerConfig = {
     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
@@ -185,6 +210,9 @@ export class ValidatorStore {
         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,
       },
     };
 
@@ -287,11 +315,22 @@ export class ValidatorStore {
     // 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 = slot !== undefined && 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 = isPostGloas ? defaultOptions.builderAliasSelection : defaultOptions.builderSelection;
-    let selection =
-      this.validators.get(pubkeyHex)?.builder?.selection ??
-      this.defaultProposerConfig.builder.selection ??
-      defaultSelection;
+    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"
@@ -313,8 +352,7 @@ export class ValidatorStore {
         break;
 
       case routes.validator.BuilderSelection.MaxProfit:
-        boostFactor =
-          this.validators.get(pubkeyHex)?.builder?.boostFactor ?? this.defaultProposerConfig.builder.boostFactor;
+        boostFactor = validatorBuilder?.boostFactor ?? this.defaultProposerConfig.builder.boostFactor;
         break;
 
       case routes.validator.BuilderSelection.BuilderAlways:
@@ -409,6 +447,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);
@@ -430,7 +588,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};
     }
@@ -879,6 +1040,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

@@ -16,6 +16,7 @@ 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";
@@ -313,6 +314,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,