@lodestar/beacon-node 1.41.0-dev.702f7932c2 → 1.41.0-dev.95cf2edc4c

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;

package/src/chain/validation/attestation.ts

@@ -143,7 +143,10 @@ export async function validateGossipAttestationsSameAttData(
   if (batchableBls) {
     // all signature sets should have same signing root since we filtered in network processor
     signatureValids = await chain.bls.verifySignatureSetsSameMessage(
-      signatureSets.map((set) => ({publicKey: chain.index2pubkey[set.index], signature: set.signature})),
+      signatureSets.map((set) => {
+        const publicKey = chain.pubkeyCache.getOrThrow(set.index);
+        return {publicKey, signature: set.signature};
+      }),
       signatureSets[0].signingRoot
     );
   } else {

package/src/chain/validation/attesterSlashing.ts

@@ -45,7 +45,7 @@ export async function validateAttesterSlashing(
     // verifySignature = false, verified in batch below
     assertValidAttesterSlashing(
       chain.config,
-      chain.index2pubkey,
+      chain.pubkeyCache,
       state.slot,
       state.validators.length,
       attesterSlashing,

package/src/chain/validation/block.ts

@@ -9,8 +9,8 @@ import {
   isExecutionEnabled,
   isExecutionStateType,
 } from "@lodestar/state-transition";
-import {SignedBeaconBlock, deneb} from "@lodestar/types";
-import {sleep, toRootHex} from "@lodestar/utils";
+import {SignedBeaconBlock, deneb, gloas} from "@lodestar/types";
+import {byteArrayEquals, sleep, toRootHex} from "@lodestar/utils";
 import {BlockErrorCode, BlockGossipError, GossipAction} from "../errors/index.js";
 import {IBeaconChain} from "../interface.js";
 import {RegenCaller} from "../regen/index.js";
@@ -23,6 +23,7 @@ export async function validateGossipBlock(
 ): Promise<void> {
   const block = signedBlock.message;
   const blockSlot = block.slot;
+  const blockEpoch = computeEpochAtSlot(blockSlot);
 
   // [IGNORE] The block is not from a future slot (with a MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance) -- i.e.validate
   // that signed_beacon_block.message.slot <= current_slot (a client MAY queue future blocks for processing at the
@@ -113,7 +114,7 @@ export async function validateGossipBlock(
   // [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;
-    const maxBlobsPerBlock = config.getMaxBlobsPerBlock(computeEpochAtSlot(blockSlot));
+    const maxBlobsPerBlock = config.getMaxBlobsPerBlock(blockEpoch);
     if (blobKzgCommitmentsLen > maxBlobsPerBlock) {
       throw new BlockGossipError(GossipAction.REJECT, {
         code: BlockErrorCode.TOO_MANY_KZG_COMMITMENTS,
@@ -123,12 +124,39 @@ export async function validateGossipBlock(
     }
   }
 
+  if (isForkPostGloas(fork)) {
+    const bid = (block as gloas.BeaconBlock).body.signedExecutionPayloadBid.message;
+
+    // [REJECT] The length of KZG commitments is less than or equal to the limitation defined in Consensus Layer
+    // -- i.e. validate that len(bid.blob_kzg_commitments) <= max_blobs_per_block
+    const blobKzgCommitmentsLen = bid.blobKzgCommitments.length;
+    const maxBlobsPerBlock = config.getMaxBlobsPerBlock(blockEpoch);
+    if (blobKzgCommitmentsLen > maxBlobsPerBlock) {
+      throw new BlockGossipError(GossipAction.REJECT, {
+        code: BlockErrorCode.TOO_MANY_KZG_COMMITMENTS,
+        blobKzgCommitmentsLen,
+        commitmentLimit: maxBlobsPerBlock,
+      });
+    }
+
+    // [REJECT] The bid's parent (defined by bid.parent_block_root) equals the block's parent (defined by block.parent_root)
+    if (!byteArrayEquals(bid.parentBlockRoot, block.parentRoot)) {
+      throw new BlockGossipError(GossipAction.REJECT, {
+        code: BlockErrorCode.BID_PARENT_ROOT_MISMATCH,
+        bidParentRoot: toRootHex(bid.parentBlockRoot),
+        blockParentRoot: parentRoot,
+      });
+    }
+
+    // TODO GLOAS: [REJECT] The block's execution payload parent (defined by bid.parent_block_hash) passes all validation
+    // This requires execution engine integration to verify the parent block hash
+  }
+
   // use getPreState to reload state if needed. It also checks for whether the current finalized checkpoint is an ancestor of the block.
   // As a result, we throw an IGNORE (whereas the spec says we should REJECT for this scenario).
   // this is something we should change this in the future to make the code airtight to the spec.
   // [IGNORE] The block's parent (defined by block.parent_root) has been seen (via both gossip and non-gossip sources) (a client MAY queue blocks for processing once the parent block is retrieved).
   // [REJECT] The block's parent (defined by block.parent_root) passes validation.
-  // TODO GLOAS: post-gloas, we check the validity of bid's parent payload, not the entire beacon block
   const blockState = await chain.regen
     .getPreState(block, {dontTransferCache: true}, RegenCaller.validateGossipBlock)
     .catch(() => {

package/src/chain/validation/dataColumnSidecar.ts

@@ -10,7 +10,7 @@ import {
   getBlockHeaderProposerSignatureSetByHeaderSlot,
   getBlockHeaderProposerSignatureSetByParentStateSlot,
 } from "@lodestar/state-transition";
-import {Root, Slot, SubnetID, fulu, ssz} from "@lodestar/types";
+import {DataColumnSidecar, Root, Slot, SubnetID, fulu, ssz} from "@lodestar/types";
 import {byteArrayEquals, toRootHex, verifyMerkleBranch} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
 import {kzg} from "../../util/kzg.js";
@@ -457,9 +457,6 @@ export async function validateBlockDataColumnSidecars(
  * SPEC FUNCTION
  * https://github.com/ethereum/consensus-specs/blob/v1.6.0-alpha.4/specs/fulu/p2p-interface.md#compute_subnet_for_data_column_sidecar
  */
-export function computeSubnetForDataColumnSidecar(
-  config: ChainConfig,
-  columnSidecar: fulu.DataColumnSidecar
-): SubnetID {
+export function computeSubnetForDataColumnSidecar(config: ChainConfig, columnSidecar: DataColumnSidecar): SubnetID {
   return columnSidecar.index % config.DATA_COLUMN_SIDECAR_SUBNET_COUNT;
 }

package/src/chain/validation/executionPayloadEnvelope.ts

@@ -35,7 +35,8 @@ async function validateExecutionPayloadEnvelope(
   // [IGNORE] The envelope's block root `envelope.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
+  // 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.getBlock(envelope.beaconBlockRoot);
   if (block === null) {
     throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {

package/src/chain/validation/payloadAttestationMessage.ts

@@ -87,9 +87,17 @@ async function validatePayloadAttestationMessage(
   }
 
   // [REJECT] `payload_attestation_message.signature` is valid with respect to the validator's public key.
+  const validatorPubkey = chain.pubkeyCache.get(validatorIndex);
+  if (!validatorPubkey) {
+    throw new PayloadAttestationError(GossipAction.REJECT, {
+      code: PayloadAttestationErrorCode.INVALID_ATTESTER,
+      attesterIndex: validatorIndex,
+    });
+  }
+
   const signatureSet = createSingleSignatureSetFromComponents(
-    chain.index2pubkey[validatorIndex],
-    getPayloadAttestationDataSigningRoot(chain.config, state.slot, data),
+    validatorPubkey,
+    getPayloadAttestationDataSigningRoot(chain.config, data),
     payloadAttestationMessage.signature
   );
 

package/src/chain/validation/proposerSlashing.ts

@@ -37,7 +37,7 @@ async function validateProposerSlashing(
   try {
     const proposer = state.validators.getReadonly(proposerSlashing.signedHeader1.message.proposerIndex);
     // verifySignature = false, verified in batch below
-    assertValidProposerSlashing(chain.config, chain.index2pubkey, state.slot, proposerSlashing, proposer, false);
+    assertValidProposerSlashing(chain.config, chain.pubkeyCache, state.slot, proposerSlashing, proposer, false);
   } catch (e) {
     throw new ProposerSlashingError(GossipAction.REJECT, {
       code: ProposerSlashingErrorCode.INVALID,

package/src/chain/validation/syncCommitteeContributionAndProof.ts

@@ -106,7 +106,7 @@ export async function validateSyncCommitteeGossipContributionAndProof(
 /**
  * Retrieve pubkeys in contribution aggregate using epochCtx:
  * - currSyncCommitteeIndexes cache
- * - index2pubkey cache
+ * - pubkeyCache
  */
 function getContributionIndices(
   state: CachedBeaconStateAltair,

package/src/db/beacon.ts

@@ -15,6 +15,8 @@ import {
   CheckpointHeaderRepository,
   DataColumnSidecarArchiveRepository,
   DataColumnSidecarRepository,
+  ExecutionPayloadEnvelopeArchiveRepository,
+  ExecutionPayloadEnvelopeRepository,
   ProposerSlashingRepository,
   StateArchiveRepository,
   SyncCommitteeRepository,
@@ -36,6 +38,9 @@ export class BeaconDb implements IBeaconDb {
   dataColumnSidecar: DataColumnSidecarRepository;
   dataColumnSidecarArchive: DataColumnSidecarArchiveRepository;
 
+  executionPayloadEnvelope: ExecutionPayloadEnvelopeRepository;
+  executionPayloadEnvelopeArchive: ExecutionPayloadEnvelopeArchiveRepository;
+
   stateArchive: StateArchiveRepository;
   checkpointState: CheckpointStateRepository;
 
@@ -65,6 +70,9 @@ export class BeaconDb implements IBeaconDb {
     this.dataColumnSidecar = new DataColumnSidecarRepository(config, db);
     this.dataColumnSidecarArchive = new DataColumnSidecarArchiveRepository(config, db);
 
+    this.executionPayloadEnvelope = new ExecutionPayloadEnvelopeRepository(config, db);
+    this.executionPayloadEnvelopeArchive = new ExecutionPayloadEnvelopeArchiveRepository(config, db);
+
     this.stateArchive = new StateArchiveRepository(config, db);
     this.checkpointState = new CheckpointStateRepository(config, db);
     this.voluntaryExit = new VoluntaryExitRepository(config, db);

package/src/db/buckets.ts

@@ -69,6 +69,9 @@ export enum Bucket {
 
   fulu_dataColumnSidecars = 57, // FULU BeaconBlockRoot -> DataColumnSidecars
   fulu_dataColumnSidecarsArchive = 58, // FULU BeaconBlockSlot -> DataColumnSidecars
+
+  gloas_executionPayloadEnvelope = 59, // GLOAS BeaconBlockRoot -> SignedExecutionPayloadEnvelope
+  gloas_executionPayloadEnvelopeArchive = 60, // GLOAS Slot -> SignedExecutionPayloadEnvelope
 }
 
 export function getBucketNameByValue<T extends Bucket>(enumValue: T): keyof typeof Bucket {

package/src/db/interface.ts

@@ -12,6 +12,8 @@ import {
   CheckpointHeaderRepository,
   DataColumnSidecarArchiveRepository,
   DataColumnSidecarRepository,
+  ExecutionPayloadEnvelopeArchiveRepository,
+  ExecutionPayloadEnvelopeRepository,
   ProposerSlashingRepository,
   StateArchiveRepository,
   SyncCommitteeRepository,
@@ -35,6 +37,9 @@ export interface IBeaconDb {
   dataColumnSidecar: DataColumnSidecarRepository;
   dataColumnSidecarArchive: DataColumnSidecarArchiveRepository;
 
+  executionPayloadEnvelope: ExecutionPayloadEnvelopeRepository;
+  executionPayloadEnvelopeArchive: ExecutionPayloadEnvelopeArchiveRepository;
+
   // finalized states
   stateArchive: StateArchiveRepository;
   // checkpoint states

package/src/db/repositories/dataColumnSidecar.ts

@@ -1,7 +1,8 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {Db, PrefixedRepository, decodeNumberForDbKey, encodeNumberForDbKey} from "@lodestar/db";
 import {NUMBER_OF_COLUMNS} from "@lodestar/params";
-import {ColumnIndex, Root, fulu, ssz} from "@lodestar/types";
+import {ColumnIndex, DataColumnSidecar, Root, isGloasDataColumnSidecar, ssz} from "@lodestar/types";
+import {isGloasDataColumnSidecarBytes} from "../../util/multifork.js";
 import {Bucket, getBucketNameByValue} from "../buckets.js";
 
 const COLUMN_INDEX_BYTE_SIZE = 2;
@@ -15,7 +16,7 @@ type BlockRoot = Root;
  *
  * Indexed data by `blockRoot` + `columnIndex`
  */
-export class DataColumnSidecarRepository extends PrefixedRepository<BlockRoot, ColumnIndex, fulu.DataColumnSidecar> {
+export class DataColumnSidecarRepository extends PrefixedRepository<BlockRoot, ColumnIndex, DataColumnSidecar> {
   constructor(config: ChainForkConfig, db: Db) {
     const bucket = Bucket.fulu_dataColumnSidecars;
     super(config, db, bucket, ssz.fulu.DataColumnSidecar, getBucketNameByValue(bucket));
@@ -24,10 +25,24 @@ export class DataColumnSidecarRepository extends PrefixedRepository<BlockRoot, C
   /**
    * Id is hashTreeRoot of unsigned BeaconBlock
    */
-  getId(value: fulu.DataColumnSidecar): ColumnIndex {
+  getId(value: DataColumnSidecar): ColumnIndex {
     return value.index;
   }
 
+  encodeValue(value: DataColumnSidecar): Uint8Array {
+    if (isGloasDataColumnSidecar(value)) {
+      return ssz.gloas.DataColumnSidecar.serialize(value);
+    }
+    return ssz.fulu.DataColumnSidecar.serialize(value);
+  }
+
+  decodeValue(data: Uint8Array): DataColumnSidecar {
+    if (isGloasDataColumnSidecarBytes(data)) {
+      return ssz.gloas.DataColumnSidecar.deserialize(data);
+    }
+    return ssz.fulu.DataColumnSidecar.deserialize(data);
+  }
+
   encodeKeyRaw(prefix: BlockRoot, id: ColumnIndex): Uint8Array {
     return Buffer.concat([prefix, encodeNumberForDbKey(id, COLUMN_INDEX_BYTE_SIZE)]);
   }

package/src/db/repositories/dataColumnSidecarArchive.ts

@@ -1,7 +1,8 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {Db, PrefixedRepository, decodeNumberForDbKey, encodeNumberForDbKey} from "@lodestar/db";
 import {NUMBER_OF_COLUMNS} from "@lodestar/params";
-import {ColumnIndex, Slot, fulu, ssz} from "@lodestar/types";
+import {ColumnIndex, DataColumnSidecar, Slot, isGloasDataColumnSidecar, ssz} from "@lodestar/types";
+import {isGloasDataColumnSidecarBytes} from "../../util/multifork.js";
 import {Bucket, getBucketNameByValue} from "../buckets.js";
 
 const COLUMN_INDEX_BYTE_SIZE = 2;
@@ -13,7 +14,7 @@ const SLOT_BYTE_SIZE = 8;
  *
  * Indexed data by `slot` + `columnIndex`
  */
-export class DataColumnSidecarArchiveRepository extends PrefixedRepository<Slot, ColumnIndex, fulu.DataColumnSidecar> {
+export class DataColumnSidecarArchiveRepository extends PrefixedRepository<Slot, ColumnIndex, DataColumnSidecar> {
   constructor(config: ChainForkConfig, db: Db) {
     const bucket = Bucket.fulu_dataColumnSidecarsArchive;
     super(config, db, bucket, ssz.fulu.DataColumnSidecar, getBucketNameByValue(bucket));
@@ -22,10 +23,24 @@ export class DataColumnSidecarArchiveRepository extends PrefixedRepository<Slot,
   /**
    * Id is hashTreeRoot of unsigned BeaconBlock
    */
-  getId(value: fulu.DataColumnSidecar): ColumnIndex {
+  getId(value: DataColumnSidecar): ColumnIndex {
     return value.index;
   }
 
+  encodeValue(value: DataColumnSidecar): Uint8Array {
+    if (isGloasDataColumnSidecar(value)) {
+      return ssz.gloas.DataColumnSidecar.serialize(value);
+    }
+    return ssz.fulu.DataColumnSidecar.serialize(value);
+  }
+
+  decodeValue(data: Uint8Array): DataColumnSidecar {
+    if (isGloasDataColumnSidecarBytes(data)) {
+      return ssz.gloas.DataColumnSidecar.deserialize(data);
+    }
+    return ssz.fulu.DataColumnSidecar.deserialize(data);
+  }
+
   encodeKeyRaw(prefix: Slot, id: ColumnIndex): Uint8Array {
     return Buffer.concat([
       encodeNumberForDbKey(prefix, SLOT_BYTE_SIZE),

package/src/db/repositories/executionPayloadEnvelope.ts

@@ -0,0 +1,26 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, Repository} from "@lodestar/db";
+import {Root, gloas, ssz} from "@lodestar/types";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+type BlockRoot = Root;
+
+/**
+ * Used to store unfinalized `SignedExecutionPayloadEnvelope`
+ *
+ * Indexed by beacon block root (root of the beacon block that contains the bid)
+ */
+export class ExecutionPayloadEnvelopeRepository extends Repository<BlockRoot, gloas.SignedExecutionPayloadEnvelope> {
+  constructor(config: ChainForkConfig, db: Db) {
+    const bucket = Bucket.gloas_executionPayloadEnvelope;
+    super(config, db, bucket, ssz.gloas.SignedExecutionPayloadEnvelope, getBucketNameByValue(bucket));
+  }
+
+  /**
+   * Id is the beacon block root (not execution payload hash)
+   * This allows correlation with the block that contains the bid
+   */
+  getId(value: gloas.SignedExecutionPayloadEnvelope): BlockRoot {
+    return value.message.beaconBlockRoot;
+  }
+}

package/src/db/repositories/executionPayloadEnvelopeArchive.ts

@@ -0,0 +1,32 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {BUCKET_LENGTH, Db, Repository, encodeKey as encodeDbKey} from "@lodestar/db";
+import {Slot, gloas, ssz} from "@lodestar/types";
+import {bytesToInt} from "@lodestar/utils";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+/**
+ * Used to store finalized `SignedExecutionPayloadEnvelope`
+ *
+ * Indexed by slot for chronological archival
+ */
+export class ExecutionPayloadEnvelopeArchiveRepository extends Repository<Slot, gloas.SignedExecutionPayloadEnvelope> {
+  constructor(config: ChainForkConfig, db: Db) {
+    const bucket = Bucket.gloas_executionPayloadEnvelopeArchive;
+    super(config, db, bucket, ssz.gloas.SignedExecutionPayloadEnvelope, getBucketNameByValue(bucket));
+  }
+
+  /**
+   * Id is the slot from the envelope
+   */
+  getId(value: gloas.SignedExecutionPayloadEnvelope): Slot {
+    return value.message.slot;
+  }
+
+  encodeKey(id: Slot): Uint8Array {
+    return encodeDbKey(this.bucket, id);
+  }
+
+  decodeKey(data: Uint8Array): number {
+    return bytesToInt(data.subarray(BUCKET_LENGTH), "be");
+  }
+}

package/src/db/repositories/index.ts

@@ -8,6 +8,8 @@ export {BlockArchiveRepository} from "./blockArchive.js";
 export {BLSToExecutionChangeRepository} from "./blsToExecutionChange.js";
 export {DataColumnSidecarRepository} from "./dataColumnSidecar.js";
 export {DataColumnSidecarArchiveRepository} from "./dataColumnSidecarArchive.js";
+export {ExecutionPayloadEnvelopeRepository} from "./executionPayloadEnvelope.js";
+export {ExecutionPayloadEnvelopeArchiveRepository} from "./executionPayloadEnvelopeArchive.js";
 export {BestLightClientUpdateRepository} from "./lightclientBestUpdate.js";
 export {CheckpointHeaderRepository} from "./lightclientCheckpointHeader.js";
 export {SyncCommitteeRepository} from "./lightclientSyncCommittee.js";

package/src/metrics/metrics/beacon.ts

@@ -144,6 +144,11 @@ export function createBeaconMetrics(register: RegistryMetricCreator) {
         help: "Time for preparing payload in advance",
         buckets: [0.1, 1, 3, 5, 10],
       }),
+      executionPayloadEnvelopeProcessingTime: register.histogram({
+        name: "beacon_block_payload_envelope_processing_seconds",
+        help: "Time to process execution payload envelope during block production",
+        buckets: [0.005, 0.01, 0.05, 0.1, 0.2, 0.5, 1],
+      }),
       payloadFetchedTime: register.histogram<{prepType: PayloadPreparationType}>({
         name: "beacon_block_payload_fetched_time",
         help: "Time to fetch the payload from EL",