@lodestar/beacon-node 1.44.0-dev.6ef8199cfa → 1.44.0-dev.762dd5f186

package/src/chain/validation/block.ts

@@ -15,12 +15,17 @@ import {BlockErrorCode, BlockGossipError, GossipAction} from "../errors/index.js
 import {IBeaconChain} from "../interface.js";
 import {RegenCaller} from "../regen/index.js";
 
+export type GossipBlockValidationResult = {
+  /** Number of skipped slots between the block and its parent (blockSlot - parentSlot - 1) */
+  skippedSlots: number;
+};
+
 export async function validateGossipBlock(
   config: ChainForkConfig,
   chain: IBeaconChain,
   signedBlock: SignedBeaconBlock,
   fork: ForkName
-): Promise<void> {
+): Promise<GossipBlockValidationResult> {
   const block = signedBlock.message;
   const blockSlot = block.slot;
   const blockEpoch = computeEpochAtSlot(blockSlot);
@@ -109,21 +114,6 @@ export async function validateGossipBlock(
     }
   }
 
-  // [IGNORE] The attestation head block is too far behind the attestation slot, causing many skip slots.
-  // This is deemed a DoS risk because we need to get the proposerShuffling. To get the shuffling we have
-  // to do a bunch of epoch transitions, the longer the distance between the parent and block,
-  // the more we have to do. epochTransitions are expensive ~750ms, so we must limit how many a
-  // single bad block can trigger
-  // Note: Ensure this check is done before calling chain.regen.getBlockSlotStat as this is the function that does various epoch transitions.
-  // Note: This validation check is not part of the spec.
-  if (chain.opts.maxSkipSlots != null && parentBlock.slot + chain.opts.maxSkipSlots < blockSlot) {
-    throw new BlockGossipError(GossipAction.IGNORE, {
-      code: BlockErrorCode.TOO_MANY_SKIPPED_SLOTS,
-      parentSlot: parentBlock.slot,
-      blockSlot,
-    });
-  }
-
   // [REJECT] The block is from a higher slot than its parent.
   if (parentBlock.slot >= blockSlot) {
     throw new BlockGossipError(GossipAction.REJECT, {
@@ -133,6 +123,10 @@ export async function validateGossipBlock(
     });
   }
 
+  // Number of skipped slots between block and parent (non-spec). Previously this gated blocks via
+  // maxSkipSlots; now the caller only observes it so legitimate post-skip blocks are no longer ignored.
+  const skippedSlots = blockSlot - parentBlock.slot - 1;
+
   // [REJECT] The length of KZG commitments is less than or equal to the limitation defined in Consensus Layer -- i.e. validate that len(body.signed_beacon_block.message.blob_kzg_commitments) <= MAX_BLOBS_PER_BLOCK
   if (isForkPostDeneb(fork) && !isForkPostGloas(fork)) {
     const blobKzgCommitmentsLen = (block as deneb.BeaconBlock).body.blobKzgCommitments.length;
@@ -247,4 +241,6 @@ export async function validateGossipBlock(
   }
 
   chain.seenBlockProposers.add(blockSlot, proposerIndex);
+
+  return {skippedSlots};
 }

package/src/chain/validation/executionPayloadBid.ts

@@ -1,12 +1,14 @@
 import {PublicKey} from "@chainsafe/blst";
+import {PAYLOAD_BUILDER_VERSION} from "@lodestar/params";
 import {
   computeEpochAtSlot,
   createSingleSignatureSetFromComponents,
   getExecutionPayloadBidSigningRoot,
   isActiveBuilder,
+  isGasLimitTargetCompatible,
   isStatePostGloas,
 } from "@lodestar/state-transition";
-import {gloas} from "@lodestar/types";
+import {ValidatorIndex, gloas} from "@lodestar/types";
 import {byteArrayEquals, toHex, toRootHex} from "@lodestar/utils";
 import {getShufflingDependentRoot} from "../../util/dependentRoot.js";
 import {ExecutionPayloadBidError, ExecutionPayloadBidErrorCode, GossipAction} from "../errors/index.js";
@@ -16,28 +18,24 @@ import {RegenCaller} from "../regen/index.js";
 export async function validateApiExecutionPayloadBid(
   chain: IBeaconChain,
   signedExecutionPayloadBid: gloas.SignedExecutionPayloadBid
-): Promise<void> {
+): Promise<{proposerIndex: ValidatorIndex}> {
   return validateExecutionPayloadBid(chain, signedExecutionPayloadBid);
 }
 
 export async function validateGossipExecutionPayloadBid(
   chain: IBeaconChain,
   signedExecutionPayloadBid: gloas.SignedExecutionPayloadBid
-): Promise<void> {
+): Promise<{proposerIndex: ValidatorIndex}> {
   return validateExecutionPayloadBid(chain, signedExecutionPayloadBid);
 }
 
 async function validateExecutionPayloadBid(
   chain: IBeaconChain,
   signedExecutionPayloadBid: gloas.SignedExecutionPayloadBid
-): Promise<void> {
+): Promise<{proposerIndex: ValidatorIndex}> {
   const bid = signedExecutionPayloadBid.message;
   const parentBlockRootHex = toRootHex(bid.parentBlockRoot);
   const parentBlockHashHex = toRootHex(bid.parentBlockHash);
-  const state = await chain.getHeadStateAtCurrentEpoch(RegenCaller.validateGossipExecutionPayloadBid);
-  if (!isStatePostGloas(state)) {
-    throw new Error(`Expected gloas+ state for execution payload bid validation, got fork=${state.forkName}`);
-  }
 
   // [IGNORE] `bid.slot` is the current slot or the next slot.
   const currentSlot = chain.clock.currentSlot;
@@ -60,6 +58,17 @@ async function validateExecutionPayloadBid(
     });
   }
 
+  // [REJECT] The bid is for a higher slot than its parent block -- i.e.
+  // validate that `bid.slot` is greater than the slot of the block with root
+  // `bid.parent_block_root`.
+  if (bid.slot <= parentBlock.slot) {
+    throw new ExecutionPayloadBidError(GossipAction.REJECT, {
+      code: ExecutionPayloadBidErrorCode.NOT_LATER_THAN_PARENT,
+      parentSlot: parentBlock.slot,
+      slot: bid.slot,
+    });
+  }
+
   // [IGNORE] A `SignedProposerPreferences` matching `bid.slot` and the bid's branch has been
   // seen — i.e. `proposal_slot == bid.slot` AND `dependent_root ==
   // get_proposer_dependent_root(parent_state, compute_epoch_at_slot(bid.slot))`.
@@ -99,9 +108,31 @@ async function validateExecutionPayloadBid(
     });
   }
 
+  // Use the bid's parent branch state for builder checks
+  const state = await chain.regen
+    .getBlockSlotState(parentBlock, bid.slot, {dontTransferCache: true}, RegenCaller.validateGossipExecutionPayloadBid)
+    .catch(() => {
+      throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
+        code: ExecutionPayloadBidErrorCode.UNKNOWN_BLOCK_ROOT,
+        parentBlockRoot: parentBlockRootHex,
+      });
+    });
+
+  if (!isStatePostGloas(state)) {
+    throw new Error(`Expected gloas+ state for execution payload bid validation, got fork=${state.forkName}`);
+  }
+
   // [REJECT] `bid.builder_index` is a valid/active builder index -- i.e.
   // `is_active_builder(state, bid.builder_index)` returns `True`.
-  const builder = state.getBuilder(bid.builderIndex);
+  let builder: gloas.Builder;
+  try {
+    builder = state.getBuilder(bid.builderIndex);
+  } catch {
+    throw new ExecutionPayloadBidError(GossipAction.REJECT, {
+      code: ExecutionPayloadBidErrorCode.BUILDER_NOT_ELIGIBLE,
+      builderIndex: bid.builderIndex,
+    });
+  }
   if (!isActiveBuilder(builder, state.finalizedCheckpoint.epoch)) {
     throw new ExecutionPayloadBidError(GossipAction.REJECT, {
       code: ExecutionPayloadBidErrorCode.BUILDER_NOT_ELIGIBLE,
@@ -109,6 +140,17 @@ async function validateExecutionPayloadBid(
     });
   }
 
+  // [REJECT] The builder version is `PAYLOAD_BUILDER_VERSION` -- i.e.
+  // `state.builders[bid.builder_index].version == PAYLOAD_BUILDER_VERSION`.
+  if (builder.version !== PAYLOAD_BUILDER_VERSION) {
+    throw new ExecutionPayloadBidError(GossipAction.REJECT, {
+      code: ExecutionPayloadBidErrorCode.INVALID_BUILDER_VERSION,
+      builderIndex: bid.builderIndex,
+      version: builder.version,
+      expectedVersion: PAYLOAD_BUILDER_VERSION,
+    });
+  }
+
   // [REJECT] `bid.execution_payment` is zero.
   if (bid.executionPayment !== 0) {
     throw new ExecutionPayloadBidError(GossipAction.REJECT, {
@@ -128,14 +170,33 @@ async function validateExecutionPayloadBid(
     });
   }
 
-  // [REJECT] `bid.gas_limit == proposer_preferences.target_gas_limit`.
-  const bidGasLimit = Number(bid.gasLimit);
-  if (bidGasLimit !== proposerPreferences.message.targetGasLimit) {
-    throw new ExecutionPayloadBidError(GossipAction.REJECT, {
+  // [IGNORE] `bid.parent_block_hash` is the block hash of a known execution payload in fork
+  // choice. Looks up the variant of `bid.parent_block_root` whose payload hash matches
+  // `bid.parent_block_hash` — works for both FULL parents (FULL variant carries the delivered
+  // payload's hash) and EMPTY parents (EMPTY/PENDING variants carry the inherited parent
+  // payload's hash, since the new block doesn't have its own payload). Variant carries the
+  // executed payload's gas_limit, which we use as `parent_gas_limit` below.
+  const parentPayloadVariant = chain.forkChoice.getBlockHexAndBlockHash(parentBlockRootHex, parentBlockHashHex);
+  if (parentPayloadVariant === null || parentPayloadVariant.executionPayloadBlockHash === null) {
+    throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
+      code: ExecutionPayloadBidErrorCode.UNKNOWN_PARENT_BLOCK_HASH,
+      parentBlockHash: parentBlockHashHex,
+    });
+  }
+
+  // [IGNORE] `is_gas_limit_target_compatible(parent_gas_limit, bid.gas_limit, target_gas_limit)`,
+  // where `parent_gas_limit` is the `gas_limit` of the parent execution payload and
+  // `target_gas_limit` is `proposer_preferences.target_gas_limit`.
+  const bidGasLimit = bid.gasLimit;
+  const parentGasLimit = parentPayloadVariant.executionPayloadGasLimit;
+  const targetGasLimit = proposerPreferences.message.targetGasLimit;
+  if (!isGasLimitTargetCompatible(parentGasLimit, bidGasLimit, targetGasLimit)) {
+    throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
       code: ExecutionPayloadBidErrorCode.PROPOSER_PREFERENCES_GAS_LIMIT_MISMATCH,
       builderIndex: bid.builderIndex,
       bidGasLimit,
-      expectedGasLimit: proposerPreferences.message.targetGasLimit,
+      parentGasLimit,
+      targetGasLimit,
     });
   }
 
@@ -166,11 +227,11 @@ async function validateExecutionPayloadBid(
   // [IGNORE] this bid is the highest value bid seen for the tuple
   // `(bid.slot, bid.parent_block_hash, bid.parent_block_root)`.
   const bestBid = chain.executionPayloadBidPool.getBestBid(bid.slot, parentBlockHashHex, parentBlockRootHex);
-  if (bestBid !== null && bestBid.value >= bid.value) {
+  if (bestBid !== null && bestBid.message.value >= bid.value) {
     throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
       code: ExecutionPayloadBidErrorCode.BID_TOO_LOW,
       bidValue: bid.value,
-      currentHighestBid: bestBid.value,
+      currentHighestBid: bestBid.message.value,
     });
   }
   // [IGNORE] `bid.value` is less or equal than the builder's excess balance --
@@ -183,9 +244,17 @@ async function validateExecutionPayloadBid(
     });
   }
 
-  // [IGNORE] `bid.parent_block_hash` is the block hash of a known execution
-  // payload in fork choice.
-  // TODO GLOAS: implement this
+  // [REJECT] `bid.prev_randao` is the correct RANDAO mix -- i.e. validate that
+  // `bid.prev_randao == get_randao_mix(parent_state, get_current_epoch(parent_state))`.
+  const randaoMix = state.getRandaoMix(computeEpochAtSlot(state.slot));
+  if (!byteArrayEquals(bid.prevRandao, randaoMix)) {
+    throw new ExecutionPayloadBidError(GossipAction.REJECT, {
+      code: ExecutionPayloadBidErrorCode.INVALID_PREV_RANDAO,
+      builderIndex: bid.builderIndex,
+      bidPrevRandao: toHex(bid.prevRandao),
+      expectedPrevRandao: toHex(randaoMix),
+    });
+  }
 
   // [REJECT] `signed_execution_payload_bid.signature` is valid with respect to the `bid.builder_index`.
   const signatureSet = createSingleSignatureSetFromComponents(
@@ -204,4 +273,6 @@ async function validateExecutionPayloadBid(
 
   // Valid
   chain.seenExecutionPayloadBids.add(bid.slot, bid.builderIndex);
+
+  return {proposerIndex: proposerPreferences.message.validatorIndex};
 }

package/src/chain/validation/executionPayloadEnvelope.ts

@@ -35,8 +35,6 @@ async function validateExecutionPayloadEnvelope(
   // [IGNORE] The envelope's block root `envelope.beacon_block_root` has been seen (via
   // gossip or non-gossip sources) (a client MAY queue payload for processing once
   // the block is retrieved).
-  // TODO GLOAS: Need to review this, we should queue the envelope for later
-  // processing if the block is not yet known, otherwise we would ignore it here
   const block = chain.forkChoice.getBlockDefaultStatus(envelope.beaconBlockRoot);
   if (block === null) {
     throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {
@@ -108,7 +106,7 @@ async function validateExecutionPayloadEnvelope(
   }
 
   // [REJECT] `hash_tree_root(envelope.execution_requests) == bid.execution_requests_root`
-  const requestsRoot = ssz.electra.ExecutionRequests.hashTreeRoot(envelope.executionRequests);
+  const requestsRoot = ssz.gloas.ExecutionRequests.hashTreeRoot(envelope.executionRequests);
   if (!byteArrayEquals(requestsRoot, payloadInput.getBid().executionRequestsRoot)) {
     throw new ExecutionPayloadEnvelopeError(GossipAction.REJECT, {
       code: ExecutionPayloadEnvelopeErrorCode.EXECUTION_REQUESTS_ROOT_MISMATCH,

package/src/chain/validation/payloadAttestationMessage.ts

@@ -8,6 +8,7 @@ import {RootHex, gloas, ssz} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {GossipAction, PayloadAttestationError, PayloadAttestationErrorCode} from "../errors/index.js";
 import {IBeaconChain} from "../index.js";
+import {RegenCaller} from "../regen/index.js";
 
 export type PayloadAttestationValidationResult = {
   attDataRootHex: RootHex;
@@ -61,22 +62,43 @@ async function validatePayloadAttestationMessage(
   // [IGNORE] The message's block `data.beacon_block_root` has been seen (via
   // gossip or non-gossip sources) (a client MAY queue attestation for processing
   // once the block is retrieved. Note a client might want to request payload after).
-  if (!chain.forkChoice.hasBlock(data.beaconBlockRoot)) {
+  const block = chain.forkChoice.getBlockDefaultStatus(data.beaconBlockRoot);
+  if (!block) {
     throw new PayloadAttestationError(GossipAction.IGNORE, {
       code: PayloadAttestationErrorCode.UNKNOWN_BLOCK_ROOT,
       blockRoot: toRootHex(data.beaconBlockRoot),
     });
   }
 
-  const state = chain.getHeadState();
-  if (!isStatePostGloas(state)) {
-    throw new Error(`Expected gloas+ state for payload attestation validation, got fork=${state.forkName}`);
+  // [IGNORE] The block referenced by `data.beacon_block_root` is at slot `data.slot`,
+  // i.e. the block has `block.slot == data.slot`.
+  if (block.slot !== data.slot) {
+    throw new PayloadAttestationError(GossipAction.IGNORE, {
+      code: PayloadAttestationErrorCode.INVALID_BLOCK_SLOT,
+      blockRoot: toRootHex(data.beaconBlockRoot),
+      blockSlot: block.slot,
+      slot: data.slot,
+    });
   }
 
   // [REJECT] The message's block `data.beacon_block_root` passes validation.
   // TODO GLOAS: implement this. Technically if we cannot get proto block from fork choice,
   // it is possible that the block didn't pass the validation
 
+  // Use the referenced block's branch state for the PTC committee check
+  const state = await chain.regen
+    .getBlockSlotState(block, data.slot, {dontTransferCache: true}, RegenCaller.validateGossipPayloadAttestationMessage)
+    .catch(() => {
+      throw new PayloadAttestationError(GossipAction.IGNORE, {
+        code: PayloadAttestationErrorCode.UNKNOWN_BLOCK_ROOT,
+        blockRoot: toRootHex(data.beaconBlockRoot),
+      });
+    });
+
+  if (!isStatePostGloas(state)) {
+    throw new Error(`Expected gloas+ state for payload attestation validation, got fork=${state.forkName}`);
+  }
+
   // [REJECT] The message's validator index is within the payload committee in
   // `get_ptc(state, data.slot)`. The `state` is the head state corresponding to
   // processing the block up to the current slot as determined by the fork choice.

package/src/chain/validatorMonitor.ts

@@ -66,6 +66,7 @@ export type ValidatorMonitor = {
     delaySec: Seconds,
     envelope: gloas.SignedExecutionPayloadEnvelope
   ): void;
+  registerExecutionPayloadBid(src: OpSource, proposerIndex: ValidatorIndex, bid: gloas.ExecutionPayloadBid): void;
   registerImportedBlock(block: BeaconBlock, data: {proposerBalanceDelta: number}): void;
   onPoolSubmitUnaggregatedAttestation(
     seenTimestampSec: number,
@@ -459,6 +460,23 @@ export function createValidatorMonitor(
       // TODO GLOAS: implement execution payload envelope monitoring
     },
 
+    registerExecutionPayloadBid(src, proposerIndex, bid) {
+      if (!validators.has(proposerIndex)) {
+        return;
+      }
+      log("Received an execution payload bid for monitored proposer", {
+        slot: bid.slot,
+        proposerIndex,
+        src,
+        builderIndex: bid.builderIndex,
+        gasLimit: bid.gasLimit,
+        value: bid.value.toString(),
+        parentBlockRoot: toRootHex(bid.parentBlockRoot),
+        parentBlockHash: toRootHex(bid.parentBlockHash),
+        blockHash: toRootHex(bid.blockHash),
+      });
+    },
+
     registerImportedBlock(block, {proposerBalanceDelta}) {
       const validator = validators.get(block.proposerIndex);
       if (validator) {

package/src/execution/builder/index.ts

@@ -1,11 +1,8 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {Logger} from "@lodestar/logger";
 import {Metrics} from "../../metrics/metrics.js";
-import {IExecutionBuilder} from "./interface.js";
-
-export {getExpectedGasLimit} from "./utils.js";
-
 import {ExecutionBuilderHttp, ExecutionBuilderHttpOpts, defaultExecutionBuilderHttpOpts} from "./http.js";
+import {IExecutionBuilder} from "./interface.js";
 
 export {ExecutionBuilderHttp, defaultExecutionBuilderHttpOpts};
 

package/src/execution/engine/http.ts

@@ -244,7 +244,7 @@ export class ExecutionEngineHttp implements IExecutionEngine {
         if (executionRequests === undefined) {
           throw Error(`executionRequests required in notifyNewPayload for fork=${fork}`);
         }
-        const serializedExecutionRequests = serializeExecutionRequests(executionRequests);
+        const serializedExecutionRequests = serializeExecutionRequests(fork, executionRequests);
         engineRequest = {
           method: ForkSeq[fork] >= ForkSeq.gloas ? "engine_newPayloadV5" : "engine_newPayloadV4",
           params: [

package/src/execution/engine/interface.ts

@@ -1,5 +1,7 @@
 import {routes} from "@lodestar/api";
 import {
+  BUILDER_DEPOSIT_REQUEST_TYPE,
+  BUILDER_EXIT_REQUEST_TYPE,
   CONSOLIDATION_REQUEST_TYPE,
   DEPOSIT_REQUEST_TYPE,
   ForkName,
@@ -51,10 +53,18 @@ export enum ExecutionEngineState {
 export type ExecutionRequestType =
   | typeof DEPOSIT_REQUEST_TYPE
   | typeof WITHDRAWAL_REQUEST_TYPE
-  | typeof CONSOLIDATION_REQUEST_TYPE;
+  | typeof CONSOLIDATION_REQUEST_TYPE
+  | typeof BUILDER_DEPOSIT_REQUEST_TYPE
+  | typeof BUILDER_EXIT_REQUEST_TYPE;
 
 export function isExecutionRequestType(type: number): type is ExecutionRequestType {
-  return type === DEPOSIT_REQUEST_TYPE || type === WITHDRAWAL_REQUEST_TYPE || type === CONSOLIDATION_REQUEST_TYPE;
+  return (
+    type === DEPOSIT_REQUEST_TYPE ||
+    type === WITHDRAWAL_REQUEST_TYPE ||
+    type === CONSOLIDATION_REQUEST_TYPE ||
+    type === BUILDER_DEPOSIT_REQUEST_TYPE ||
+    type === BUILDER_EXIT_REQUEST_TYPE
+  );
 }
 
 export type ExecutePayloadResponse =

package/src/execution/engine/mock.ts

@@ -393,11 +393,12 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
           blobs,
           proofs,
         }),
-        executionRequests: serializeExecutionRequests({
-          deposits: ssz.electra.DepositRequests.defaultValue(),
-          withdrawals: ssz.electra.WithdrawalRequests.defaultValue(),
-          consolidations: ssz.electra.ConsolidationRequests.defaultValue(),
-        }),
+        executionRequests: serializeExecutionRequests(
+          fork,
+          ForkSeq[fork] >= ForkSeq.gloas
+            ? ssz.gloas.ExecutionRequests.defaultValue()
+            : ssz.electra.ExecutionRequests.defaultValue()
+        ),
       });
 
       // IF the payload is deemed VALID and the build process has begun

package/src/execution/engine/types.ts

@@ -1,4 +1,6 @@
 import {
+  BUILDER_DEPOSIT_REQUEST_TYPE,
+  BUILDER_EXIT_REQUEST_TYPE,
   BYTES_PER_FIELD_ELEMENT,
   BYTES_PER_LOGS_BLOOM,
   CELLS_PER_EXT_BLOB,
@@ -205,16 +207,27 @@ export type WithdrawalRpc = {
 };
 
 /**
- * ExecutionRequestsRpc only holds at most 3 elements and no repeated type:
- * - ssz'ed DepositRequests
- * - ssz'ed WithdrawalRequests
- * - ssz'ed ConsolidationRequests
+ * ExecutionRequestsRpc holds at most 5 elements and no repeated type, ordered by
+ * the single-byte request type prefix:
+ * - ssz'ed DepositRequests          (0x00)
+ * - ssz'ed WithdrawalRequests       (0x01)
+ * - ssz'ed ConsolidationRequests    (0x02)
+ * - ssz'ed BuilderDepositRequests   (0x03)
+ * - ssz'ed BuilderExitRequests      (0x04)
  */
-export type ExecutionRequestsRpc = (DepositRequestsRpc | WithdrawalRequestsRpc | ConsolidationRequestsRpc)[];
+export type ExecutionRequestsRpc = (
+  | DepositRequestsRpc
+  | WithdrawalRequestsRpc
+  | ConsolidationRequestsRpc
+  | BuilderDepositRequestsRpc
+  | BuilderExitRequestsRpc
+)[];
 
 export type DepositRequestsRpc = DATA;
 export type WithdrawalRequestsRpc = DATA;
 export type ConsolidationRequestsRpc = DATA;
+export type BuilderDepositRequestsRpc = DATA;
+export type BuilderExitRequestsRpc = DATA;
 
 export type BlobAndProofRpc = {
   blob: DATA;
@@ -339,7 +352,7 @@ export function parseExecutionPayload(
     data = response.executionPayload;
     blobsBundle = response.blobsBundle ? parseBlobsBundle(response.blobsBundle) : undefined;
     executionRequests = response.executionRequests
-      ? deserializeExecutionRequests(response.executionRequests)
+      ? deserializeExecutionRequests(fork, response.executionRequests)
       : undefined;
     shouldOverrideBuilder = response.shouldOverrideBuilder ?? false;
   } else {
@@ -526,13 +539,36 @@ function deserializeConsolidationRequests(serialized: ConsolidationRequestsRpc):
   return ssz.electra.ConsolidationRequests.deserialize(dataToBytes(serialized, null));
 }
 
+function serializeBuilderDepositRequests(
+  builderDepositRequests: gloas.BuilderDepositRequests
+): BuilderDepositRequestsRpc {
+  const requestsBytes = ssz.gloas.BuilderDepositRequests.serialize(builderDepositRequests);
+  return bytesToData(prefixRequests(requestsBytes, BUILDER_DEPOSIT_REQUEST_TYPE));
+}
+
+function deserializeBuilderDepositRequests(serialized: BuilderDepositRequestsRpc): gloas.BuilderDepositRequests {
+  return ssz.gloas.BuilderDepositRequests.deserialize(dataToBytes(serialized, null));
+}
+
+function serializeBuilderExitRequests(builderExitRequests: gloas.BuilderExitRequests): BuilderExitRequestsRpc {
+  const requestsBytes = ssz.gloas.BuilderExitRequests.serialize(builderExitRequests);
+  return bytesToData(prefixRequests(requestsBytes, BUILDER_EXIT_REQUEST_TYPE));
+}
+
+function deserializeBuilderExitRequests(serialized: BuilderExitRequestsRpc): gloas.BuilderExitRequests {
+  return ssz.gloas.BuilderExitRequests.deserialize(dataToBytes(serialized, null));
+}
+
 /**
  * This is identical to get_execution_requests_list in
  * https://github.com/ethereum/consensus-specs/blob/v1.5.0-alpha.8/specs/electra/beacon-chain.md#new-get_execution_requests_list
+ *
+ * Gloas extends the list with builder deposits (0x03) and builder exits (0x04) per
+ * https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.11/specs/gloas/beacon-chain.md#modified-get_execution_requests_list
  */
-export function serializeExecutionRequests(executionRequests: ExecutionRequests): ExecutionRequestsRpc {
+export function serializeExecutionRequests(fork: ForkName, executionRequests: ExecutionRequests): ExecutionRequestsRpc {
   const {deposits, withdrawals, consolidations} = executionRequests;
-  const result = [];
+  const result: ExecutionRequestsRpc = [];
 
   if (deposits.length !== 0) {
     result.push(serializeDepositRequests(deposits));
@@ -546,15 +582,26 @@ export function serializeExecutionRequests(executionRequests: ExecutionRequests)
     result.push(serializeConsolidationRequests(consolidations));
   }
 
+  if (ForkSeq[fork] >= ForkSeq.gloas) {
+    const {builderDeposits, builderExits} = executionRequests as gloas.ExecutionRequests;
+
+    if (builderDeposits.length !== 0) {
+      result.push(serializeBuilderDepositRequests(builderDeposits));
+    }
+
+    if (builderExits.length !== 0) {
+      result.push(serializeBuilderExitRequests(builderExits));
+    }
+  }
+
   return result;
 }
 
-export function deserializeExecutionRequests(serialized: ExecutionRequestsRpc): ExecutionRequests {
-  const result: ExecutionRequests = {
-    deposits: [],
-    withdrawals: [],
-    consolidations: [],
-  };
+export function deserializeExecutionRequests(fork: ForkName, serialized: ExecutionRequestsRpc): ExecutionRequests {
+  const result: ExecutionRequests =
+    ForkSeq[fork] >= ForkSeq.gloas
+      ? {deposits: [], withdrawals: [], consolidations: [], builderDeposits: [], builderExits: []}
+      : {deposits: [], withdrawals: [], consolidations: []};
 
   if (serialized.length === 0) {
     return result;
@@ -601,6 +648,20 @@ export function deserializeExecutionRequests(serialized: ExecutionRequestsRpc):
         result.consolidations = deserializeConsolidationRequests(requests);
         break;
       }
+      case BUILDER_DEPOSIT_REQUEST_TYPE: {
+        if (ForkSeq[fork] < ForkSeq.gloas) {
+          throw Error(`Builder deposit request is not supported pre-gloas fork=${fork}`);
+        }
+        (result as gloas.ExecutionRequests).builderDeposits = deserializeBuilderDepositRequests(requests);
+        break;
+      }
+      case BUILDER_EXIT_REQUEST_TYPE: {
+        if (ForkSeq[fork] < ForkSeq.gloas) {
+          throw Error(`Builder exit request is not supported pre-gloas fork=${fork}`);
+        }
+        (result as gloas.ExecutionRequests).builderExits = deserializeBuilderExitRequests(requests);
+        break;
+      }
     }
     prevRequestType = currentRequestType;
   }

package/src/metrics/metrics/lodestar.ts

@@ -610,6 +610,11 @@ export function createLodestarMetrics(
         help: "The origination source of one of the BlockInputSync triggers",
         labelNames: ["source"],
       }),
+      payloadSource: register.counter<{source: BlockInputSource}>({
+        name: "lodestar_payload_input_sync_source_total",
+        help: "Count of payload (execution payload envelope) sync triggers, labeled by their source",
+        labelNames: ["source"],
+      }),
       pendingBlocks: register.gauge({
         name: "lodestar_sync_unknown_block_pending_blocks_size",
         help: "Current size of UnknownBlockSync pending blocks cache",
@@ -861,6 +866,12 @@ export function createLodestarMetrics(
         labelNames: ["numBlobs"],
       }),
 
+      skippedSlots: register.histogram({
+        name: "lodestar_gossip_block_skipped_slots",
+        help: "Number of skipped slots between a gossip block and its parent (blockSlot - parentSlot - 1)",
+        buckets: [0, 1, 2, 4, 8, 16, 32],
+      }),
+
       processBlockErrors: register.gauge<{error: BlockErrorCode | "NOT_BLOCK_ERROR"}>({
         name: "lodestar_gossip_block_process_block_errors",
         help: "Count of errors, by error type, while processing blocks",
@@ -987,10 +998,11 @@ export function createLodestarMetrics(
       }),
     },
     importPayload: {
-      bySource: register.gauge<{source: PayloadEnvelopeInputSource}>({
-        name: "lodestar_import_payload_by_source_total",
-        help: "Total number of imported execution payload envelopes by source",
+      elapsedTimeTillImported: register.histogram<{source: PayloadEnvelopeInputSource}>({
+        name: "lodestar_import_payload_elapsed_time_till_imported_seconds",
+        help: "Time elapsed between slot time and the time execution payload envelope is imported (added to fork choice)",
         labelNames: ["source"],
+        buckets: [1, 2, 3, 6, 9, 12],
       }),
       columnsBySource: register.gauge<{source: PayloadEnvelopeInputSource}>({
         name: "lodestar_import_payload_columns_by_source_total",

package/src/network/interface.ts

@@ -113,6 +113,7 @@ export interface INetwork extends INetworkCorePublic {
   publishLightClientFinalityUpdate(update: LightClientFinalityUpdate): Promise<number>;
   publishLightClientOptimisticUpdate(update: LightClientOptimisticUpdate): Promise<number>;
   publishSignedExecutionPayloadEnvelope(signedEnvelope: gloas.SignedExecutionPayloadEnvelope): Promise<number>;
+  publishSignedExecutionPayloadBid(signedBid: gloas.SignedExecutionPayloadBid): Promise<number>;
   publishPayloadAttestationMessage(payloadAttestationMessage: gloas.PayloadAttestationMessage): Promise<number>;
   publishProposerPreferences(signedProposerPreferences: gloas.SignedProposerPreferences): Promise<number>;
 

package/src/network/network.ts

@@ -515,6 +515,17 @@ export class Network implements INetwork {
     );
   }
 
+  async publishSignedExecutionPayloadBid(signedBid: gloas.SignedExecutionPayloadBid): Promise<number> {
+    const epoch = computeEpochAtSlot(signedBid.message.slot);
+    const boundary = this.config.getForkBoundaryAtEpoch(epoch);
+
+    return this.publishGossip<GossipType.execution_payload_bid>(
+      {type: GossipType.execution_payload_bid, boundary},
+      signedBid,
+      {ignoreDuplicatePublishError: true}
+    );
+  }
+
   async publishPayloadAttestationMessage(payloadAttestationMessage: gloas.PayloadAttestationMessage): Promise<number> {
     const epoch = computeEpochAtSlot(payloadAttestationMessage.data.slot);
     const boundary = this.config.getForkBoundaryAtEpoch(epoch);