@lodestar/beacon-node 1.41.0-dev.279c11da24 → 1.41.0-dev.49f680d9f0

package/src/chain/archiveStore/archiveStore.ts

@@ -1,5 +1,6 @@
 import {CheckpointWithHex} from "@lodestar/fork-choice";
 import {LoggerNode} from "@lodestar/logger/node";
+import {ForkSeq} from "@lodestar/params";
 import {Checkpoint} from "@lodestar/types/phase0";
 import {callFnWhenAwait} from "@lodestar/utils";
 import {IBeaconDb} from "../../db/index.js";
@@ -13,6 +14,7 @@ import {HistoricalStateRegen} from "./historicalState/historicalStateRegen.js";
 import {ArchiveMode, ArchiveStoreOpts, StateArchiveStrategy} from "./interface.js";
 import {FrequencyStateArchiveStrategy} from "./strategies/frequencyStateArchiveStrategy.js";
 import {archiveBlocks} from "./utils/archiveBlocks.js";
+import {archiveExecutionPayloadEnvelopes} from "./utils/archivePayloads.js";
 import {pruneHistory} from "./utils/pruneHistory.js";
 import {updateBackfillRange} from "./utils/updateBackfillRange.js";
 
@@ -27,6 +29,7 @@ type ArchiveStoreInitOpts = ArchiveStoreOpts & {dbName: string; anchorState: {fi
 
 export enum ArchiveStoreTask {
   ArchiveBlocks = "archive_blocks",
+  ArchivePayloads = "archive_payloads",
   PruneHistory = "prune_history",
   OnFinalizedCheckpoint = "on_finalized_checkpoint",
   MaybeArchiveState = "maybe_archive_state",
@@ -189,6 +192,7 @@ export class ArchiveStore {
   private processFinalizedCheckpoint = async (finalized: CheckpointWithHex): Promise<void> => {
     try {
       const finalizedEpoch = finalized.epoch;
+      const finalizedFork = this.chain.config.getForkSeqAtEpoch(finalizedEpoch);
       this.logger.verbose("Start processing finalized checkpoint", {epoch: finalizedEpoch, rootHex: finalized.rootHex});
 
       let timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
@@ -206,6 +210,12 @@ export class ArchiveStore {
       );
       timer?.({source: ArchiveStoreTask.ArchiveBlocks});
 
+      if (finalizedFork >= ForkSeq.gloas) {
+        timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
+        await archiveExecutionPayloadEnvelopes(this.chain, finalized);
+        timer?.({source: ArchiveStoreTask.ArchivePayloads});
+      }
+
       if (this.opts.pruneHistory) {
         timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
         await pruneHistory(

package/src/chain/archiveStore/utils/archivePayloads.ts

@@ -0,0 +1,15 @@
+import {CheckpointWithHex} from "@lodestar/fork-choice";
+import {IBeaconChain} from "../../interface.js";
+
+/**
+ * Archives execution payload envelopes from hot DB to archive DB after finalization.
+ */
+export async function archiveExecutionPayloadEnvelopes(
+  chain: IBeaconChain,
+  _finalized: CheckpointWithHex
+): Promise<void> {
+  const finalizedBlock = chain.forkChoice.getFinalizedBlock();
+  if (!finalizedBlock) return;
+
+  // TODO GLOAS: Implement payload envelope archival after epbs fork choice changes are merged
+}

package/src/chain/blocks/importBlock.ts

@@ -101,9 +101,6 @@ export async function importBlock(
     }
   });
 
-  // Without forcefully clearing this cache, we would rely on WeakMap to evict memory which is not reliable
-  this.serializedCache.clear();
-
   // 2. Import block to fork choice
 
   // Should compute checkpoint balances before forkchoice.onBlock

package/src/chain/blocks/index.ts

@@ -1,6 +1,7 @@
 import {SignedBeaconBlock} from "@lodestar/types";
 import {isErrorAborted, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
+import {nextEventLoop} from "../../util/eventLoop.js";
 import {JobItemQueue, isQueueErrorAborted} from "../../util/queue/index.js";
 import type {BeaconChain} from "../chain.js";
 import {BlockError, BlockErrorCode, isBlockErrorAborted} from "../errors/index.js";
@@ -100,9 +101,9 @@ export async function processBlocks(
     );
 
     for (const fullyVerifiedBlock of fullyVerifiedBlocks) {
-      // No need to sleep(0) here since `importBlock` includes a disk write
       // TODO: Consider batching importBlock too if it takes significant time
       await importBlock.call(this, fullyVerifiedBlock, opts);
+      await nextEventLoop();
     }
   } catch (e) {
     if (isErrorAborted(e) || isQueueErrorAborted(e) || isBlockErrorAborted(e)) {

package/src/chain/blocks/writeBlockInputToDb.ts

@@ -125,6 +125,9 @@ export async function persistBlockInputs(this: BeaconChain, blockInputs: IBlockI
       for (const blockInput of blockInputs) {
         this.seenBlockInputCache.prune(blockInput.blockRootHex);
       }
+      // Without forcefully clearing this cache, we would rely on WeakMap to evict memory which is not reliable.
+      // Clear here (after the DB write) so that writeBlockInputToDb can still use the cached serialized bytes.
+      this.serializedCache.clear();
       if (blockInputs.length === 1) {
         this.logger.debug("Pruned block input", {
           slot: blockInputs[0].slot,

package/src/chain/chain.ts

@@ -5,11 +5,20 @@ import {CompositeTypeAny, TreeView, Type} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
 import {CheckpointWithHex, IForkChoice, ProtoBlock, UpdateHeadOpt} from "@lodestar/fork-choice";
 import {LoggerNode} from "@lodestar/logger/node";
-import {EFFECTIVE_BALANCE_INCREMENT, GENESIS_SLOT, SLOTS_PER_EPOCH, isForkPostElectra} from "@lodestar/params";
+import {
+  BUILDER_INDEX_SELF_BUILD,
+  EFFECTIVE_BALANCE_INCREMENT,
+  ForkPostFulu,
+  GENESIS_SLOT,
+  SLOTS_PER_EPOCH,
+  isForkPostElectra,
+  isForkPostGloas,
+} from "@lodestar/params";
 import {
   BeaconStateAllForks,
   BeaconStateElectra,
   CachedBeaconStateAllForks,
+  CachedBeaconStateGloas,
   EffectiveBalanceIncrements,
   EpochShuffling,
   Index2PubkeyCache,
@@ -28,6 +37,7 @@ import {
   BeaconBlock,
   BlindedBeaconBlock,
   BlindedBeaconBlockBody,
+  DataColumnSidecars,
   Epoch,
   Root,
   RootHex,
@@ -38,7 +48,7 @@ import {
   ValidatorIndex,
   Wei,
   deneb,
-  fulu,
+  gloas,
   isBlindedBeaconBlock,
   phase0,
   rewards,
@@ -87,8 +97,8 @@ import {
 } from "./opPools/index.js";
 import {IChainOptions} from "./options.js";
 import {PrepareNextSlotScheduler} from "./prepareNextSlot.js";
-import {computeNewStateRoot} from "./produceBlock/computeNewStateRoot.js";
-import {AssembledBlockType, BlockType, ProduceResult} from "./produceBlock/index.js";
+import {computeEnvelopeStateRoot, computeNewStateRoot} from "./produceBlock/computeNewStateRoot.js";
+import {AssembledBlockType, BlockType, ProduceFullGloas, ProduceResult} from "./produceBlock/index.js";
 import {BlockAttributes, produceBlockBody, produceCommonBlockBody} from "./produceBlock/produceBlockBody.js";
 import {QueuedStateRegenerator, RegenCaller} from "./regen/index.js";
 import {ReprocessController} from "./reprocess.js";
@@ -808,7 +818,7 @@ export class BeaconChain implements IBeaconChain {
     return null;
   }
 
-  async getDataColumnSidecars(blockSlot: Slot, blockRootHex: string): Promise<fulu.DataColumnSidecars> {
+  async getDataColumnSidecars(blockSlot: Slot, blockRootHex: string): Promise<DataColumnSidecars> {
     const blockInput = this.seenBlockInputCache.get(blockRootHex);
     if (blockInput) {
       if (!isBlockInputColumns(blockInput)) {
@@ -818,10 +828,10 @@ export class BeaconChain implements IBeaconChain {
     }
     const sidecarsUnfinalized = await this.db.dataColumnSidecar.values(fromHex(blockRootHex));
     if (sidecarsUnfinalized.length > 0) {
-      return sidecarsUnfinalized;
+      return sidecarsUnfinalized as DataColumnSidecars;
     }
     const sidecarsFinalized = await this.db.dataColumnSidecarArchive.values(blockSlot);
-    return sidecarsFinalized;
+    return sidecarsFinalized as DataColumnSidecars;
   }
 
   async getSerializedDataColumnSidecars(
@@ -843,7 +853,7 @@ export class BeaconChain implements IBeaconChain {
         if (serialized) {
           return serialized;
         }
-        return ssz.fulu.DataColumnSidecar.serialize(sidecar);
+        return sszTypesFor(blockInput.forkName as ForkPostFulu).DataColumnSidecar.serialize(sidecar);
       });
     }
     const sidecarsUnfinalized = await this.db.dataColumnSidecar.getManyBinary(fromHex(blockRootHex), indices);
@@ -902,6 +912,7 @@ export class BeaconChain implements IBeaconChain {
     consensusBlockValue: Wei;
     shouldOverrideBuilder?: boolean;
   }> {
+    const fork = this.config.getForkName(slot);
     const state = await this.regen.getBlockSlotState(
       parentBlock,
       slot,
@@ -930,7 +941,7 @@ export class BeaconChain implements IBeaconChain {
     // The hashtree root computed here for debug log will get cached and hence won't introduce additional delays
     const bodyRoot =
       produceResult.type === BlockType.Full
-        ? this.config.getForkTypes(slot).BeaconBlockBody.hashTreeRoot(body)
+        ? sszTypesFor(fork).BeaconBlockBody.hashTreeRoot(body)
         : this.config
             .getPostBellatrixForkTypes(slot)
             .BlindedBeaconBlockBody.hashTreeRoot(body as BlindedBeaconBlockBody);
@@ -948,14 +959,33 @@ export class BeaconChain implements IBeaconChain {
       body,
     } as AssembledBlockType<T>;
 
-    const {newStateRoot, proposerReward} = computeNewStateRoot(this.metrics, state, block);
+    const {newStateRoot, proposerReward, postState} = computeNewStateRoot(this.metrics, state, block);
     block.stateRoot = newStateRoot;
     const blockRoot =
       produceResult.type === BlockType.Full
-        ? this.config.getForkTypes(slot).BeaconBlock.hashTreeRoot(block)
+        ? sszTypesFor(fork).BeaconBlock.hashTreeRoot(block)
         : this.config.getPostBellatrixForkTypes(slot).BlindedBeaconBlock.hashTreeRoot(block as BlindedBeaconBlock);
     const blockRootHex = toRootHex(blockRoot);
 
+    if (isForkPostGloas(fork)) {
+      // TODO GLOAS: we should retire BlockType post-gloas, may need a new enum for self vs non-self built
+      if (produceResult.type !== BlockType.Full) {
+        throw Error(`Unexpected block type=${produceResult.type} for post-gloas fork=${fork}`);
+      }
+
+      const gloasResult = produceResult as ProduceFullGloas;
+      const envelope: gloas.ExecutionPayloadEnvelope = {
+        payload: gloasResult.executionPayload,
+        executionRequests: gloasResult.executionRequests,
+        builderIndex: BUILDER_INDEX_SELF_BUILD,
+        beaconBlockRoot: blockRoot,
+        slot,
+        stateRoot: ZERO_HASH,
+      };
+      const envelopeStateRoot = computeEnvelopeStateRoot(this.metrics, postState as CachedBeaconStateGloas, envelope);
+      gloasResult.envelopeStateRoot = envelopeStateRoot;
+    }
+
     // Track the produced block for consensus broadcast validations, later validation, etc.
     this.blockProductionCache.set(blockRootHex, produceResult);
     this.metrics?.blockProductionCacheSize.set(this.blockProductionCache.size);

package/src/chain/emitter.ts

@@ -3,7 +3,7 @@ import {StrictEventEmitter} from "strict-event-emitter-types";
 import {routes} from "@lodestar/api";
 import {CheckpointWithHex} from "@lodestar/fork-choice";
 import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {RootHex, deneb, fulu, phase0} from "@lodestar/types";
+import {DataColumnSidecars, RootHex, deneb, phase0} from "@lodestar/types";
 import {PeerIdStr} from "../util/peerId.js";
 import {BlockInputSource, IBlockInput} from "./blocks/blockInput/types.js";
 
@@ -88,7 +88,7 @@ export type IChainEvents = ApiEvents & {
 
   [ChainEvent.updateTargetCustodyGroupCount]: (targetGroupCount: number) => void;
 
-  [ChainEvent.publishDataColumns]: (sidecars: fulu.DataColumnSidecar[]) => void;
+  [ChainEvent.publishDataColumns]: (sidecars: DataColumnSidecars) => void;
 
   [ChainEvent.publishBlobSidecars]: (sidecars: deneb.BlobSidecar[]) => void;
 

package/src/chain/interface.ts

@@ -11,6 +11,7 @@ import {
 import {
   BeaconBlock,
   BlindedBeaconBlock,
+  DataColumnSidecars,
   Epoch,
   Root,
   RootHex,
@@ -23,7 +24,6 @@ import {
   altair,
   capella,
   deneb,
-  fulu,
   phase0,
   rewards,
 } from "@lodestar/types";
@@ -224,7 +224,7 @@ export interface IBeaconChain {
   ): Promise<{block: SignedBeaconBlock; executionOptimistic: boolean; finalized: boolean} | null>;
   getBlobSidecars(blockSlot: Slot, blockRootHex: string): Promise<deneb.BlobSidecars | null>;
   getSerializedBlobSidecars(blockSlot: Slot, blockRootHex: string): Promise<Uint8Array | null>;
-  getDataColumnSidecars(blockSlot: Slot, blockRootHex: string): Promise<fulu.DataColumnSidecars>;
+  getDataColumnSidecars(blockSlot: Slot, blockRootHex: string): Promise<DataColumnSidecars>;
   getSerializedDataColumnSidecars(
     blockSlot: Slot,
     blockRootHex: string,

package/src/chain/lightClient/index.ts

@@ -355,7 +355,10 @@ export class LightClientServer {
     // Signature data
     const update = await this.db.bestLightClientUpdate.get(period);
     if (!update) {
-      throw Error(`No partialUpdate available for period ${period}`);
+      throw new LightClientServerError(
+        {code: LightClientServerErrorCode.RESOURCE_UNAVAILABLE},
+        `No partialUpdate available for period ${period}`
+      );
     }
     return update;
   }

package/src/chain/options.ts

@@ -27,6 +27,7 @@ export type IChainOptions = BlockProcessOpts &
     blsVerifyAllMainThread?: boolean;
     blsVerifyAllMultiThread?: boolean;
     blacklistedBlocks?: string[];
+    // TODO GLOAS: add similar option for execution payload envelopes?
     persistProducedBlocks?: boolean;
     persistInvalidSszObjects?: boolean;
     persistInvalidSszObjectsDir?: string;

package/src/chain/prepareNextSlot.ts

@@ -1,14 +1,14 @@
 import {routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
 import {getSafeExecutionBlockHash} from "@lodestar/fork-choice";
-import {ForkPostBellatrix, ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {ForkPostBellatrix, ForkSeq, SLOTS_PER_EPOCH, isForkPostBellatrix} from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
   CachedBeaconStateExecutions,
+  CachedBeaconStateGloas,
   StateHashTreeRootSource,
   computeEpochAtSlot,
   computeTimeAtSlot,
-  isExecutionStateType,
 } from "@lodestar/state-transition";
 import {Slot} from "@lodestar/types";
 import {Logger, fromHex, isErrorAborted, sleep} from "@lodestar/utils";
@@ -120,10 +120,10 @@ export class PrepareNextSlotScheduler {
         RegenCaller.precomputeEpoch
       );
 
-      if (isExecutionStateType(prepareState)) {
+      if (isForkPostBellatrix(fork)) {
         const proposerIndex = prepareState.epochCtx.getBeaconProposer(prepareSlot);
         const feeRecipient = this.chain.beaconProposerCache.get(proposerIndex);
-        let updatedPrepareState = prepareState;
+        let updatedPrepareState = prepareState as CachedBeaconStateExecutions | CachedBeaconStateGloas;
         let updatedHeadRoot = headRoot;
 
         if (feeRecipient) {
@@ -146,7 +146,7 @@ export class PrepareNextSlotScheduler {
               // only transfer cache if epoch transition because that's the state we will use to stateTransition() the 1st block of epoch
               {dontTransferCache: !isEpochTransition},
               RegenCaller.predictProposerHead
-            )) as CachedBeaconStateExecutions;
+            )) as CachedBeaconStateExecutions | CachedBeaconStateGloas;
             updatedHeadRoot = proposerHeadRoot;
           }
 

package/src/chain/produceBlock/computeNewStateRoot.ts

@@ -1,11 +1,14 @@
 import {
   CachedBeaconStateAllForks,
+  CachedBeaconStateGloas,
   DataAvailabilityStatus,
   ExecutionPayloadStatus,
+  G2_POINT_AT_INFINITY,
   StateHashTreeRootSource,
   stateTransition,
 } from "@lodestar/state-transition";
-import {BeaconBlock, BlindedBeaconBlock, Gwei, Root} from "@lodestar/types";
+import {processExecutionPayloadEnvelope} from "@lodestar/state-transition/block";
+import {BeaconBlock, BlindedBeaconBlock, Gwei, Root, gloas} from "@lodestar/types";
 import {ZERO_HASH} from "../../constants/index.js";
 import {Metrics} from "../../metrics/index.js";
 
@@ -18,7 +21,7 @@ export function computeNewStateRoot(
   metrics: Metrics | null,
   state: CachedBeaconStateAllForks,
   block: BeaconBlock | BlindedBeaconBlock
-): {newStateRoot: Root; proposerReward: Gwei} {
+): {newStateRoot: Root; proposerReward: Gwei; postState: CachedBeaconStateAllForks} {
   // Set signature to zero to re-use stateTransition() function which requires the SignedBeaconBlock type
   const blockEmptySig = {message: block, signature: ZERO_HASH};
 
@@ -51,5 +54,34 @@ export function computeNewStateRoot(
   const newStateRoot = postState.hashTreeRoot();
   hashTreeRootTimer?.();
 
-  return {newStateRoot, proposerReward};
+  return {newStateRoot, proposerReward, postState};
+}
+
+/**
+ * Compute the state root after processing an execution payload envelope.
+ * Similar to `computeNewStateRoot` but for payload envelope processing.
+ *
+ * The `postBlockState` is mutated in place, callers must ensure it is not needed afterward.
+ */
+export function computeEnvelopeStateRoot(
+  metrics: Metrics | null,
+  postBlockState: CachedBeaconStateGloas,
+  envelope: gloas.ExecutionPayloadEnvelope
+): Root {
+  const signedEnvelope: gloas.SignedExecutionPayloadEnvelope = {
+    message: envelope,
+    signature: G2_POINT_AT_INFINITY,
+  };
+
+  const processEnvelopeTimer = metrics?.blockPayload.executionPayloadEnvelopeProcessingTime.startTimer();
+  processExecutionPayloadEnvelope(postBlockState, signedEnvelope, false);
+  processEnvelopeTimer?.();
+
+  const hashTreeRootTimer = metrics?.stateHashTreeRootTime.startTimer({
+    source: StateHashTreeRootSource.computeEnvelopeStateRoot,
+  });
+  const stateRoot = postBlockState.hashTreeRoot();
+  hashTreeRootTimer?.();
+
+  return stateRoot;
 }

package/src/chain/produceBlock/produceBlockBody.ts

@@ -1,10 +1,13 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {ProtoBlock, getSafeExecutionBlockHash} from "@lodestar/fork-choice";
+import {IForkChoice, ProtoBlock, getSafeExecutionBlockHash} from "@lodestar/fork-choice";
 import {
+  BUILDER_INDEX_SELF_BUILD,
   ForkName,
   ForkPostBellatrix,
+  ForkPostCapella,
   ForkPostDeneb,
   ForkPostFulu,
+  ForkPostGloas,
   ForkPreGloas,
   ForkSeq,
   isForkPostAltair,
@@ -16,6 +19,8 @@ import {
   CachedBeaconStateBellatrix,
   CachedBeaconStateCapella,
   CachedBeaconStateExecutions,
+  CachedBeaconStateGloas,
+  G2_POINT_AT_INFINITY,
   computeTimeAtSlot,
   getExpectedWithdrawals,
   getRandaoMix,
@@ -42,6 +47,7 @@ import {
   deneb,
   electra,
   fulu,
+  gloas,
 } from "@lodestar/types";
 import {Logger, fromHex, sleep, toHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
 import {ZERO_HASH_HEX} from "../../constants/index.js";
@@ -99,6 +105,20 @@ export type AssembledBodyType<T extends BlockType> = T extends BlockType.Full
   : BlindedBeaconBlockBody;
 export type AssembledBlockType<T extends BlockType> = T extends BlockType.Full ? BeaconBlock : BlindedBeaconBlock;
 
+export type ProduceFullGloas = {
+  type: BlockType.Full;
+  fork: ForkPostGloas;
+  executionPayload: ExecutionPayload<ForkPostGloas>;
+  executionRequests: electra.ExecutionRequests;
+  blobsBundle: BlobsBundle<ForkPostGloas>;
+  cells: fulu.Cell[][];
+  /**
+   * Cached envelope state root computed during block production.
+   * This is the state root after running `processExecutionPayloadEnvelope` on the
+   * post-block state, and later used to construct the `ExecutionPayloadEnvelope`.
+   */
+  envelopeStateRoot: Root;
+};
 export type ProduceFullFulu = {
   type: BlockType.Full;
   fork: ForkPostFulu;
@@ -131,6 +151,7 @@ export type ProduceBlinded = {
 
 /** The result of local block production, everything that's not the block itself */
 export type ProduceResult =
+  | ProduceFullGloas
   | ProduceFullFulu
   | ProduceFullDeneb
   | ProduceFullBellatrix
@@ -180,12 +201,112 @@ export async function produceBlockBody<T extends BlockType>(
   this.logger.verbose("Producing beacon block body", logMeta);
 
   if (isForkPostGloas(fork)) {
-    // TODO GLOAS: Set body.signedExecutionPayloadBid and body.payloadAttestation
+    // TODO GLOAS: support non self-building here, the block type differentiation between
+    // full and blinded no longer makes sense in gloas, it might be a good idea to move
+    // this into a completely separate function and have pre/post gloas more separated
+    const gloasState = currentState as CachedBeaconStateGloas;
+    const safeBlockHash = getSafeExecutionBlockHash(this.forkChoice);
+    const finalizedBlockHash = this.forkChoice.getFinalizedBlock().executionPayloadBlockHash ?? ZERO_HASH_HEX;
+    const feeRecipient = requestedFeeRecipient ?? this.beaconProposerCache.getOrDefault(proposerIndex);
+
+    const endExecutionPayload = this.metrics?.executionBlockProductionTimeSteps.startTimer();
+
+    this.logger.verbose("Preparing execution payload from engine", {
+      slot: blockSlot,
+      parentBlockRoot: toRootHex(parentBlockRoot),
+      feeRecipient,
+    });
+
+    // Get execution payload from EL
+    const prepareRes = await prepareExecutionPayload(
+      this,
+      this.logger,
+      fork,
+      parentBlockRoot,
+      safeBlockHash,
+      finalizedBlockHash ?? ZERO_HASH_HEX,
+      gloasState,
+      feeRecipient
+    );
+
+    const {prepType, payloadId} = prepareRes;
+    Object.assign(logMeta, {executionPayloadPrepType: prepType});
+
+    if (prepType !== PayloadPreparationType.Cached) {
+      await sleep(PAYLOAD_GENERATION_TIME_MS);
+    }
+
+    this.logger.verbose("Fetching execution payload from engine", {slot: blockSlot, payloadId});
+    const payloadRes = await this.executionEngine.getPayload(fork, payloadId);
+
+    endExecutionPayload?.({step: BlockProductionStep.executionPayload});
+
+    const {executionPayload, blobsBundle, executionRequests} = payloadRes;
+    executionPayloadValue = payloadRes.executionPayloadValue;
+    shouldOverrideBuilder = payloadRes.shouldOverrideBuilder;
+
+    if (blobsBundle === undefined) {
+      throw Error(`Missing blobsBundle response from getPayload at fork=${fork}`);
+    }
+    if (executionRequests === undefined) {
+      throw Error(`Missing executionRequests response from getPayload at fork=${fork}`);
+    }
+
+    const cells = blobsBundle.blobs.map((blob) => kzg.computeCells(blob));
+    if (this.opts.sanityCheckExecutionEngineBlobs) {
+      await validateCellsAndKzgCommitments(blobsBundle.commitments, blobsBundle.proofs, cells);
+    }
+
+    // Create self-build execution payload bid
+    const bid: gloas.ExecutionPayloadBid = {
+      parentBlockHash: gloasState.latestBlockHash,
+      parentBlockRoot: parentBlockRoot,
+      blockHash: executionPayload.blockHash,
+      prevRandao: getRandaoMix(gloasState, gloasState.epochCtx.epoch),
+      feeRecipient: executionPayload.feeRecipient,
+      gasLimit: BigInt(executionPayload.gasLimit),
+      builderIndex: BUILDER_INDEX_SELF_BUILD,
+      slot: blockSlot,
+      value: 0,
+      executionPayment: 0,
+      blobKzgCommitments: blobsBundle.commitments,
+    };
+    const signedBid: gloas.SignedExecutionPayloadBid = {
+      message: bid,
+      signature: G2_POINT_AT_INFINITY,
+    };
+
     const commonBlockBody = await commonBlockBodyPromise;
-    blockBody = Object.assign({}, commonBlockBody) as AssembledBodyType<T>;
-    executionPayloadValue = BigInt(0);
+    const gloasBody = Object.assign({}, commonBlockBody) as gloas.BeaconBlockBody;
+    gloasBody.signedExecutionPayloadBid = signedBid;
+    // TODO GLOAS: Get payload attestations from pool for previous slot
+    gloasBody.payloadAttestations = [];
+    blockBody = gloasBody as AssembledBodyType<T>;
+
+    // Store execution payload data required to construct execution payload envelope later
+    const gloasResult = produceResult as ProduceFullGloas;
+    gloasResult.executionPayload = executionPayload as ExecutionPayload<ForkPostGloas>;
+    gloasResult.executionRequests = executionRequests;
+    gloasResult.blobsBundle = blobsBundle;
+    gloasResult.cells = cells;
+
+    const fetchedTime = Date.now() / 1000 - computeTimeAtSlot(this.config, blockSlot, this.genesisTime);
+    this.metrics?.blockPayload.payloadFetchedTime.observe({prepType}, fetchedTime);
+    this.logger.verbose("Produced block with self-build bid", {
+      slot: blockSlot,
+      executionPayloadValue,
+      prepType,
+      payloadId,
+      fetchedTime,
+      executionBlockHash: toRootHex(executionPayload.blockHash),
+      blobs: blobsBundle.commitments.length,
+    });
 
-    // We don't deal with blinded blocks, execution engine, blobs and execution requests post-gloas
+    Object.assign(logMeta, {
+      transactions: executionPayload.transactions.length,
+      blobs: blobsBundle.commitments.length,
+      shouldOverrideBuilder,
+    });
   } else if (isForkPostBellatrix(fork)) {
     const safeBlockHash = getSafeExecutionBlockHash(this.forkChoice);
     const finalizedBlockHash = this.forkChoice.getFinalizedBlock().executionPayloadBlockHash ?? ZERO_HASH_HEX;
@@ -447,8 +568,14 @@ export async function produceBlockBody<T extends BlockType>(
     });
   }
 
-  if (ForkSeq[fork] >= ForkSeq.capella) {
-    const {blsToExecutionChanges, executionPayload} = blockBody as capella.BeaconBlockBody;
+  if (ForkSeq[fork] >= ForkSeq.gloas) {
+    const {blsToExecutionChanges, payloadAttestations} = blockBody as BeaconBlockBody<ForkPostGloas>;
+    Object.assign(logMeta, {
+      blsToExecutionChanges: blsToExecutionChanges.length,
+      payloadAttestations: payloadAttestations.length,
+    });
+  } else if (ForkSeq[fork] >= ForkSeq.capella) {
+    const {blsToExecutionChanges, executionPayload} = blockBody as BeaconBlockBody<ForkPostCapella & ForkPreGloas>;
     Object.assign(logMeta, {
       blsToExecutionChanges: blsToExecutionChanges.length,
     });
@@ -480,10 +607,12 @@ export async function prepareExecutionPayload(
   parentBlockRoot: Root,
   safeBlockHash: RootHex,
   finalizedBlockHash: RootHex,
-  state: CachedBeaconStateExecutions,
+  state: CachedBeaconStateExecutions | CachedBeaconStateGloas,
   suggestedFeeRecipient: string
 ): Promise<{prepType: PayloadPreparationType; payloadId: PayloadId}> {
-  const parentHash = state.latestExecutionPayloadHeader.blockHash;
+  const parentHash = isForkPostGloas(fork)
+    ? (state as CachedBeaconStateGloas).latestBlockHash
+    : (state as CachedBeaconStateExecutions).latestExecutionPayloadHeader.blockHash;
   const timestamp = computeTimeAtSlot(chain.config, state.slot, state.genesisTime);
   const prevRandao = getRandaoMix(state, state.epochCtx.epoch);
 
@@ -568,25 +697,46 @@ export function getPayloadAttributesForSSE(
   fork: ForkPostBellatrix,
   chain: {
     config: ChainForkConfig;
+    forkChoice: IForkChoice;
   },
   {
     prepareState,
     prepareSlot,
     parentBlockRoot,
     feeRecipient,
-  }: {prepareState: CachedBeaconStateExecutions; prepareSlot: Slot; parentBlockRoot: Root; feeRecipient: string}
+  }: {
+    prepareState: CachedBeaconStateExecutions | CachedBeaconStateGloas;
+    prepareSlot: Slot;
+    parentBlockRoot: Root;
+    feeRecipient: string;
+  }
 ): SSEPayloadAttributes {
-  const parentHash = prepareState.latestExecutionPayloadHeader.blockHash;
+  const parentHash = isForkPostGloas(fork)
+    ? (prepareState as CachedBeaconStateGloas).latestBlockHash
+    : (prepareState as CachedBeaconStateExecutions).latestExecutionPayloadHeader.blockHash;
   const payloadAttributes = preparePayloadAttributes(fork, chain, {
     prepareState,
     prepareSlot,
     parentBlockRoot,
     feeRecipient,
   });
+
+  let parentBlockNumber: number;
+  if (isForkPostGloas(fork)) {
+    // TODO GLOAS: revisit this after fork choice changes are merged
+    const parentBlock = chain.forkChoice.getBlock(parentBlockRoot);
+    if (parentBlock?.executionPayloadBlockHash == null) {
+      throw Error(`Parent block not found in fork choice root=${toRootHex(parentBlockRoot)}`);
+    }
+    parentBlockNumber = parentBlock.executionPayloadNumber;
+  } else {
+    parentBlockNumber = (prepareState as CachedBeaconStateExecutions).latestExecutionPayloadHeader.blockNumber;
+  }
+
   const ssePayloadAttributes: SSEPayloadAttributes = {
     proposerIndex: prepareState.epochCtx.getBeaconProposer(prepareSlot),
     proposalSlot: prepareSlot,
-    parentBlockNumber: prepareState.latestExecutionPayloadHeader.blockNumber,
+    parentBlockNumber,
     parentBlockRoot,
     parentBlockHash: parentHash,
     payloadAttributes,
@@ -605,7 +755,7 @@ function preparePayloadAttributes(
     parentBlockRoot,
     feeRecipient,
   }: {
-    prepareState: CachedBeaconStateExecutions;
+    prepareState: CachedBeaconStateExecutions | CachedBeaconStateGloas;
     prepareSlot: Slot;
     parentBlockRoot: Root;
     feeRecipient: string;