@lodestar/beacon-node 1.35.0-dev.8689cc3545 → 1.35.0-dev.894daf8b44

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/processor/index.ts

@@ -230,14 +230,13 @@ export class NetworkProcessor {
     return queue.getAll();
   }
 
-  searchUnknownSlotRoot(slotRoot: SlotRootHex, source: BlockInputSource, peer?: PeerIdStr): void {
-    const {slot, root} = slotRoot;
+  searchUnknownSlotRoot({slot, root}: SlotRootHex, source: BlockInputSource, peer?: PeerIdStr): void {
     if (this.chain.seenBlock(root) || this.unknownRootsBySlot.getOrDefault(slot).has(root)) {
       return;
     }
     // Search for the unknown block
     this.unknownRootsBySlot.getOrDefault(slot).add(root);
-    this.chain.emitter.emit(ChainEvent.unknownBlockRoot, {rootSlot: slotRoot, peer, source});
+    this.chain.emitter.emit(ChainEvent.unknownBlockRoot, {rootHex: root, peer, source});
   }
 
   private onPendingGossipsubMessage(message: PendingGossipsubMessage): void {

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/types.ts

@@ -37,8 +37,6 @@ export type PendingBlockInput = {
 export type PendingRootHex = {
   status: PendingBlockInputStatus.pending | PendingBlockInputStatus.fetching;
   rootHex: RootHex;
-  // optional because we may not know the slot of parent_unknown event
-  slot?: Slot;
   timeAddedSec: number;
   timeSyncedSec?: number;
   peerIdStrings: Set<string>;

package/src/sync/unknownBlock.ts

@@ -1,8 +1,9 @@
 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 {RootHex, Slot} from "@lodestar/types";
-import {Logger, prettyBytes, prettyPrintIndices, pruneSetToMax, sleep} from "@lodestar/utils";
+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";
 import {BlockInputSource, IBlockInput} from "../chain/blocks/blockInput/types.js";
 import {BlockError, BlockErrorCode} from "../chain/errors/index.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) {
@@ -146,8 +145,7 @@ export class BlockInputSync {
    */
   private onUnknownBlockRoot = (data: ChainEventData[ChainEvent.unknownBlockRoot]): void => {
     try {
-      const {root, slot} = data.rootSlot;
-      this.addByRootHex(root, slot, data.peer);
+      this.addByRootHex(data.rootHex, data.peer);
       this.triggerUnknownBlockSearch();
       this.metrics?.blockInputSync.requests.inc({type: PendingBlockType.UNKNOWN_BLOCK_ROOT});
       this.metrics?.blockInputSync.source.inc({source: data.source});
@@ -175,8 +173,7 @@ export class BlockInputSync {
    */
   private onUnknownParent = (data: ChainEventData[ChainEvent.unknownParent]): void => {
     try {
-      // we don't know the slot of parent, hence make it undefined
-      this.addByRootHex(data.blockInput.parentRootHex, undefined, data.peer);
+      this.addByRootHex(data.blockInput.parentRootHex, data.peer);
       this.addByBlockInput(data.blockInput, data.peer);
       this.triggerUnknownBlockSearch();
       this.metrics?.blockInputSync.requests.inc({type: PendingBlockType.UNKNOWN_PARENT});
@@ -186,12 +183,11 @@ export class BlockInputSync {
     }
   };
 
-  private addByRootHex = (rootHex: RootHex, slot?: Slot, peerIdStr?: PeerIdStr): void => {
+  private addByRootHex = (rootHex: RootHex, peerIdStr?: PeerIdStr): void => {
     let pendingBlock = this.pendingBlocks.get(rootHex);
     if (!pendingBlock) {
       pendingBlock = {
         status: PendingBlockInputStatus.pending,
-        slot,
         rootHex: rootHex,
         peerIdStrings: new Set(),
         timeAddedSec: Date.now() / 1000,
@@ -199,7 +195,7 @@ export class BlockInputSync {
       this.pendingBlocks.set(rootHex, pendingBlock);
 
       this.logger.verbose("Added new rootHex to BlockInputSync.pendingBlocks", {
-        rootHex: prettyBytes(pendingBlock.rootHex),
+        root: pendingBlock.rootHex,
         peerIdStr: peerIdStr ?? "unknown peer",
       });
     }
@@ -318,7 +314,7 @@ export class BlockInputSync {
     const rootHex = getBlockInputSyncCacheItemRootHex(block);
     const logCtx = {
       slot: getBlockInputSyncCacheItemSlot(block),
-      blockRoot: prettyBytes(rootHex),
+      root: rootHex,
       pendingBlocks: this.pendingBlocks.size,
     };
 
@@ -334,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);
@@ -362,7 +358,7 @@ export class BlockInputSync {
         });
         this.removeAndDownScoreAllDescendants(block);
       } else {
-        this.onUnknownBlockRoot({rootSlot: {root: pending.blockInput.parentRootHex}, source: BlockInputSource.byRoot});
+        this.onUnknownBlockRoot({rootHex: pending.blockInput.parentRootHex, source: BlockInputSource.byRoot});
       }
     } else {
       this.metrics?.blockInputSync.downloadedBlocksError.inc();
@@ -399,18 +395,20 @@ 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
       // eligible for proposer boost to prevent unbundling attack
       this.logger.verbose("Avoid proposer boost for this block of known proposer", {
         slot: blockSlot,
-        blockRoot: prettyBytes(pendingBlock.blockInput.blockRootHex),
+        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
@@ -500,7 +498,7 @@ export class BlockInputSync {
         : null;
 
     const fetchStartSec = Date.now() / 1000;
-    let slot = isPendingBlockInput(cacheItem) ? cacheItem.blockInput.slot : cacheItem.slot;
+    let slot = isPendingBlockInput(cacheItem) ? cacheItem.blockInput.slot : undefined;
     if (slot !== undefined) {
       this.metrics?.blockInputSync.fetchBegin.observe(this.chain.clock.secFromSlot(slot, fetchStartSec));
     }
@@ -515,7 +513,7 @@ export class BlockInputSync {
       const peerMeta = this.peerBalancer.bestPeerForPendingColumns(pendingColumns, excludedPeers);
       if (peerMeta === null) {
         // no more peer with needed columns to try, throw error
-        let message = `Error fetching UnknownBlockRoot slot=${slot} blockRoot=${prettyBytes(rootHex)} after ${i}: cannot find peer`;
+        let message = `Error fetching UnknownBlockRoot slot=${slot} root=${rootHex} after ${i}: cannot find peer`;
         if (pendingColumns) {
           message += ` with needed columns=${prettyPrintIndices(Array.from(pendingColumns))}`;
         }
@@ -605,7 +603,7 @@ export class BlockInputSync {
       }
     } // end while loop over peers
 
-    const message = `Error fetching BlockInput with slot=${slot} blockRoot=${prettyBytes(rootHex)} after ${i - 1} attempts.`;
+    const message = `Error fetching BlockInput with slot=${slot} root=${rootHex} after ${i - 1} attempts.`;
 
     if (!isPendingBlockInput(cacheItem)) {
       throw Error(`${message} No block and no data was found.`);

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};
   }

package/src/util/clock.ts

@@ -9,12 +9,12 @@ import {MAXIMUM_GOSSIP_CLOCK_DISPARITY} from "../constants/constants.js";
 export enum ClockEvent {
   /**
    * This event signals the start of a new slot, and that subsequent calls to `clock.currentSlot` will equal `slot`.
-   * This event is guaranteed to be emitted every `SECONDS_PER_SLOT` seconds.
+   * This event is guaranteed to be emitted every `SLOT_DURATION_MS` milliseconds.
    */
   slot = "clock:slot",
   /**
    * This event signals the start of a new epoch, and that subsequent calls to `clock.currentEpoch` will return `epoch`.
-   * This event is guaranteed to be emitted every `SECONDS_PER_SLOT * SLOTS_PER_EPOCH` seconds.
+   * This event is guaranteed to be emitted every `SLOT_DURATION_MS * SLOTS_PER_EPOCH` milliseconds.
    */
   epoch = "clock:epoch",
 }
@@ -29,7 +29,7 @@ export type ClockEvents = {
  *
  * The time is dependent on:
  * - `state.genesisTime` - the genesis time
- * - `SECONDS_PER_SLOT` - # of seconds per slot
+ * - `SLOT_DURATION_MS` - # of milliseconds per slot
  * - `SLOTS_PER_EPOCH` - # of slots per epoch
  */
 export type IClock = StrictEventEmitter<EventEmitter, ClockEvents> & {
@@ -58,6 +58,10 @@ export type IClock = StrictEventEmitter<EventEmitter, ClockEvents> & {
    * Return second from a slot to either toSec or now.
    */
   secFromSlot(slot: Slot, toSec?: number): number;
+  /**
+   * Return milliseconds from a slot to either toMs or now.
+   */
+  msFromSlot(slot: Slot, toMs?: number): number;
 };
 
 /**
@@ -170,12 +174,16 @@ export class Clock extends EventEmitter implements IClock {
   }
 
   secFromSlot(slot: Slot, toSec = Date.now() / 1000): number {
-    return toSec - (this.genesisTime + slot * this.config.SECONDS_PER_SLOT);
+    return toSec - computeTimeAtSlot(this.config, slot, this.genesisTime);
+  }
+
+  msFromSlot(slot: Slot, toMs = Date.now()): number {
+    return toMs - computeTimeAtSlot(this.config, slot, this.genesisTime) * 1000;
   }
 
   private onNextSlot = (slot?: Slot): void => {
     const clockSlot = slot ?? getCurrentSlot(this.config, this.genesisTime);
-    // process multiple clock slots in the case the main thread has been saturated for > SECONDS_PER_SLOT
+    // process multiple clock slots in the case the main thread has been saturated for > SLOT_DURATION_MS
     while (this._currentSlot < clockSlot && !this.signal.aborted) {
       const previousSlot = this._currentSlot;
       this._currentSlot++;
@@ -197,7 +205,7 @@ export class Clock extends EventEmitter implements IClock {
   };
 
   private msUntilNextSlot(): number {
-    const milliSecondsPerSlot = this.config.SECONDS_PER_SLOT * 1000;
+    const milliSecondsPerSlot = this.config.SLOT_DURATION_MS;
     const diffInMilliSeconds = Date.now() - this.genesisTime * 1000;
     return milliSecondsPerSlot - (diffInMilliSeconds % milliSecondsPerSlot);
   }

package/src/util/dataColumns.ts

@@ -1,7 +1,14 @@
 import {digest} from "@chainsafe/as-sha256";
 import {Tree} from "@chainsafe/persistent-merkle-tree";
 import {ChainForkConfig} from "@lodestar/config";
-import {ForkAll, ForkName, ForkPostFulu, KZG_COMMITMENTS_GINDEX, NUMBER_OF_COLUMNS} from "@lodestar/params";
+import {
+  ForkAll,
+  ForkName,
+  ForkPostFulu,
+  ForkPreGloas,
+  KZG_COMMITMENTS_GINDEX,
+  NUMBER_OF_COLUMNS,
+} from "@lodestar/params";
 import {signedBlockToSignedHeader} from "@lodestar/state-transition";
 import {
   BeaconBlockBody,
@@ -303,7 +310,9 @@ export function getDataColumnSidecarsFromBlock(
   signedBlock: SignedBeaconBlock<ForkPostFulu>,
   cellsAndKzgProofs: {cells: Uint8Array[]; proofs: Uint8Array[]}[]
 ): fulu.DataColumnSidecars {
-  const blobKzgCommitments = signedBlock.message.body.blobKzgCommitments;
+  // TODO GLOAS: Need to get blobKzgCommitments from somewhere else
+  const blobKzgCommitments = (signedBlock.message.body as BeaconBlockBody<ForkPostFulu & ForkPreGloas>)
+    .blobKzgCommitments;
 
   // No need to create data column sidecars if there are no blobs
   if (blobKzgCommitments.length === 0) {