@lodestar/beacon-node 1.35.0-dev.21ba2777a9 → 1.35.0-dev.287e63792e

package/src/chain/produceBlock/produceBlockBody.ts

@@ -4,9 +4,11 @@ import {
   ForkPostBellatrix,
   ForkPostDeneb,
   ForkPostFulu,
+  ForkPreGloas,
   ForkSeq,
   isForkPostAltair,
   isForkPostBellatrix,
+  isForkPostGloas,
 } from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
@@ -182,7 +184,14 @@ export async function produceBlockBody<T extends BlockType>(
   };
   this.logger.verbose("Producing beacon block body", logMeta);
 
-  if (isForkPostBellatrix(fork)) {
+  if (isForkPostGloas(fork)) {
+    // TODO GLOAS: Set body.signedExecutionPayloadBid and body.payloadAttestation
+    const commonBlockBody = await commonBlockBodyPromise;
+    blockBody = Object.assign({}, commonBlockBody) as AssembledBodyType<T>;
+    executionPayloadValue = BigInt(0);
+
+    // We don't deal with blinded blocks, execution engine, blobs and execution requests post-gloas
+  } else if (isForkPostBellatrix(fork)) {
     const safeBlockHash = this.forkChoice.getJustifiedBlock().executionPayloadBlockHash ?? ZERO_HASH_HEX;
     const finalizedBlockHash = this.forkChoice.getFinalizedBlock().executionPayloadBlockHash ?? ZERO_HASH_HEX;
     const feeRecipient = requestedFeeRecipient ?? this.beaconProposerCache.getOrDefault(proposerIndex);
@@ -307,6 +316,7 @@ export async function produceBlockBody<T extends BlockType>(
 
     // blockType === BlockType.Full
     else {
+      // enginePromise only supports pre-gloas
       const enginePromise = (async () => {
         const endExecutionPayload = this.metrics?.executionBlockProductionTimeSteps.startTimer();
 
@@ -384,13 +394,13 @@ export async function produceBlockBody<T extends BlockType>(
       blockBody = Object.assign({}, commonBlockBody) as AssembledBodyType<BlockType.Blinded>;
 
       if (engineRes.isPremerge) {
-        (blockBody as BeaconBlockBody<ForkPostBellatrix>).executionPayload = engineRes.executionPayload;
+        (blockBody as BeaconBlockBody<ForkPostBellatrix & ForkPreGloas>).executionPayload = engineRes.executionPayload;
         executionPayloadValue = engineRes.executionPayloadValue;
       } else {
         const {prepType, payloadId, executionPayload, blobsBundle, executionRequests} = engineRes;
         shouldOverrideBuilder = engineRes.shouldOverrideBuilder;
 
-        (blockBody as BeaconBlockBody<ForkPostBellatrix>).executionPayload = executionPayload;
+        (blockBody as BeaconBlockBody<ForkPostBellatrix & ForkPreGloas>).executionPayload = executionPayload;
         (produceResult as ProduceFullBellatrix).executionPayload = executionPayload;
         executionPayloadValue = engineRes.executionPayloadValue;
         Object.assign(logMeta, {transactions: executionPayload.transactions.length, shouldOverrideBuilder});

package/src/chain/regen/interface.ts

@@ -10,6 +10,7 @@ export enum RegenCaller {
   produceBlock = "produceBlock",
   validateGossipBlock = "validateGossipBlock",
   validateGossipBlob = "validateGossipBlob",
+  validateGossipDataColumn = "validateGossipDataColumn",
   precomputeEpoch = "precomputeEpoch",
   predictProposerHead = "predictProposerHead",
   produceAttestationData = "produceAttestationData",

package/src/chain/seenCache/seenGossipBlockInput.ts

@@ -1,6 +1,6 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {CheckpointWithHex} from "@lodestar/fork-choice";
-import {ForkName, ForkPostFulu, isForkPostDeneb, isForkPostFulu} from "@lodestar/params";
+import {ForkName, ForkPostFulu, ForkPreGloas, isForkPostDeneb, isForkPostFulu, isForkPostGloas} from "@lodestar/params";
 import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {RootHex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
 import {LodestarError, Logger} from "@lodestar/utils";
@@ -155,6 +155,12 @@ export class SeenBlockInput {
     let blockInput = this.blockInputs.get(blockRootHex) as IBlockInput;
     if (!blockInput) {
       const {forkName, daOutOfRange} = this.buildCommonProps(block.message.slot);
+
+      // TODO GLOAS: Implement
+      if (isForkPostGloas(forkName)) {
+        throw Error("Not implemented");
+      }
+      // Pre-deneb
       if (!isForkPostDeneb(forkName)) {
         blockInput = BlockInputPreData.createFromBlock({
           block,
@@ -165,9 +171,10 @@ export class SeenBlockInput {
           seenTimestampSec,
           peerIdStr,
         });
+        // Fulu Only
       } else if (isForkPostFulu(forkName)) {
         blockInput = BlockInputColumns.createFromBlock({
-          block: block as SignedBeaconBlock<ForkPostFulu>,
+          block: block as SignedBeaconBlock<ForkPostFulu & ForkPreGloas>,
           blockRootHex,
           daOutOfRange,
           forkName,
@@ -177,6 +184,7 @@ export class SeenBlockInput {
           seenTimestampSec,
           peerIdStr,
         });
+        // Deneb and Electra
       } else {
         blockInput = BlockInputBlobs.createFromBlock({
           block: block as SignedBeaconBlock<ForkBlobsDA>,

package/src/chain/stateCache/persistentCheckpointsCache.ts

@@ -1,5 +1,4 @@
 import {routes} from "@lodestar/api";
-import {INTERVALS_PER_SLOT} from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
   computeStartSlotAtEpoch,
@@ -59,6 +58,9 @@ type LoadedStateBytesData = {persistedKey: DatastoreKey; stateBytes: Uint8Array}
  */
 export const DEFAULT_MAX_CP_STATE_EPOCHS_IN_MEMORY = 3;
 
+// TODO GLOAS: re-evaluate this timing
+const PROCESS_CHECKPOINT_STATES_BPS = 6667;
+
 /**
  * An implementation of CheckpointStateCache that keep up to n epoch checkpoint states in memory and persist the rest to disk
  * - If it's more than `maxEpochsInMemory` epochs old, it will persist n last epochs to disk based on the view of the block
@@ -464,14 +466,14 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
     }
 
     const blockSlot = state.slot;
-    const twoThirdsSlot = (2 * state.config.SECONDS_PER_SLOT) / INTERVALS_PER_SLOT;
+    const processCPStatesTimeMs = state.config.getSlotComponentDurationMs(PROCESS_CHECKPOINT_STATES_BPS);
     // we always have clock in production, fallback value is only for test
-    const secFromSlot = this.clock?.secFromSlot(blockSlot) ?? twoThirdsSlot;
-    const secToTwoThirdsSlot = twoThirdsSlot - secFromSlot;
-    if (secToTwoThirdsSlot > 0) {
-      // 2/3 of slot is the most free time of every slot, take that chance to persist checkpoint states
-      // normally it should only persist checkpoint states at 2/3 of slot 0 of epoch
-      await sleep(secToTwoThirdsSlot * 1000, this.signal);
+    const msFromSlot = this.clock?.msFromSlot(blockSlot) ?? processCPStatesTimeMs;
+    const msToProcessCPStates = processCPStatesTimeMs - msFromSlot;
+    if (msToProcessCPStates > 0) {
+      // At ~67% of slot is the most free time of every slot, take that chance to persist checkpoint states
+      // normally it should only persist checkpoint states at ~67% of slot 0 of epoch
+      await sleep(msToProcessCPStates, this.signal);
     }
     // at syncing time, it's critical to persist checkpoint states as soon as possible to avoid OOM during unfinality time
     // if node is synced this is not a hot time because block comes late, we'll likely miss attestation already, or the block is orphaned

package/src/chain/validation/dataColumnSidecar.ts

@@ -99,7 +99,7 @@ export async function validateGossipDataColumnSidecar(
   // this is something we should change this in the future to make the code airtight to the spec.
   // 7) [REJECT] The sidecar's block's parent passes validation.
   const blockState = await chain.regen
-    .getBlockSlotState(parentRoot, blockHeader.slot, {dontTransferCache: true}, RegenCaller.validateGossipBlock)
+    .getBlockSlotState(parentRoot, blockHeader.slot, {dontTransferCache: true}, RegenCaller.validateGossipDataColumn)
     .catch(() => {
       throw new DataColumnSidecarGossipError(GossipAction.IGNORE, {
         code: DataColumnSidecarErrorCode.PARENT_UNKNOWN,

package/src/chain/validation/lightClientFinalityUpdate.ts

@@ -25,9 +25,10 @@ export function validateLightClientFinalityUpdate(
   }
 
   // [IGNORE] The finality_update is received after the block at signature_slot was given enough time to propagate
-  // through the network -- i.e. validate that one-third of finality_update.signature_slot has transpired
-  // (SECONDS_PER_SLOT / INTERVALS_PER_SLOT seconds after the start of the slot, with a MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance)
-  if (updateReceivedTooEarly(config, chain.genesisTime, gossipedFinalityUpdate)) {
+  // through the network -- i.e. validate that `get_sync_message_due_ms(epoch)`
+  // milliseconds (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) has
+  // transpired since the start of `signature_slot`.
+  if (updateReceivedTooEarly(config, chain.clock, gossipedFinalityUpdate)) {
     throw new LightClientError(GossipAction.IGNORE, {
       code: LightClientErrorCode.FINALITY_UPDATE_RECEIVED_TOO_EARLY,
     });

package/src/chain/validation/lightClientOptimisticUpdate.ts

@@ -1,8 +1,8 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {computeTimeAtSlot} from "@lodestar/state-transition";
 import {LightClientOptimisticUpdate} from "@lodestar/types";
 import {MAXIMUM_GOSSIP_CLOCK_DISPARITY} from "../../constants/index.js";
 import {assertLightClientServer} from "../../node/utils/lightclient.js";
+import {IClock} from "../../util/clock.js";
 import {GossipAction} from "../errors/index.js";
 import {LightClientError, LightClientErrorCode} from "../errors/lightClientError.js";
 import {IBeaconChain} from "../interface.js";
@@ -26,9 +26,10 @@ export function validateLightClientOptimisticUpdate(
   }
 
   // [IGNORE] The optimistic_update is received after the block at signature_slot was given enough time to propagate
-  // through the network -- i.e. validate that one-third of optimistic_update.signature_slot has transpired
-  // (SECONDS_PER_SLOT / INTERVALS_PER_SLOT seconds after the start of the slot, with a MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance)
-  if (updateReceivedTooEarly(config, chain.genesisTime, gossipedOptimisticUpdate)) {
+  // through the network -- i.e. validate that `get_sync_message_due_ms(epoch)`
+  // milliseconds (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) has
+  // transpired since the start of `signature_slot`.
+  if (updateReceivedTooEarly(config, chain.clock, gossipedOptimisticUpdate)) {
     throw new LightClientError(GossipAction.IGNORE, {
       code: LightClientErrorCode.OPTIMISTIC_UPDATE_RECEIVED_TOO_EARLY,
     });
@@ -48,20 +49,20 @@ export function validateLightClientOptimisticUpdate(
 /**
  * Returns true, if the spec condition below triggers an IGNORE.
  *
- *      Sig +1/3 time
+ *      Sig + SYNC_MESSAGE_DUE_BPS time
  * -----|-----
  * xxx|-------  (x is not okay)
  *
  * [IGNORE] The *update is received after the block at signature_slot was given enough time to propagate
- * through the network -- i.e. validate that one-third of *update.signature_slot has transpired
- * (SECONDS_PER_SLOT / INTERVALS_PER_SLOT seconds after the start of the slot, with a MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance)
+ * through the network -- i.e. validate that `get_sync_message_due_ms(epoch)`
+ * milliseconds (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance) has
+ * transpired since the start of `signature_slot`.
  */
 export function updateReceivedTooEarly(
   config: ChainForkConfig,
-  genesisTime: number,
+  clock: IClock,
   update: Pick<LightClientOptimisticUpdate, "signatureSlot">
 ): boolean {
-  const signatureSlot13TimestampMs = computeTimeAtSlot(config, update.signatureSlot + 1 / 3, genesisTime) * 1000;
-  const earliestAllowedTimestampMs = signatureSlot13TimestampMs - MAXIMUM_GOSSIP_CLOCK_DISPARITY;
-  return Date.now() < earliestAllowedTimestampMs;
+  const fork = config.getForkName(update.signatureSlot);
+  return clock.msFromSlot(update.signatureSlot) < config.getSyncMessageDueMs(fork) - MAXIMUM_GOSSIP_CLOCK_DISPARITY;
 }

package/src/chain/validatorMonitor.ts

@@ -1,11 +1,12 @@
-import {ChainConfig, ChainForkConfig} from "@lodestar/config";
-import {ForkSeq, INTERVALS_PER_SLOT, MIN_ATTESTATION_INCLUSION_DELAY, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {ChainForkConfig} from "@lodestar/config";
+import {ForkSeq, MIN_ATTESTATION_INCLUSION_DELAY, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
   CachedBeaconStateAltair,
   ParticipationFlags,
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
+  computeTimeAtSlot,
   getBlockRootAtSlot,
   getCurrentSlot,
   parseAttesterFlags,
@@ -34,8 +35,9 @@ const MAX_CACHED_EPOCHS = 4;
 
 const MAX_CACHED_DISTINCT_TARGETS = 4;
 
-const INTERVALS_LATE_ATTESTATION_SUBMISSION = 1.5;
-const INTERVALS_LATE_BLOCK_SUBMISSION = 0.75;
+// TODO GLOAS: re-evaluate these timings
+const LATE_ATTESTATION_SUBMISSION_BPS = 5000;
+const LATE_BLOCK_SUBMISSION_BPS = 2500;
 
 const RETAIN_REGISTERED_VALIDATORS_MS = 1 * 3600 * 1000; // 1 hour
 
@@ -450,8 +452,11 @@ export function createValidatorMonitor(
 
     onPoolSubmitUnaggregatedAttestation(seenTimestampSec, indexedAttestation, subnet, sentPeers) {
       const data = indexedAttestation.data;
-      // Returns the duration between when the attestation `data` could be produced (1/3rd through the slot) and `seenTimestamp`.
-      const delaySec = seenTimestampSec - (genesisTime + (data.slot + 1 / 3) * config.SECONDS_PER_SLOT);
+      const fork = config.getForkName(data.slot);
+      // Returns the duration between when the attestation `data` could be produced (ATTESTATION_DUE_BPS through the slot) and `seenTimestamp`.
+      const delaySec =
+        seenTimestampSec -
+        (computeTimeAtSlot(config, data.slot, genesisTime) + config.getAttestationDueMs(fork) / 1000);
       for (const index of indexedAttestation.attestingIndices) {
         const validator = validators.get(index);
         if (validator) {
@@ -483,8 +488,11 @@ export function createValidatorMonitor(
       const src = OpSource.gossip;
       const data = indexedAttestation.data;
       const epoch = computeEpochAtSlot(data.slot);
-      // Returns the duration between when the attestation `data` could be produced (1/3rd through the slot) and `seenTimestamp`.
-      const delaySec = seenTimestampSec - (genesisTime + (data.slot + 1 / 3) * config.SECONDS_PER_SLOT);
+      const fork = config.getForkName(data.slot);
+      // Returns the duration between when the attestation `data` could be produced (ATTESTATION_DUE_BPS through the slot) and `seenTimestamp`.
+      const delaySec =
+        seenTimestampSec -
+        (computeTimeAtSlot(config, data.slot, genesisTime) + config.getAttestationDueMs(fork) / 1000);
 
       for (const index of indexedAttestation.attestingIndices) {
         const validator = validators.get(index);
@@ -500,8 +508,10 @@ export function createValidatorMonitor(
 
     onPoolSubmitAggregatedAttestation(seenTimestampSec, indexedAttestation, sentPeers) {
       const data = indexedAttestation.data;
-      // Returns the duration between when a `AggregateAndproof` with `data` could be produced (2/3rd through the slot) and `seenTimestamp`.
-      const delaySec = seenTimestampSec - (genesisTime + (data.slot + 2 / 3) * config.SECONDS_PER_SLOT);
+      const fork = config.getForkName(data.slot);
+      // Returns the duration between when a `AggregateAndproof` with `data` could be produced (AGGREGATE_DUE_BPS through the slot) and `seenTimestamp`.
+      const delaySec =
+        seenTimestampSec - (computeTimeAtSlot(config, data.slot, genesisTime) + config.getAggregateDueMs(fork) / 1000);
 
       for (const index of indexedAttestation.attestingIndices) {
         const validator = validators.get(index);
@@ -527,8 +537,10 @@ export function createValidatorMonitor(
       const src = OpSource.gossip;
       const data = indexedAttestation.data;
       const epoch = computeEpochAtSlot(data.slot);
-      // Returns the duration between when a `AggregateAndProof` with `data` could be produced (2/3rd through the slot) and `seenTimestamp`.
-      const delaySec = seenTimestampSec - (genesisTime + (data.slot + 2 / 3) * config.SECONDS_PER_SLOT);
+      const fork = config.getForkName(data.slot);
+      // Returns the duration between when a `AggregateAndproof` with `data` could be produced (AGGREGATE_DUE_BPS through the slot) and `seenTimestamp`.
+      const delaySec =
+        seenTimestampSec - (computeTimeAtSlot(config, data.slot, genesisTime) + config.getAggregateDueMs(fork) / 1000);
 
       const aggregatorIndex = signedAggregateAndProof.message.aggregatorIndex;
       const validatorAggregator = validators.get(aggregatorIndex);
@@ -822,7 +834,7 @@ export function createValidatorMonitor(
  * - Was the attestation seen in a block?
  */
 function renderAttestationSummary(
-  config: ChainConfig,
+  config: ChainForkConfig,
   rootCache: RootHexCache,
   summary: AttestationSummary | undefined,
   flags: ParticipationFlags
@@ -925,8 +937,7 @@ function renderAttestationSummary(
   }
 
   const submittedLate =
-    summary.poolSubmitDelayMinSec >
-    (INTERVALS_LATE_ATTESTATION_SUBMISSION * config.SECONDS_PER_SLOT) / INTERVALS_PER_SLOT;
+    summary.poolSubmitDelayMinSec > config.getSlotComponentDurationMs(LATE_ATTESTATION_SUBMISSION_BPS) / 1000;
 
   const aggregateInclusion = summary.aggregateInclusionDelaysSec.length > 0;
 
@@ -1030,7 +1041,7 @@ function isMissedSlot(rootCache: RootHexCache, slot: Slot): boolean {
 }
 
 function renderBlockProposalSummary(
-  config: ChainConfig,
+  config: ChainForkConfig,
   rootCache: RootHexCache,
   summary: EpochSummary | undefined,
   proposalSlot: Slot
@@ -1053,7 +1064,7 @@ function renderBlockProposalSummary(
 
   if (
     proposal.poolSubmitDelaySec !== null &&
-    proposal.poolSubmitDelaySec > (INTERVALS_LATE_BLOCK_SUBMISSION * config.SECONDS_PER_SLOT) / INTERVALS_PER_SLOT
+    proposal.poolSubmitDelaySec > config.getSlotComponentDurationMs(LATE_BLOCK_SUBMISSION_BPS) / 1000
   ) {
     out += "_late";
   }

package/src/metrics/metrics/lodestar.ts

@@ -862,9 +862,9 @@ export function createLodestarMetrics(
         help: "Time elapsed between block slot time and the time block becomes head",
         buckets: [0.5, 1, 2, 4, 6, 12],
       }),
-      setHeadAfterFirstInterval: register.gauge({
-        name: "lodestar_import_block_set_head_after_first_interval_total",
-        help: "Total times an imported block is set as head after the first slot interval",
+      setHeadAfterCutoff: register.gauge({
+        name: "lodestar_import_block_set_head_after_cutoff_total",
+        help: "Total times an imported block is set as head after ATTESTATION_DUE_BPS of the slot",
       }),
       bySource: register.gauge<{source: BlockInputSource}>({
         name: "lodestar_import_block_by_source_total",

package/src/network/gossip/gossipsub.ts

@@ -105,7 +105,7 @@ export class Eth2Gossipsub extends GossipSub {
       mcacheLength: 6,
       mcacheGossip: 3,
       // this should be in ms
-      seenTTL: config.SECONDS_PER_SLOT * SLOTS_PER_EPOCH * 2 * 1000,
+      seenTTL: config.SLOT_DURATION_MS * SLOTS_PER_EPOCH * 2,
       scoreParams,
       scoreThresholds: gossipScoreThresholds,
       // For a single stream, await processing each RPC before processing the next

package/src/network/gossip/scoringParameters.ts

@@ -84,10 +84,10 @@ export function computeGossipPeerScoreParams({
   config: BeaconConfig;
   eth2Context: Eth2Context;
 }): Partial<PeerScoreParams> {
-  const decayIntervalMs = config.SECONDS_PER_SLOT * 1000;
+  const decayIntervalMs = config.SLOT_DURATION_MS;
   const decayToZero = 0.01;
-  const epochDurationMs = config.SECONDS_PER_SLOT * SLOTS_PER_EPOCH * 1000;
-  const slotDurationMs = config.SECONDS_PER_SLOT * 1000;
+  const epochDurationMs = config.SLOT_DURATION_MS * SLOTS_PER_EPOCH;
+  const slotDurationMs = config.SLOT_DURATION_MS;
   const scoreParameterDecayFn = (decayTimeMs: number): number => {
     return scoreParameterDecayWithBase(decayTimeMs, decayIntervalMs, decayToZero);
   };
@@ -265,7 +265,7 @@ function getTopicScoreParams(
 
   if (meshMessageInfo) {
     const {decaySlots, capFactor, activationWindow, currentSlot} = meshMessageInfo;
-    const decayTimeMs = config.SECONDS_PER_SLOT * decaySlots * 1000;
+    const decayTimeMs = config.SLOT_DURATION_MS * decaySlots;
     params.meshMessageDeliveriesDecay = scoreParameterDecayFn(decayTimeMs);
     params.meshMessageDeliveriesThreshold = threshold(params.meshMessageDeliveriesDecay, expectedMessageRate / 50);
     params.meshMessageDeliveriesCap = Math.max(capFactor * params.meshMessageDeliveriesThreshold, 2);

package/src/network/network.ts

@@ -7,7 +7,7 @@ import {BeaconConfig} from "@lodestar/config";
 import {LoggerNode} from "@lodestar/logger/node";
 import {ForkSeq} from "@lodestar/params";
 import {ResponseIncoming} from "@lodestar/reqresp";
-import {computeEpochAtSlot, computeTimeAtSlot} from "@lodestar/state-transition";
+import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {
   AttesterSlashing,
   LightClientBootstrap,
@@ -689,9 +689,9 @@ export class Network implements INetwork {
     // TODO: Review is OK to remove if (this.hasAttachedSyncCommitteeMember())
 
     try {
-      // messages SHOULD be broadcast after one-third of slot has transpired
+      // messages SHOULD be broadcast after SYNC_MESSAGE_DUE_BPS of slot has transpired
       // https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/light-client/p2p-interface.md#sync-committee
-      await this.waitOneThirdOfSlot(finalityUpdate.signatureSlot);
+      await this.waitForSyncMessageCutoff(finalityUpdate.signatureSlot);
       await this.publishLightClientFinalityUpdate(finalityUpdate);
     } catch (e) {
       // Non-mandatory route on most of network as of Oct 2022. May not have found any peers on topic yet
@@ -706,9 +706,9 @@ export class Network implements INetwork {
     // TODO: Review is OK to remove if (this.hasAttachedSyncCommitteeMember())
 
     try {
-      // messages SHOULD be broadcast after one-third of slot has transpired
+      // messages SHOULD be broadcast after SYNC_MESSAGE_DUE_BPS of slot has transpired
       // https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/light-client/p2p-interface.md#sync-committee
-      await this.waitOneThirdOfSlot(optimisticUpdate.signatureSlot);
+      await this.waitForSyncMessageCutoff(optimisticUpdate.signatureSlot);
       await this.publishLightClientOptimisticUpdate(optimisticUpdate);
     } catch (e) {
       // Non-mandatory route on most of network as of Oct 2022. May not have found any peers on topic yet
@@ -719,10 +719,10 @@ export class Network implements INetwork {
     }
   };
 
-  private waitOneThirdOfSlot = async (slot: number): Promise<void> => {
-    const secAtSlot = computeTimeAtSlot(this.config, slot + 1 / 3, this.chain.genesisTime);
-    const msToSlot = secAtSlot * 1000 - Date.now();
-    await sleep(msToSlot, this.controller.signal);
+  private waitForSyncMessageCutoff = async (slot: number): Promise<void> => {
+    const fork = this.config.getForkName(slot);
+    const msToCutoffTime = this.config.getSyncMessageDueMs(fork) - this.chain.clock.msFromSlot(slot);
+    await sleep(msToCutoffTime, this.controller.signal);
   };
 
   private onHead = async (): Promise<void> => {

package/src/network/peers/peerManager.ts

@@ -3,6 +3,7 @@ import {BitArray} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
 import {LoggerNode} from "@lodestar/logger/node";
 import {ForkSeq, SLOTS_PER_EPOCH, SYNC_COMMITTEE_SUBNET_COUNT} from "@lodestar/params";
+import {computeTimeAtSlot} from "@lodestar/state-transition";
 import {Metadata, Status, altair, fulu, phase0} from "@lodestar/types";
 import {prettyPrintIndices, toHex, withTimeout} from "@lodestar/utils";
 import {GOODBYE_KNOWN_CODES, GoodByeReasonCode, Libp2pEvent} from "../../constants/index.js";
@@ -599,7 +600,7 @@ export class PeerManager {
             subnet: query.subnet,
             type,
             maxPeersToDiscover: query.maxPeersToDiscover,
-            toUnixMs: 1000 * (this.clock.genesisTime + query.toSlot * this.config.SECONDS_PER_SLOT),
+            toUnixMs: computeTimeAtSlot(this.config, query.toSlot, this.clock.genesisTime) * 1000,
           });
         }
 

package/src/network/processor/gossipHandlers.ts

@@ -379,7 +379,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
 
     // Handler - MUST NOT `await`, to allow validation result to be propagated
 
-    const delaySec = seenTimestampSec - (chain.genesisTime + slot * config.SECONDS_PER_SLOT);
+    const delaySec = seenTimestampSec - computeTimeAtSlot(config, slot, chain.genesisTime);
     metrics?.gossipBlock.elapsedTimeTillReceived.observe({source: OpSource.gossip}, delaySec);
     chain.validatorMonitor?.registerBeaconBlock(OpSource.gossip, delaySec, signedBlock.message);
     if (!blockInput.hasBlockAndAllData()) {

package/src/network/subnets/attnetsService.ts

@@ -163,12 +163,9 @@ export class AttnetsService implements IAttnetsService {
    */
   private onSlot = (clockSlot: Slot): void => {
     try {
-      setTimeout(
-        () => {
-          this.onHalfSlot(clockSlot);
-        },
-        this.config.SECONDS_PER_SLOT * 0.5 * 1000
-      );
+      setTimeout(() => {
+        this.onHalfSlot(clockSlot);
+      }, this.config.SLOT_DURATION_MS * 0.5);
 
       for (const [dutiedSlot, dutiedInfo] of this.aggregatorSlotSubnet.entries()) {
         if (dutiedSlot === clockSlot + this.opts.slotsToSubscribeBeforeAggregatorDuty) {

package/src/node/notifier.ts

@@ -157,7 +157,7 @@ export async function runNodeNotifier(modules: NodeNotifierModules): Promise<voi
 }
 
 function timeToNextHalfSlot(config: BeaconConfig, chain: IBeaconChain, isFirstTime: boolean): number {
-  const msPerSlot = config.SECONDS_PER_SLOT * 1000;
+  const msPerSlot = config.SLOT_DURATION_MS;
   const msPerHalfSlot = msPerSlot / 2;
   const msFromGenesis = Date.now() - chain.genesisTime * 1000;
   const msToNextSlot =

package/src/sync/unknownBlock.ts

@@ -1,6 +1,7 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {ForkSeq, INTERVALS_PER_SLOT} from "@lodestar/params";
+import {ForkSeq} from "@lodestar/params";
 import {RequestError, RequestErrorCode} from "@lodestar/reqresp";
+import {computeTimeAtSlot} from "@lodestar/state-transition";
 import {RootHex} from "@lodestar/types";
 import {Logger, prettyPrintIndices, pruneSetToMax, sleep} from "@lodestar/utils";
 import {isBlockInputBlobs, isBlockInputColumns} from "../chain/blocks/blockInput/blockInput.js";
@@ -78,7 +79,6 @@ export class BlockInputSync {
    */
   private readonly pendingBlocks = new Map<RootHex, BlockInputSyncCacheItem>();
   private readonly knownBadBlocks = new Set<RootHex>();
-  private readonly proposerBoostSecWindow: number;
   private readonly maxPendingBlocks;
   private subscribedToNetworkEvents = false;
   private peerBalancer: UnknownBlockPeerBalancer;
@@ -92,7 +92,6 @@ export class BlockInputSync {
     private readonly opts?: SyncOptions
   ) {
     this.maxPendingBlocks = opts?.maxPendingBlocks ?? MAX_PENDING_BLOCKS;
-    this.proposerBoostSecWindow = this.config.SECONDS_PER_SLOT / INTERVALS_PER_SLOT;
     this.peerBalancer = new UnknownBlockPeerBalancer();
 
     if (metrics) {
@@ -331,7 +330,7 @@ export class BlockInputSync {
       this.pendingBlocks.set(pending.blockInput.blockRootHex, pending);
       const blockSlot = pending.blockInput.slot;
       const finalizedSlot = this.chain.forkChoice.getFinalizedBlock().slot;
-      const delaySec = Date.now() / 1000 - (this.chain.genesisTime + blockSlot * this.config.SECONDS_PER_SLOT);
+      const delaySec = Date.now() / 1000 - computeTimeAtSlot(this.config, blockSlot, this.chain.genesisTime);
       this.metrics?.blockInputSync.elapsedTimeTillReceived.observe(delaySec);
 
       const parentInForkChoice = this.chain.forkChoice.hasBlockHex(pending.blockInput.parentRootHex);
@@ -396,8 +395,10 @@ export class BlockInputSync {
     // this prevents unbundling attack
     // see https://lighthouse-blog.sigmaprime.io/mev-unbundling-rpc.html
     const {slot: blockSlot, proposerIndex} = pendingBlock.blockInput.getBlock().message;
+    const fork = this.config.getForkName(blockSlot);
+    const proposerBoostWindowMs = this.config.getAttestationDueMs(fork);
     if (
-      this.chain.clock.secFromSlot(blockSlot) < this.proposerBoostSecWindow &&
+      this.chain.clock.msFromSlot(blockSlot) < proposerBoostWindowMs &&
       this.chain.seenBlockProposers.isKnown(blockSlot, proposerIndex)
     ) {
       // proposer is known by a gossip block already, wait a bit to make sure this block is not
@@ -407,7 +408,7 @@ export class BlockInputSync {
         root: pendingBlock.blockInput.blockRootHex,
         proposerIndex,
       });
-      await sleep(this.proposerBoostSecWindow * 1000);
+      await sleep(proposerBoostWindowMs);
     }
     // At gossip time, it's critical to keep a good number of mesh peers.
     // To do that, the Gossip Job Wait Time should be consistently <3s to avoid the behavior penalties in gossip

package/src/sync/utils/downloadByRange.ts

@@ -1,5 +1,5 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {ForkPostDeneb, ForkPostFulu} from "@lodestar/params";
+import {ForkPostDeneb, ForkPostFulu, ForkPreFulu, ForkPreGloas} from "@lodestar/params";
 import {SignedBeaconBlock, Slot, deneb, fulu, phase0} from "@lodestar/types";
 import {LodestarError, Logger, fromHex, prettyBytes, prettyPrintIndices, toRootHex} from "@lodestar/utils";
 import {
@@ -458,14 +458,16 @@ export function validateBlockByRangeResponse(
 }
 
 /**
- * Should not be called directly. Only exported for unit testing purposes
+ * Should not be called directly. Only exported for unit testing purposes.
+ * This is used only in Deneb and Electra
  */
 export async function validateBlobsByRangeResponse(
   dataRequestBlocks: ValidatedBlock[],
   blobSidecars: deneb.BlobSidecars
 ): Promise<ValidatedBlobSidecars[]> {
   const expectedBlobCount = dataRequestBlocks.reduce(
-    (acc, {block}) => (block as SignedBeaconBlock<ForkPostDeneb>).message.body.blobKzgCommitments.length + acc,
+    (acc, {block}) =>
+      (block as SignedBeaconBlock<ForkPostDeneb & ForkPreFulu>).message.body.blobKzgCommitments.length + acc,
     0
   );
   if (blobSidecars.length > expectedBlobCount) {
@@ -492,7 +494,8 @@ export async function validateBlobsByRangeResponse(
   const validateSidecarsPromises: Promise<ValidatedBlobSidecars>[] = [];
   for (let blockIndex = 0, blobSidecarIndex = 0; blockIndex < dataRequestBlocks.length; blockIndex++) {
     const {block, blockRoot} = dataRequestBlocks[blockIndex];
-    const blockKzgCommitments = (block as SignedBeaconBlock<ForkPostDeneb>).message.body.blobKzgCommitments;
+    const blockKzgCommitments = (block as SignedBeaconBlock<ForkPostDeneb & ForkPreFulu>).message.body
+      .blobKzgCommitments;
     if (blockKzgCommitments.length === 0) {
       continue;
     }
@@ -532,8 +535,9 @@ export async function validateColumnsByRangeResponse(
   columnSidecars: fulu.DataColumnSidecars
 ): Promise<WarnResult<ValidatedColumnSidecars[], DownloadByRangeError>> {
   // Expected column count considering currently-validated batch blocks
+  // TODO GLOAS: Post-gloas's blobKzgCommitments is not in beacon block body. Need to source it from somewhere else.
   const expectedColumnCount = dataRequestBlocks.reduce((acc, {block}) => {
-    return (block as SignedBeaconBlock<ForkPostDeneb>).message.body.blobKzgCommitments.length > 0
+    return (block as SignedBeaconBlock<ForkPostDeneb & ForkPreGloas>).message.body.blobKzgCommitments.length > 0
       ? request.columns.length + acc
       : acc;
   }, 0);
@@ -566,7 +570,9 @@ export async function validateColumnsByRangeResponse(
     const {block, blockRoot} = dataRequestBlocks[blockIndex];
     const slot = block.message.slot;
     const blockRootHex = toRootHex(blockRoot);
-    const blockKzgCommitments = (block as SignedBeaconBlock<ForkPostFulu>).message.body.blobKzgCommitments;
+    // TODO GLOAS: Post-gloas's blobKzgCommitments is not in beacon block body. Need to source it from somewhere else.
+    const blockKzgCommitments = (block as SignedBeaconBlock<ForkPostFulu & ForkPreGloas>).message.body
+      .blobKzgCommitments;
     const expectedColumns = blockKzgCommitments.length ? request.columns.length : 0;
 
     if (expectedColumns === 0) {

package/src/sync/utils/downloadByRoot.ts

@@ -1,7 +1,14 @@
 import {routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
-import {ForkPostDeneb, ForkPostFulu, ForkPreFulu, isForkPostDeneb, isForkPostFulu} from "@lodestar/params";
-import {BlobIndex, ColumnIndex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
+import {
+  ForkPostDeneb,
+  ForkPostFulu,
+  ForkPreFulu,
+  ForkPreGloas,
+  isForkPostDeneb,
+  isForkPostFulu,
+} from "@lodestar/params";
+import {BeaconBlockBody, BlobIndex, ColumnIndex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
 import {LodestarError, fromHex, prettyBytes, prettyPrintIndices, toHex, toRootHex} from "@lodestar/utils";
 import {isBlockInputBlobs, isBlockInputColumns} from "../../chain/blocks/blockInput/blockInput.js";
 import {BlockInputSource, IBlockInput} from "../../chain/blocks/blockInput/types.js";
@@ -269,7 +276,7 @@ export async function fetchByRoot({
         missing: network.custodyConfig.sampledColumns,
       });
     } else if (isForkPostDeneb(forkName)) {
-      const commitments = (block as SignedBeaconBlock<ForkPostDeneb>).message.body.blobKzgCommitments;
+      const commitments = (block as SignedBeaconBlock<ForkPostDeneb & ForkPreFulu>).message.body.blobKzgCommitments;
       const blobCount = commitments.length;
       blobSidecars = await fetchAndValidateBlobs({
         config,
@@ -369,7 +376,8 @@ export async function fetchAndValidateColumns({
 }: FetchByRootAndValidateColumnsProps): Promise<WarnResult<fulu.DataColumnSidecars, DownloadByRootError>> {
   const {peerId: peerIdStr} = peerMeta;
   const slot = block.message.slot;
-  const blobCount = block.message.body.blobKzgCommitments.length;
+  // TODO GLOAS: Get blob count from somewhere else since blobKzgCommitments is absent from block body
+  const blobCount = (block.message.body as BeaconBlockBody<ForkPostFulu & ForkPreGloas>).blobKzgCommitments.length;
   if (blobCount === 0) {
     return {result: [], warnings: null};
   }