@lodestar/beacon-node 1.41.0-dev.9fa839a030 → 1.41.0-dev.a35cbde8b3

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,12 @@
 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,
   ForkPostDeneb,
   ForkPostFulu,
+  ForkPostGloas,
   ForkPreGloas,
   ForkSeq,
   isForkPostAltair,
@@ -16,6 +18,8 @@ import {
   CachedBeaconStateBellatrix,
   CachedBeaconStateCapella,
   CachedBeaconStateExecutions,
+  CachedBeaconStateGloas,
+  G2_POINT_AT_INFINITY,
   computeTimeAtSlot,
   getExpectedWithdrawals,
   getRandaoMix,
@@ -42,6 +46,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 +104,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 +150,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 +200,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;
@@ -480,10 +600,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 +690,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 +748,7 @@ function preparePayloadAttributes(
     parentBlockRoot,
     feeRecipient,
   }: {
-    prepareState: CachedBeaconStateExecutions;
+    prepareState: CachedBeaconStateExecutions | CachedBeaconStateGloas;
     prepareSlot: Slot;
     parentBlockRoot: Root;
     feeRecipient: string;

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/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",

package/src/metrics/metrics/lodestar.ts

@@ -827,6 +827,15 @@ export function createLodestarMetrics(
         help: "Total number of blobs retrieved from execution engine and published to gossip",
       }),
     },
+    // Gossip execution payload envelope
+    gossipExecutionPayloadEnvelope: {
+      elapsedTimeTillReceived: register.histogram<{source: OpSource}>({
+        name: "lodestar_gossip_execution_payload_envelope_elapsed_time_till_received",
+        help: "Time elapsed between slot time and the time execution payload envelope received",
+        labelNames: ["source"],
+        buckets: [0.5, 1, 2, 4, 6, 12],
+      }),
+    },
     recoverDataColumnSidecars: {
       recoverTime: register.histogram({
         name: "lodestar_recover_data_column_sidecar_recover_time_seconds",

package/src/metrics/metrics.ts

@@ -19,11 +19,16 @@ export function createMetrics(opts: MetricsOptions, genesisTime: number, externa
   const lodestar = createLodestarMetrics(register, opts.metadata, genesisTime);
   const stateTransition = getMetrics(register);
 
-  process.on("unhandledRejection", (_error) => {
+  const onUnhandledRejection = (_error: unknown): void => {
     lodestar.unhandledPromiseRejections.inc();
-  });
+  };
+  process.on("unhandledRejection", onUnhandledRejection);
 
-  const close = collectNodeJSMetrics(register);
+  const nodeJsMetricsClose = collectNodeJSMetrics(register);
+  const close = (): void => {
+    process.removeListener("unhandledRejection", onUnhandledRejection);
+    nodeJsMetricsClose();
+  };
 
   // Merge external registries
   for (const externalRegister of externalRegistries) {

package/src/network/gossip/interface.ts

@@ -4,6 +4,7 @@ import {PeerIdStr} from "@chainsafe/libp2p-gossipsub/types";
 import {BeaconConfig, ForkBoundary} from "@lodestar/config";
 import {
   AttesterSlashing,
+  DataColumnSidecar,
   LightClientFinalityUpdate,
   LightClientOptimisticUpdate,
   SignedAggregateAndProof,
@@ -14,7 +15,6 @@ import {
   altair,
   capella,
   deneb,
-  fulu,
   gloas,
   phase0,
 } from "@lodestar/types";
@@ -98,7 +98,7 @@ export type GossipTypeMap = {
   [GossipType.blob_sidecar]: deneb.BlobSidecar;
   [GossipType.beacon_aggregate_and_proof]: SignedAggregateAndProof;
   [GossipType.beacon_attestation]: SingleAttestation;
-  [GossipType.data_column_sidecar]: fulu.DataColumnSidecar;
+  [GossipType.data_column_sidecar]: DataColumnSidecar;
   [GossipType.voluntary_exit]: phase0.SignedVoluntaryExit;
   [GossipType.proposer_slashing]: phase0.ProposerSlashing;
   [GossipType.attester_slashing]: AttesterSlashing;
@@ -117,7 +117,7 @@ export type GossipFnByType = {
   [GossipType.blob_sidecar]: (blobSidecar: deneb.BlobSidecar) => Promise<void> | void;
   [GossipType.beacon_aggregate_and_proof]: (aggregateAndProof: SignedAggregateAndProof) => Promise<void> | void;
   [GossipType.beacon_attestation]: (attestation: SingleAttestation) => Promise<void> | void;
-  [GossipType.data_column_sidecar]: (dataColumnSidecar: fulu.DataColumnSidecar) => Promise<void> | void;
+  [GossipType.data_column_sidecar]: (dataColumnSidecar: DataColumnSidecar) => Promise<void> | void;
   [GossipType.voluntary_exit]: (voluntaryExit: phase0.SignedVoluntaryExit) => Promise<void> | void;
   [GossipType.proposer_slashing]: (proposerSlashing: phase0.ProposerSlashing) => Promise<void> | void;
   [GossipType.attester_slashing]: (attesterSlashing: AttesterSlashing) => Promise<void> | void;

package/src/network/gossip/topic.ts

@@ -6,6 +6,7 @@ import {
   SYNC_COMMITTEE_SUBNET_COUNT,
   isForkPostAltair,
   isForkPostElectra,
+  isForkPostFulu,
 } from "@lodestar/params";
 import {Attestation, SingleAttestation, ssz, sszTypesFor} from "@lodestar/types";
 import {GossipAction, GossipActionError, GossipErrorCode} from "../../chain/errors/gossipValidation.js";
@@ -92,7 +93,7 @@ export function getGossipSSZType(topic: GossipTopic) {
     case GossipType.blob_sidecar:
       return ssz.deneb.BlobSidecar;
     case GossipType.data_column_sidecar:
-      return ssz.fulu.DataColumnSidecar;
+      return isForkPostFulu(fork) ? sszTypesFor(fork).DataColumnSidecar : ssz.fulu.DataColumnSidecar;
     case GossipType.beacon_aggregate_and_proof:
       return sszTypesFor(fork).SignedAggregateAndProof;
     case GossipType.beacon_attestation:

package/src/network/interface.ts

@@ -19,6 +19,7 @@ import type {Datastore} from "interface-datastore";
 import {Libp2p as ILibp2p} from "libp2p";
 import {
   AttesterSlashing,
+  DataColumnSidecar,
   LightClientFinalityUpdate,
   LightClientOptimisticUpdate,
   SignedAggregateAndProof,
@@ -31,6 +32,7 @@ import {
   capella,
   deneb,
   fulu,
+  gloas,
   phase0,
 } from "@lodestar/types";
 import {BlockInputSource} from "../chain/blocks/blockInput/types.js";
@@ -86,7 +88,7 @@ export interface INetwork extends INetworkCorePublic {
   publishBlobSidecar(blobSidecar: deneb.BlobSidecar): Promise<number>;
   publishBeaconAggregateAndProof(aggregateAndProof: SignedAggregateAndProof): Promise<number>;
   publishBeaconAttestation(attestation: SingleAttestation, subnet: SubnetID): Promise<number>;
-  publishDataColumnSidecar(dataColumnSideCar: fulu.DataColumnSidecar): Promise<number>;
+  publishDataColumnSidecar(dataColumnSideCar: DataColumnSidecar): Promise<number>;
   publishVoluntaryExit(voluntaryExit: phase0.SignedVoluntaryExit): Promise<number>;
   publishBlsToExecutionChange(blsToExecutionChange: capella.SignedBLSToExecutionChange): Promise<number>;
   publishProposerSlashing(proposerSlashing: phase0.ProposerSlashing): Promise<number>;
@@ -95,6 +97,7 @@ export interface INetwork extends INetworkCorePublic {
   publishContributionAndProof(contributionAndProof: altair.SignedContributionAndProof): Promise<number>;
   publishLightClientFinalityUpdate(update: LightClientFinalityUpdate): Promise<number>;
   publishLightClientOptimisticUpdate(update: LightClientOptimisticUpdate): Promise<number>;
+  publishSignedExecutionPayloadEnvelope(signedEnvelope: gloas.SignedExecutionPayloadEnvelope): Promise<number>;
 
   // Debug
   dumpGossipQueue(gossipType: GossipType): Promise<PendingGossipsubMessage[]>;

package/src/network/network.ts

@@ -10,6 +10,7 @@ import {ResponseIncoming} from "@lodestar/reqresp";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {
   AttesterSlashing,
+  DataColumnSidecar,
   LightClientBootstrap,
   LightClientFinalityUpdate,
   LightClientOptimisticUpdate,
@@ -24,6 +25,7 @@ import {
   capella,
   deneb,
   fulu,
+  gloas,
   phase0,
 } from "@lodestar/types";
 import {prettyPrintIndices, sleep} from "@lodestar/utils";
@@ -33,7 +35,7 @@ import {computeSubnetForDataColumnSidecar} from "../chain/validation/dataColumnS
 import {IBeaconDb} from "../db/interface.js";
 import {Metrics, RegistryMetricCreator} from "../metrics/index.js";
 import {IClock} from "../util/clock.js";
-import {CustodyConfig} from "../util/dataColumns.js";
+import {CustodyConfig, isGloasDataColumnSidecar} from "../util/dataColumns.js";
 import {PeerIdStr, peerIdToString} from "../util/peerId.js";
 import {promiseAllMaybeAsync} from "../util/promises.js";
 import {BeaconBlocksByRootRequest, BlobSidecarsByRootRequest, DataColumnSidecarsByRootRequest} from "../util/types.js";
@@ -354,8 +356,11 @@ export class Network implements INetwork {
     });
   }
 
-  async publishDataColumnSidecar(dataColumnSidecar: fulu.DataColumnSidecar): Promise<number> {
-    const epoch = computeEpochAtSlot(dataColumnSidecar.signedBlockHeader.message.slot);
+  async publishDataColumnSidecar(dataColumnSidecar: DataColumnSidecar): Promise<number> {
+    const slot = isGloasDataColumnSidecar(dataColumnSidecar)
+      ? dataColumnSidecar.slot
+      : dataColumnSidecar.signedBlockHeader.message.slot;
+    const epoch = computeEpochAtSlot(slot);
     const boundary = this.config.getForkBoundaryAtEpoch(epoch);
 
     const subnet = computeSubnetForDataColumnSidecar(this.config, dataColumnSidecar);
@@ -489,6 +494,17 @@ export class Network implements INetwork {
     );
   }
 
+  async publishSignedExecutionPayloadEnvelope(signedEnvelope: gloas.SignedExecutionPayloadEnvelope): Promise<number> {
+    const epoch = computeEpochAtSlot(signedEnvelope.message.slot);
+    const boundary = this.config.getForkBoundaryAtEpoch(epoch);
+
+    return this.publishGossip<GossipType.execution_payload>(
+      {type: GossipType.execution_payload, boundary},
+      signedEnvelope,
+      {ignoreDuplicatePublishError: true}
+    );
+  }
+
   private async publishGossip<K extends GossipType>(
     topic: GossipTopicMap[K],
     object: GossipTypeMap[K],
@@ -765,7 +781,7 @@ export class Network implements INetwork {
     this.core.setTargetGroupCount(count);
   };
 
-  private onPublishDataColumns = (sidecars: fulu.DataColumnSidecar[]): Promise<number[]> => {
+  private onPublishDataColumns = (sidecars: DataColumnSidecar[]): Promise<number[]> => {
     return promiseAllMaybeAsync(sidecars.map((sidecar) => () => this.publishDataColumnSidecar(sidecar)));
   };
 

package/src/network/processor/gossipHandlers.ts

@@ -548,7 +548,8 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       seenTimestampSec,
     }: GossipHandlerParamGeneric<GossipType.data_column_sidecar>) => {
       const {serializedData} = gossipData;
-      const dataColumnSidecar = sszDeserialize(topic, serializedData);
+      // TODO GLOAS: handle gloas.DataColumnSidecar
+      const dataColumnSidecar = sszDeserialize(topic, serializedData) as fulu.DataColumnSidecar;
       const dataColumnSlot = dataColumnSidecar.signedBlockHeader.message.slot;
       const index = dataColumnSidecar.index;
 
@@ -821,11 +822,16 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
     [GossipType.execution_payload]: async ({
       gossipData,
       topic,
+      seenTimestampSec,
     }: GossipHandlerParamGeneric<GossipType.execution_payload>) => {
       const {serializedData} = gossipData;
       const executionPayloadEnvelope = sszDeserialize(topic, serializedData);
       await validateGossipExecutionPayloadEnvelope(chain, executionPayloadEnvelope);
 
+      const slot = executionPayloadEnvelope.message.slot;
+      const delaySec = seenTimestampSec - computeTimeAtSlot(config, slot, chain.genesisTime);
+      metrics?.gossipExecutionPayloadEnvelope.elapsedTimeTillReceived.observe({source: OpSource.gossip}, delaySec);
+
       // TODO GLOAS: Handle valid envelope. Need an import flow that calls `processExecutionPayloadEnvelope` and fork choice
     },
     [GossipType.payload_attestation_message]: async ({

package/src/network/reqresp/handlers/lightClientUpdatesByRange.ts

@@ -19,6 +19,7 @@ export async function* onLightClientUpdatesByRange(
   assertLightClientServer(chain.lightClientServer);
 
   const count = Math.min(MAX_REQUEST_LIGHT_CLIENT_UPDATES, requestBody.count);
+  let started = false;
   for (let period = requestBody.startPeriod; period < requestBody.startPeriod + count; period++) {
     try {
       const update = await chain.lightClientServer.getUpdate(period);
@@ -29,9 +30,13 @@ export async function* onLightClientUpdatesByRange(
         data: type.serialize(update),
         boundary,
       };
+      started = true;
     } catch (e) {
       if ((e as LightClientServerError).type?.code === LightClientServerErrorCode.RESOURCE_UNAVAILABLE) {
-        throw new ResponseError(RespStatus.RESOURCE_UNAVAILABLE, (e as Error).message);
+        // Period not available, if we already started yielding, stop to
+        // preserve consecutive order. Otherwise skip leading gaps.
+        if (started) return;
+        continue;
       }
       throw new ResponseError(RespStatus.SERVER_ERROR, (e as Error).message);
     }

package/src/util/dataColumns.ts

@@ -15,9 +15,12 @@ import {
   BeaconBlockBody,
   ColumnIndex,
   CustodyIndex,
+  DataColumnSidecar,
+  Root,
   SSZTypesFor,
   SignedBeaconBlock,
   SignedBeaconBlockHeader,
+  Slot,
   deneb,
   fulu,
   gloas,
@@ -277,6 +280,11 @@ export function getBlobKzgCommitments(
   return (signedBlock.message.body as BeaconBlockBody<ForkPostFulu & ForkPreGloas>).blobKzgCommitments;
 }
 
+/** Type guard for `gloas.DataColumnSidecar` */
+export function isGloasDataColumnSidecar(sidecar: DataColumnSidecar): sidecar is gloas.DataColumnSidecar {
+  return (sidecar as gloas.DataColumnSidecar).beaconBlockRoot !== undefined;
+}
+
 /**
  * Given a signed block header and the commitments, inclusion proof, cells/proofs associated with
  * each blob in the block, assemble the sidecars which can be distributed to peers.
@@ -359,6 +367,39 @@ export function getDataColumnSidecarsFromColumnSidecar(
   );
 }
 
+/**
+ * In Gloas, data column sidecars have a simplified structure with `slot` and `beaconBlockRoot`
+ * instead of `signedBlockHeader`, `kzgCommitments`, and `kzgCommitmentsInclusionProof`.
+ */
+export function getDataColumnSidecarsForGloas(
+  slot: Slot,
+  beaconBlockRoot: Root,
+  cellsAndKzgProofs: {cells: Uint8Array[]; proofs: Uint8Array[]}[]
+): gloas.DataColumnSidecars {
+  // No need to create data column sidecars if there are no blobs
+  if (cellsAndKzgProofs.length === 0) {
+    return [];
+  }
+
+  const sidecars: gloas.DataColumnSidecars = [];
+  for (let columnIndex = 0; columnIndex < NUMBER_OF_COLUMNS; columnIndex++) {
+    const column: Uint8Array[] = [];
+    const kzgProofs: Uint8Array[] = [];
+    for (const {cells, proofs} of cellsAndKzgProofs) {
+      column.push(cells[columnIndex]);
+      kzgProofs.push(proofs[columnIndex]);
+    }
+    sidecars.push({
+      index: columnIndex,
+      column,
+      kzgProofs,
+      slot,
+      beaconBlockRoot,
+    });
+  }
+  return sidecars;
+}
+
 /**
  * If we receive more than half of NUMBER_OF_COLUMNS (64) we should recover all remaining columns
  */

package/src/util/serializedCache.ts

@@ -14,6 +14,11 @@ export class SerializedCache {
     this.map.set(obj, serialized);
   }
 
+  /**
+   * Replace the internal WeakMap to force GC of all cached entries.
+   * Must only be called after all DB writes that may read from this cache have completed,
+   * otherwise cached serialized bytes will be unavailable and data will be re-serialized unnecessarily.
+   */
   clear(): void {
     this.map = new WeakMap();
   }