@lodestar/beacon-node 1.47.0-dev.4546ac1229 → 1.47.0-dev.56250f4ab6

package/src/chain/stateCache/fifoBlockStateCache.ts

@@ -144,13 +144,20 @@ export class FIFOBlockStateCache implements BlockStateCache {
     return this.cache.size;
   }
 
+  /**
+   * On a checkpoint event, prune the cache while keeping the head state.
+   */
+  onCheckpoint(headStateRootHex: string): void {
+    this.prune(headStateRootHex);
+  }
+
   /**
    * Prune the cache from tail to keep the most recent n states consistently.
    * The tail of the list is the oldest state, in case regen adds back the same state,
    * it should stay next to head so that it won't be pruned right away.
    * The FIFO cache helps with this.
    */
-  prune(lastAddedKey: string): void {
+  private prune(lastAddedKey: string): void {
     while (this.keyOrder.length > this.maxStates) {
       const key = this.keyOrder.last();
       // it does not make sense to prune the last added state

package/src/chain/stateCache/persistentCheckpointsCache.ts

@@ -14,7 +14,11 @@ import {BlockStateCache, CacheItemType, CheckpointHex, CheckpointStateCache} fro
 export type PersistentCheckpointStateCacheOpts = {
   /** Keep max n state epochs in memory, persist the rest to disk */
   maxCPStateEpochsInMemory?: number;
-  /** Keep max n state epochs on disk */
+  /**
+   * On-disk retention of persisted checkpoint states. Selects one of two modes:
+   * - `Infinity` (default) -> tiered retention mode
+   * - any finite `n` (>= 0) -> legacy flat retention (keep the last n dense epochs)
+   */
   maxCPStateEpochsOnDisk?: number;
 };
 
@@ -64,6 +68,18 @@ export const DEFAULT_MAX_CP_STATE_EPOCHS_IN_MEMORY = 3;
  */
 export const DEFAULT_MAX_CP_STATE_ON_DISK = Infinity;
 
+// CP_STATE_TIER_BASE = spacing multiplier per tier AND per-tier capacity. Deciding capacity == base
+// so that a full tier[n] always holds exactly ONE epoch aligned to tier[n+1]
+// given tier[n] has span = 16 ^ n and tier[n+1] has span = 16 ^ (n+1)
+// why 16?
+//   - tier 0 is the dense hot-regen window; it must exceed regen's MAX_EPOCH_TO_PROCESS (=5).
+//   - with a full 4 tiers = 64 epochs, we can cover ~ a year of continuous non-finality, and it'll grow very slowly after that
+//     - tier0 spans 16 epochs ≈ 1.7h, this is more than enough to handle reorg
+//     - tier1 spans 256 epochs ≈ 1.1d, ie we store 16 epochs of the previous day
+//     - tier2 spans 4096 epochs ≈ 18d, ie we store 16 epochs of the last ~2.5 weeks
+//     - tier3 spans 65536ep ≈ 291d, ie we store 16 epochs of the last 0.8 year
+export const CP_STATE_TIER_BASE = 16;
+
 // TODO GLOAS: re-evaluate this timing
 const PROCESS_CHECKPOINT_STATES_BPS = 6667;
 
@@ -112,6 +128,19 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
   private preComputedCheckpointHits: number | null = null;
   private readonly maxEpochsInMemory: number;
   private readonly maxEpochsOnDisk: number;
+  /**
+   * Persist checkpoint states (epoch + root) by tiers
+   *
+   *                   ╔═════════ tier 2 ══════════╦═══════ tier 1 ═══════╦═══ tier 0 (dense) ══╗
+   * finalizedEpoch -> ║  keep 1 epoch per 256     ║  keep 1 epoch per 16 ║  keep every epoch   ║ -> head
+   *                   ║  x·······x·······x······  ║  x···x···x···x···    ║  xxxxxxxxxxxxxxxxx  ║
+   *                   ╚═══════════════════════════╩══════════════════════╩═════════════════════╝
+   *
+   * starting from tier 1, all epochs must be aligned to the finalized epoch
+   */
+  private persistentTiers: Map<Epoch, Set<RootHex>>[] = [new Map()];
+  private finalizedEpoch: Epoch = 0;
+  private justifiedEpoch: Epoch = 0;
   private readonly datastore: CPStateDatastore;
   private readonly blockStateCache: BlockStateCache;
   private readonly bufferPool?: BufferPool;
@@ -152,6 +181,13 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
         metrics.cpStateCache.size.set({type: CacheItemType.inMemory}, inMemoryCount);
         metrics.cpStateCache.epochSize.set({type: CacheItemType.persisted}, persistentEpochs.size);
         metrics.cpStateCache.epochSize.set({type: CacheItemType.inMemory}, memoryEpochs.size);
+
+        for (let tier = 0; tier < this.persistentTiers.length; tier++) {
+          let states = 0;
+          for (const roots of this.persistentTiers[tier].values()) states += roots.size;
+          metrics.cpStateCache.persistentTierEpochs.set({tier}, this.persistentTiers[tier].size);
+          metrics.cpStateCache.persistentTierStates.set({tier}, states);
+        }
       });
     }
     this.logger = logger;
@@ -407,10 +443,77 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
   }
 
   /**
-   * This is just to conform to the old implementation
+   * This is called on every checkpoint event to refresh the pinned finalized/justified epochs.
    */
-  prune(): void {
-    // do nothing
+  onCheckpoint(finalizedEpoch: Epoch, justifiedEpoch: Epoch): void {
+    this.finalizedEpoch = finalizedEpoch;
+    this.justifiedEpoch = justifiedEpoch;
+  }
+
+  /**
+   * This is called right after we persist a checkpoint state.
+   */
+  private async onPersist(epoch: Epoch, rootHex: RootHex): Promise<void> {
+    let roots = this.persistentTiers[0].get(epoch);
+    if (roots === undefined) {
+      roots = new Set<RootHex>();
+      this.persistentTiers[0].set(epoch, roots);
+    }
+    roots.add(rootHex);
+    await this.prunePersistentTier(0);
+  }
+
+  /**
+   * When tier `n` overflows (> CP_STATE_TIER_BASE epochs), evict its oldest epoch and either promote it to tier `n + 1` (if aligned there) or delete it.
+   *
+   *   before:  persistentTiers[n]   = { ..., e_old }
+   *            persistentTiers[n+1] = { ... }
+   *
+   *   after, if e_old aligns to n+1:           |  after, if e_old does NOT align to n+1:
+   *     persistentTiers[n]   = { ... }         |    persistentTiers[n]   = { ... }
+   *     persistentTiers[n+1] = { ..., e_old }  |    e_old and all its roots deleted from disk
+   *
+   * Since pruning a tier[n] may push an item at tier[n+1], we must call the function recursively.
+   */
+  private async prunePersistentTier(tier: number): Promise<void> {
+    const tierMap = this.persistentTiers[tier];
+    while (tierMap.size > CP_STATE_TIER_BASE) {
+      // Evict the oldest epoch, but never the pinned justified epoch
+      const oldestEpoch = Math.min(...Array.from(tierMap.keys()).filter((epoch) => epoch !== this.justifiedEpoch));
+      const roots = tierMap.get(oldestEpoch) as Set<RootHex>;
+      tierMap.delete(oldestEpoch);
+
+      const rootHexes = Array.from(roots).join(",");
+      // `>= finalizedEpoch` guards the transient window where an epoch below the (fork-choice)
+      // finalized epoch has not yet been removed by pruneFinalized: its offset would be negative
+      // and JS `%` could spuriously report it as aligned. Such epochs are stale -> delete.
+      if (oldestEpoch >= this.finalizedEpoch && this.alignedForTier(oldestEpoch, tier + 1)) {
+        if (this.persistentTiers[tier + 1] === undefined) {
+          this.persistentTiers[tier + 1] = new Map<Epoch, Set<RootHex>>();
+        }
+        this.persistentTiers[tier + 1].set(oldestEpoch, roots);
+        this.logger.verbose("Migrated persistent checkpoint states to lower tier", {
+          epoch: oldestEpoch,
+          fromTier: tier,
+          toTier: tier + 1,
+          rootHexes,
+        });
+        await this.prunePersistentTier(tier + 1);
+      } else {
+        // the oldest epoch is not aligned to the next tier
+        await this.deleteAllEpochItems(oldestEpoch)
+          .then(() => this.logger.verbose("Pruned checkpoint states from disk", {epoch: oldestEpoch, tier, rootHexes}))
+          .catch((e) => this.logger.debug("Error delete all epoch items", {epoch: oldestEpoch, tier}, e as Error));
+      }
+    }
+  }
+
+  /**
+   * Starting from tier[1], it must be aligned to the finalized epoch
+   * ie given finalized epoch F, tier[n] only epochs of F + n*16, n = 1,2,3...
+   */
+  private alignedForTier(epoch: Epoch, tier: number): boolean {
+    return (epoch - this.finalizedEpoch) % CP_STATE_TIER_BASE ** tier === 0;
   }
 
   /**
@@ -598,9 +701,16 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
     return seedBlockState;
   }
 
-  clear(): void {
-    this.cache.clear();
-    this.epochIndex.clear();
+  async clear(): Promise<void> {
+    // deleteAllEpochItems removes every root of an epoch from disk and clears the cache
+    await Promise.all(
+      Array.from(this.epochIndex.keys()).map((epoch) =>
+        this.deleteAllEpochItems(epoch).catch((e) =>
+          this.logger.debug("Error delete all epoch items on clear", {epoch}, e as Error)
+        )
+      )
+    );
+    this.persistentTiers = [new Map()];
   }
 
   /** ONLY FOR DEBUGGING PURPOSES. For lodestar debug API */
@@ -743,12 +853,18 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
           }
           // overwrite cpKey, this means the state is deleted from memory
           this.cache.set(cpKey, {type: CacheItemType.persisted, value: persistedKey});
+          if (this.isTieredMode) {
+            await this.onPersist(epoch, rootHex);
+          }
         } else {
           if (persistedKey) {
             // persisted file will be eventually deleted by the archive task
             // this also means the state is deleted from memory
             this.cache.set(cpKey, {type: CacheItemType.persisted, value: persistedKey});
             // do not update epochIndex
+            if (this.isTieredMode) {
+              await this.onPersist(epoch, rootHex);
+            }
           } else {
             // delete the state from memory
             this.cache.delete(cpKey);
@@ -790,6 +906,10 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
       this.cache.delete(key);
     }
     this.epochIndex.delete(epoch);
+    // keep the on-disk retention tiers in sync so they never drift from epochIndex
+    for (const tierMap of this.persistentTiers) {
+      tierMap.delete(epoch);
+    }
     this.logger.verbose("Pruned checkpoint states for epoch", {
       epoch,
       persistCount,
@@ -798,7 +918,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
   }
 
   /**
-   * Prune persisted checkpoint states from disk.
+   * Legacy flat-window on-disk pruning, used only when a `maxEpochsOnDisk` is configured.
    * Note that this should handle all possible errors and not throw.
    */
   private prunePersistedStates(): void {
@@ -842,6 +962,11 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
 
     return null;
   }
+
+  /** Tiered pruning is active with the default `Infinity` on-disk cap; a finite cap uses the flat path */
+  private get isTieredMode(): boolean {
+    return this.maxEpochsOnDisk === Infinity;
+  }
 }
 
 export function toCheckpointHex(checkpoint: phase0.Checkpoint): CheckpointHex {

package/src/chain/stateCache/types.ts

@@ -29,7 +29,7 @@ export interface BlockStateCache {
   getSeedState(): IBeaconStateView;
   clear(): void;
   size: number;
-  prune(headStateRootHex: RootHex): void;
+  onCheckpoint(headStateRootHex: RootHex): void;
   dumpSummary(): routes.lodestar.StateCacheItem[];
   /** Expose beacon states stored in cache. Use with caution */
   getStates(): IterableIterator<IBeaconStateView>;
@@ -65,9 +65,9 @@ export interface CheckpointStateCache {
   getLatest(rootHex: RootHex, maxEpoch: Epoch): IBeaconStateView | null;
   getOrReloadLatest(rootHex: RootHex, maxEpoch: Epoch): Promise<IBeaconStateView | null>;
   updatePreComputedCheckpoint(rootHex: RootHex, epoch: Epoch): number | null;
-  prune(finalizedEpoch: Epoch, justifiedEpoch: Epoch): void;
+  onCheckpoint(finalizedEpoch: Epoch, justifiedEpoch: Epoch): void;
   processState(blockRootHex: RootHex, state: IBeaconStateView): Promise<number>;
-  clear(): void;
+  clear(): Promise<void>;
   dumpSummary(): routes.lodestar.StateCacheItem[];
   /** Expose beacon states stored in cache. Use with caution */
   getStates(): IterableIterator<IBeaconStateView>;

package/src/chain/validation/executionPayloadBid.ts

@@ -313,11 +313,11 @@ async function validateExecutionPayloadBid(
   // increment, see https://github.com/ethereum/consensus-specs/pull/4831. This prevents spam
   // from builders submitting numerous bids with minimal value increments.
   const bestBid = chain.executionPayloadBidPool.getBestBid(bid.slot, bidParentBlockHash, bidParentBlockRoot);
-  if (bestBid !== null && bid.value < getMinBidValue(bestBid.message.value)) {
+  if (bestBid !== null && bid.value < getMinBidValue(bestBid.signedBid.message.value)) {
     throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
       code: ExecutionPayloadBidErrorCode.BID_TOO_LOW,
       bidValue: bid.value,
-      currentHighestBid: bestBid.message.value,
+      currentHighestBid: bestBid.signedBid.message.value,
     });
   }
   // [IGNORE] `bid.value` is less or equal than the builder's excess balance --

package/src/chain/validation/voluntaryExit.ts

@@ -9,12 +9,69 @@ import {
 import {IBeaconChain} from "../index.js";
 import {RegenCaller} from "../regen/index.js";
 
+export type ApiVoluntaryExitResult = {status: "published"} | {status: "deferred"; validity: VoluntaryExitValidity};
+
+// Variants that can become valid in a future epoch without user action.
+// - earlyEpoch: exit.message.epoch is in the future; valid once current epoch catches up
+// - shortTimeActive: validator active < SHARD_COMMITTEE_PERIOD; valid once enough time passes
+// - pendingWithdrawals: Electra; valid once pending partial withdrawals drain
+// Note: VoluntaryExitValidity.inactive is intentionally excluded. It conflates
+// "validator does not exist" (permanent) with "validator not yet activated"
+// (transient), and cleanly classifying it requires splitting the enum variant
+// upstream. Left for a future follow-up.
+
+export function isTransientExitValidity(v: VoluntaryExitValidity): boolean {
+  switch (v) {
+    case VoluntaryExitValidity.earlyEpoch:
+    case VoluntaryExitValidity.shortTimeActive:
+    case VoluntaryExitValidity.pendingWithdrawals:
+      return true;
+    case VoluntaryExitValidity.valid:
+    case VoluntaryExitValidity.inactive:
+    case VoluntaryExitValidity.alreadyExited:
+    case VoluntaryExitValidity.invalidSignature:
+      return false;
+  }
+}
+
+// Comments for each call are present inside `validateVoluntaryExit`.
 export async function validateApiVoluntaryExit(
   chain: IBeaconChain,
   voluntaryExit: phase0.SignedVoluntaryExit
-): Promise<void> {
+): Promise<ApiVoluntaryExitResult> {
   const prioritizeBls = true;
-  return validateVoluntaryExit(chain, voluntaryExit, prioritizeBls);
+
+  if (
+    chain.opPool.hasSeenVoluntaryExit(voluntaryExit.message.validatorIndex) ||
+    chain.deferredVoluntaryExitPool.has(voluntaryExit.message.validatorIndex)
+  ) {
+    throw new VoluntaryExitError(GossipAction.IGNORE, {
+      code: VoluntaryExitErrorCode.ALREADY_EXISTS,
+    });
+  }
+
+  const state = await chain.getHeadStateAtCurrentEpoch(RegenCaller.validateApiVoluntaryExit);
+  const validity = state.getVoluntaryExitValidity(voluntaryExit, false);
+
+  if (validity !== VoluntaryExitValidity.valid && !isTransientExitValidity(validity)) {
+    throw new VoluntaryExitError(GossipAction.REJECT, {
+      code: voluntaryExitValidityToErrorCode(validity),
+    });
+  }
+
+  const signatureSet = getVoluntaryExitSignatureSet(chain.config, state, voluntaryExit);
+  if (!(await chain.bls.verifySignatureSets([signatureSet], {batchable: true, priority: prioritizeBls}))) {
+    throw new VoluntaryExitError(GossipAction.REJECT, {
+      code: VoluntaryExitErrorCode.INVALID_SIGNATURE,
+    });
+  }
+
+  if (validity !== VoluntaryExitValidity.valid) {
+    // Transient failure — signature is good, defer
+    return {status: "deferred", validity};
+  }
+
+  return {status: "published"};
 }
 
 export async function validateGossipVoluntaryExit(

package/src/execution/builder/apiClient.ts

@@ -0,0 +1,244 @@
+import {routes} from "@lodestar/api";
+import {ApiClient as BuilderApi, getClient} from "@lodestar/api/builder";
+import {ChainForkConfig} from "@lodestar/config";
+import {Logger} from "@lodestar/logger";
+import {DOMAIN_BUILDER_REQUEST_AUTH, ForkPostGloas} from "@lodestar/params";
+import {
+  ZERO_HASH,
+  computeDomain,
+  computeSigningRoot,
+  createSingleSignatureSetFromComponents,
+} from "@lodestar/state-transition";
+import {BLSPubkey, Root, SignedBeaconBlock, Slot, WithOptionalBytes, gloas, ssz} from "@lodestar/types";
+import {isValidAsciiHttpUrl, toHex, toPrintableUrl} from "@lodestar/utils";
+import type {IBlsVerifier} from "../../chain/bls/index.js";
+import {Metrics} from "../../metrics/metrics.js";
+import {IClock} from "../../util/clock.js";
+
+/**
+ * Additional duration to account for potential event loop lag which causes
+ * builder bids to be rejected even though the response was sent in time.
+ */
+const EVENT_LOOP_LAG_BUFFER = 250;
+
+/**
+ * Duration given to a builder to provide a `SignedExecutionPayloadBid` before the deadline
+ * is reached, advertised on each bid request via the `X-Timeout-Ms` header. The p2p bid is
+ * selected after the same duration, only considering bids received up to that point.
+ */
+export const BUILDER_BID_DEADLINE_MS = 500;
+
+/** Local timeout for bid requests, event loop lag must not discard bids that arrived in time */
+export const BUILDER_BID_REQUEST_TIMEOUT_MS = BUILDER_BID_DEADLINE_MS + EVENT_LOOP_LAG_BUFFER;
+
+export type BuilderApiClientOpts = {
+  /** Timeout for builder api requests, bid requests always use `BUILDER_BID_REQUEST_TIMEOUT_MS` */
+  timeout?: number;
+  // Add User-Agent header to all requests
+  userAgent?: string;
+};
+
+type BuilderUrl = string;
+
+/** Decode the SSZ URL bytes without allowing replacement characters or unsafe header values. */
+export function decodeBuilderUrl(value: Uint8Array): BuilderUrl {
+  let url: string;
+  try {
+    url = new TextDecoder("utf8", {fatal: true}).decode(value);
+  } catch {
+    throw Error("Builder url must be valid UTF-8");
+  }
+  if (!isValidAsciiHttpUrl(url)) {
+    throw Error("Invalid builder url");
+  }
+  return url;
+}
+
+export type BuilderApiBid = {
+  url: BuilderUrl;
+  entry: routes.validator.BuilderEntry;
+  signedBid: gloas.SignedExecutionPayloadBid;
+  /** Time in milliseconds from the slot start when the bid was received */
+  receivedMs: number;
+};
+
+/**
+ * External builder integration post-gloas
+ *
+ * The builder set is driven by the resolved `BuilderConfig` the validator client supplies on
+ * each block production request, clients are dialed on demand based on the entry `url`.
+ */
+export class BuilderApiClient {
+  private readonly clients = new Map<BuilderUrl, BuilderApi>();
+
+  constructor(
+    private readonly opts: BuilderApiClientOpts,
+    private readonly config: ChainForkConfig,
+    private readonly clock: IClock,
+    private readonly bls: IBlsVerifier,
+    private readonly metrics: Metrics | null = null,
+    private readonly logger?: Logger
+  ) {}
+
+  /**
+   * Fan out bid requests to the builders named by the entries, one request per unique
+   * `(url, auth.message.data)` pair. Errors and empty responses (204) are logged and filtered
+   * out so a single unresponsive builder never fails block production.
+   */
+  async getExecutionPayloadBids(
+    entries: routes.validator.BuilderEntry[],
+    slot: Slot,
+    parentHash: Root,
+    parentRoot: Root,
+    proposerPubkey: BLSPubkey
+  ): Promise<BuilderApiBid[]> {
+    const seenRequests = new Set<string>();
+    const requests: {url: BuilderUrl; entry: routes.validator.BuilderEntry}[] = [];
+
+    for (const entry of entries) {
+      const urlForLog = Buffer.from(entry.url).toString("utf8");
+      let url: BuilderUrl;
+      try {
+        url = decodeBuilderUrl(entry.url);
+      } catch {
+        this.logger?.warn("Ignoring builder entry with invalid url", {slot, url: urlForLog});
+        continue;
+      }
+
+      const requestKey = `${url}-${toHex(entry.auth.message.data)}`;
+      if (seenRequests.has(requestKey)) {
+        continue;
+      }
+      seenRequests.add(requestKey);
+
+      // The builder rejects a mismatch, an entry naming a different slot is not used for a bid request
+      if (entry.auth.message.slot !== slot) {
+        this.logger?.warn("Ignoring builder entry with auth for different slot", {
+          slot,
+          authSlot: entry.auth.message.slot,
+          builder: toPrintableUrl(url),
+        });
+        continue;
+      }
+
+      requests.push({url, entry});
+    }
+
+    // Collected in arrival order so an earlier received bid wins ties during candidate ranking
+    const bids: BuilderApiBid[] = [];
+    await Promise.all(
+      requests.map(async ({url, entry}) => {
+        this.metrics?.builderApi.bidRequests.inc();
+        try {
+          const client = await this.getOrCreateClient(url, proposerPubkey, entry.auth);
+          const res = await client.getExecutionPayloadBid(
+            {
+              slot,
+              parentHash,
+              parentRoot,
+              proposerPubkey,
+              requestAuth: entry.auth,
+              dateMilliseconds: Date.now(),
+              timeoutMs: BUILDER_BID_DEADLINE_MS,
+            },
+            {timeoutMs: BUILDER_BID_REQUEST_TIMEOUT_MS}
+          );
+          const signedBid = res.value();
+          if (signedBid === undefined) {
+            this.logger?.debug("No bid received from builder", {slot, builder: toPrintableUrl(url)});
+            return;
+          }
+          this.metrics?.builderApi.bidsReceived.inc();
+          bids.push({url, entry, signedBid, receivedMs: this.clock.msFromSlot(slot)});
+        } catch (e) {
+          this.metrics?.builderApi.bidRequestErrors.inc();
+          this.logger?.warn("Failed to get bid from builder", {slot, builder: toPrintableUrl(url)}, e as Error);
+        }
+      })
+    );
+
+    return bids;
+  }
+
+  /** Forward a proposer's builder preferences to the builder at the given url */
+  async submitBuilderPreferences(
+    url: BuilderUrl,
+    proposerPubkey: BLSPubkey,
+    request: gloas.BuilderPreferencesRequest
+  ): Promise<void> {
+    try {
+      const client = await this.getOrCreateClient(url, proposerPubkey, request.auth);
+      (await client.submitBuilderPreferences({proposerPubkey, request})).assertOk();
+      this.metrics?.builderApi.preferencesForwarded.inc({status: "success"});
+    } catch (e) {
+      this.metrics?.builderApi.preferencesForwarded.inc({status: "error"});
+      throw e;
+    }
+  }
+
+  /**
+   * Submit the signed beacon block to the builder whose bid was included. The builder is
+   * then responsible for constructing and broadcasting the corresponding
+   * `SignedExecutionPayloadEnvelope`, no further action is required by the proposer.
+   */
+  async submitSignedBeaconBlock(
+    url: BuilderUrl,
+    signedBlock: WithOptionalBytes<SignedBeaconBlock<ForkPostGloas>>
+  ): Promise<void> {
+    const client = this.clients.get(url);
+    if (client === undefined) {
+      this.metrics?.builderApi.blockSubmissions.inc({status: "error"});
+      this.logger?.warn("Ignoring signed block submission to unauthenticated builder", {url});
+      return;
+    }
+
+    try {
+      (await client.submitSignedBeaconBlock({signedBlock}, {redirect: "manual"})).assertOk();
+      this.metrics?.builderApi.blockSubmissions.inc({status: "success"});
+    } catch (e) {
+      this.metrics?.builderApi.blockSubmissions.inc({status: "error"});
+      throw e;
+    }
+  }
+
+  private async getOrCreateClient(
+    url: BuilderUrl,
+    proposerPubkey: BLSPubkey,
+    auth: gloas.SignedBuilderRequestAuth
+  ): Promise<BuilderApi> {
+    if (auth.message.data.length === 0) {
+      throw Error("Builder request auth data must not be empty");
+    }
+
+    let client = this.clients.get(url);
+    if (client === undefined) {
+      const domain = computeDomain(DOMAIN_BUILDER_REQUEST_AUTH, this.config.GENESIS_FORK_VERSION, ZERO_HASH);
+      const signingRoot = computeSigningRoot(ssz.gloas.BuilderRequestAuth, auth.message, domain);
+      const signatureSet = createSingleSignatureSetFromComponents(proposerPubkey, signingRoot, auth.signature);
+
+      let isValid = false;
+      try {
+        isValid = await this.bls.verifySignatureSets([signatureSet]);
+      } catch {
+        // Malformed signatures are invalid request authentication.
+      }
+      if (!isValid) {
+        throw Error("Invalid builder request auth");
+      }
+
+      client = getClient(
+        {
+          baseUrl: url,
+          globalInit: {
+            timeoutMs: this.opts.timeout,
+            headers: this.opts.userAgent ? {"User-Agent": this.opts.userAgent} : undefined,
+          },
+        },
+        {config: this.config, metrics: this.metrics?.builderHttpClient, logger: this.logger}
+      );
+      this.clients.set(url, client);
+      this.logger?.info("External builder registered", {url: toPrintableUrl(url)});
+    }
+    return client;
+  }
+}