@lodestar/beacon-node 1.35.0-dev.ba92bd8a88 → 1.35.0-dev.be3c5220f4

package/src/api/impl/validator/index.ts

@@ -5,6 +5,7 @@ import {ExecutionStatus} from "@lodestar/fork-choice";
 import {
   ForkName,
   ForkPostBellatrix,
+  ForkPreGloas,
   ForkSeq,
   GENESIS_SLOT,
   SLOTS_PER_EPOCH,
@@ -22,6 +23,7 @@ import {
   calculateCommitteeAssignments,
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
+  computeTimeAtSlot,
   createCachedBeaconState,
   getBlockRootAtSlot,
   getCurrentSlot,
@@ -66,7 +68,7 @@ import {
   SyncCommitteeErrorCode,
 } from "../../../chain/errors/index.js";
 import {ChainEvent, CheckpointHex, CommonBlockBody} from "../../../chain/index.js";
-import {SCHEDULER_LOOKAHEAD_FACTOR} from "../../../chain/prepareNextSlot.js";
+import {PREPARE_NEXT_SLOT_BPS} from "../../../chain/prepareNextSlot.js";
 import {BlockType, ProduceFullDeneb} from "../../../chain/produceBlock/index.js";
 import {RegenCaller} from "../../../chain/regen/index.js";
 import {validateApiAggregateAndProof} from "../../../chain/validation/index.js";
@@ -82,7 +84,7 @@ import {getDefaultGraffiti, toGraffitiBytes} from "../../../util/graffiti.js";
 import {getLodestarClientVersion} from "../../../util/metadata.js";
 import {ApiOptions} from "../../options.js";
 import {getStateResponseWithRegen} from "../beacon/state/utils.js";
-import {ApiError, NodeIsSyncing, OnlySupportedByDVT} from "../errors.js";
+import {ApiError, FailureList, IndexedError, NodeIsSyncing, OnlySupportedByDVT} from "../errors.js";
 import {ApiModules} from "../types.js";
 import {computeSubnetForCommitteesAtSlot, getPubkeysForIndices, selectBlockProductionSource} from "./utils.js";
 
@@ -108,6 +110,8 @@ export const SYNC_TOLERANCE_EPOCHS = 1;
  * Empirically the builder block resolves in ~1 second, and execution block resolves in <500 ms.
  * A cutoff of 2 seconds gives enough time and if there are unexpected delays it ensures we publish
  * in time as proposals post 4 seconds into the slot will likely be orphaned due to proposer boost reorg.
+ *
+ * TODO GLOAS: re-evaluate cutoff timing
  */
 const BLOCK_PRODUCTION_RACE_CUTOFF_MS = 2_000;
 /** Overall timeout for execution and block production apis */
@@ -178,7 +182,7 @@ export function getValidatorApi(
    * This value is the same to MAXIMUM_GOSSIP_CLOCK_DISPARITY_SEC.
    * For very fast networks, reduce clock disparity to half a slot.
    */
-  const MAX_API_CLOCK_DISPARITY_SEC = Math.min(0.5, config.SECONDS_PER_SLOT / 2);
+  const MAX_API_CLOCK_DISPARITY_SEC = Math.min(0.5, config.SLOT_DURATION_MS / 2000);
   const MAX_API_CLOCK_DISPARITY_MS = MAX_API_CLOCK_DISPARITY_SEC * 1000;
 
   /** Compute and cache the genesis block root */
@@ -211,7 +215,7 @@ export function getValidatorApi(
       return;
     }
 
-    const slotStartSec = chain.genesisTime + slot * config.SECONDS_PER_SLOT;
+    const slotStartSec = computeTimeAtSlot(config, slot, chain.genesisTime);
     const msToSlot = slotStartSec * 1000 - Date.now();
 
     if (msToSlot > MAX_API_CLOCK_DISPARITY_MS) {
@@ -242,7 +246,7 @@ export function getValidatorApi(
    */
   function msToNextEpoch(): number {
     const nextEpoch = chain.clock.currentEpoch + 1;
-    const secPerEpoch = SLOTS_PER_EPOCH * config.SECONDS_PER_SLOT;
+    const secPerEpoch = (SLOTS_PER_EPOCH * config.SLOT_DURATION_MS) / 1000;
     const nextEpochStartSec = chain.genesisTime + nextEpoch * secPerEpoch;
     return nextEpochStartSec * 1000 - Date.now();
   }
@@ -407,11 +411,9 @@ export function getValidatorApi(
     {
       commonBlockBodyPromise,
       parentBlockRoot,
-      parentSlot,
     }: Omit<routes.validator.ExtraProduceBlockOpts, "builderSelection"> & {
       commonBlockBodyPromise: Promise<CommonBlockBody>;
       parentBlockRoot: Root;
-      parentSlot: Slot;
     }
   ): Promise<ProduceBlindedBlockRes> {
     const version = config.getForkName(slot);
@@ -443,7 +445,6 @@ export function getValidatorApi(
       const {block, executionPayloadValue, consensusBlockValue} = await chain.produceBlindedBlock({
         slot,
         parentBlockRoot,
-        parentSlot,
         randaoReveal,
         graffiti,
         commonBlockBodyPromise,
@@ -479,11 +480,9 @@ export function getValidatorApi(
       strictFeeRecipientCheck,
       commonBlockBodyPromise,
       parentBlockRoot,
-      parentSlot,
     }: Omit<routes.validator.ExtraProduceBlockOpts, "builderSelection"> & {
       commonBlockBodyPromise: Promise<CommonBlockBody>;
       parentBlockRoot: Root;
-      parentSlot: Slot;
     }
   ): Promise<ProduceBlockContentsRes & {shouldOverrideBuilder?: boolean}> {
     const source = ProducedBlockSource.engine;
@@ -495,7 +494,6 @@ export function getValidatorApi(
       const {block, executionPayloadValue, consensusBlockValue, shouldOverrideBuilder} = await chain.produceBlock({
         slot,
         parentBlockRoot,
-        parentSlot,
         randaoReveal,
         graffiti,
         feeRecipient,
@@ -638,7 +636,6 @@ export function getValidatorApi(
           strictFeeRecipientCheck: false,
           commonBlockBodyPromise,
           parentBlockRoot,
-          parentSlot,
         })
       : Promise.reject(new Error("Builder disabled"));
 
@@ -648,7 +645,6 @@ export function getValidatorApi(
           strictFeeRecipientCheck,
           commonBlockBodyPromise,
           parentBlockRoot,
-          parentSlot,
         }).then((engineBlock) => {
           // Once the engine returns a block, in the event of either:
           // - suspected builder censorship
@@ -666,7 +662,7 @@ export function getValidatorApi(
       : Promise.reject(new Error("Engine disabled"));
 
     // Calculate cutoff time based on start of the slot
-    const cutoffMs = Math.max(0, BLOCK_PRODUCTION_RACE_CUTOFF_MS - Math.round(chain.clock.secFromSlot(slot) * 1000));
+    const cutoffMs = Math.max(0, BLOCK_PRODUCTION_RACE_CUTOFF_MS - chain.clock.msFromSlot(slot));
 
     logger.verbose("Block production race (builder vs execution) starting", {
       ...loggerContext,
@@ -691,7 +687,6 @@ export function getValidatorApi(
         .produceCommonBlockBody({
           slot,
           parentBlockRoot,
-          parentSlot,
           randaoReveal,
           graffiti: graffitiBytes,
         })
@@ -884,13 +879,14 @@ export function getValidatorApi(
         opts
       );
 
-      if (opts.blindedLocal === true && ForkSeq[meta.version] >= ForkSeq.bellatrix) {
+      const fork = ForkSeq[meta.version];
+      if (opts.blindedLocal === true && fork >= ForkSeq.bellatrix && fork < ForkSeq.gloas) {
         if (meta.executionPayloadBlinded) {
           return {data, meta};
         }
 
         const {block} = data as BlockContents;
-        const blindedBlock = beaconBlockToBlinded(config, block as BeaconBlock<ForkPostBellatrix>);
+        const blindedBlock = beaconBlockToBlinded(config, block as BeaconBlock<ForkPostBellatrix & ForkPreGloas>);
         return {
           data: blindedBlock,
           meta: {...meta, executionPayloadBlinded: true},
@@ -1016,8 +1012,8 @@ export function getValidatorApi(
       const head = chain.forkChoice.getHead();
       let state: CachedBeaconStateAllForks | undefined = undefined;
       const startSlot = computeStartSlotAtEpoch(epoch);
-      const slotMs = config.SECONDS_PER_SLOT * 1000;
-      const prepareNextSlotLookAheadMs = slotMs / SCHEDULER_LOOKAHEAD_FACTOR;
+      const prepareNextSlotLookAheadMs =
+        config.SLOT_DURATION_MS - config.getSlotComponentDurationMs(PREPARE_NEXT_SLOT_BPS);
       const toNextEpochMs = msToNextEpoch();
       // validators may request next epoch's duties when it's close to next epoch
       // this is to avoid missed block proposal due to 0 epoch look ahead
@@ -1290,7 +1286,7 @@ export function getValidatorApi(
       notWhileSyncing();
 
       const seenTimestampSec = Date.now() / 1000;
-      const errors: Error[] = [];
+      const failures: FailureList = [];
       const fork = chain.config.getForkName(chain.clock.currentSlot);
 
       await Promise.all(
@@ -1326,8 +1322,8 @@ export function getValidatorApi(
               return; // Ok to submit the same aggregate twice
             }
 
-            errors.push(e as Error);
-            logger.error(`Error on publishAggregateAndProofs [${i}]`, logCtx, e as Error);
+            failures.push({index: i, message: (e as Error).message});
+            logger.verbose(`Error on publishAggregateAndProofs [${i}]`, logCtx, e as Error);
             if (e instanceof AttestationError && e.action === GossipAction.REJECT) {
               chain.persistInvalidSszValue(ssz.phase0.SignedAggregateAndProof, signedAggregateAndProof, "api_reject");
             }
@@ -1335,12 +1331,8 @@ export function getValidatorApi(
         })
       );
 
-      if (errors.length > 1) {
-        throw Error("Multiple errors on publishAggregateAndProofs\n" + errors.map((e) => e.message).join("\n"));
-      }
-
-      if (errors.length === 1) {
-        throw errors[0];
+      if (failures.length > 0) {
+        throw new IndexedError("Error processing aggregate and proofs", failures);
       }
     },
 
@@ -1354,7 +1346,7 @@ export function getValidatorApi(
     async publishContributionAndProofs({contributionAndProofs}) {
       notWhileSyncing();
 
-      const errors: Error[] = [];
+      const failures: FailureList = [];
 
       await Promise.all(
         contributionAndProofs.map(async (contributionAndProof, i) => {
@@ -1386,8 +1378,8 @@ export function getValidatorApi(
               return; // Ok to submit the same aggregate twice
             }
 
-            errors.push(e as Error);
-            logger.error(`Error on publishContributionAndProofs [${i}]`, logCtx, e as Error);
+            failures.push({index: i, message: (e as Error).message});
+            logger.verbose(`Error on publishContributionAndProofs [${i}]`, logCtx, e as Error);
             if (e instanceof SyncCommitteeError && e.action === GossipAction.REJECT) {
               chain.persistInvalidSszValue(ssz.altair.SignedContributionAndProof, contributionAndProof, "api_reject");
             }
@@ -1395,12 +1387,8 @@ export function getValidatorApi(
         })
       );
 
-      if (errors.length > 1) {
-        throw Error("Multiple errors on publishContributionAndProofs\n" + errors.map((e) => e.message).join("\n"));
-      }
-
-      if (errors.length === 1) {
-        throw errors[0];
+      if (failures.length > 0) {
+        throw new IndexedError("Error processing contribution and proofs", failures);
       }
     },
 

package/src/chain/blocks/blockInput/blockInput.ts

@@ -1,5 +1,5 @@
-import {ForkName, ForkPreDeneb} from "@lodestar/params";
-import {BlobIndex, ColumnIndex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
+import {ForkName, ForkPostFulu, ForkPreDeneb, ForkPreGloas} from "@lodestar/params";
+import {BeaconBlockBody, BlobIndex, ColumnIndex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
 import {fromHex, prettyBytes, toRootHex, withTimeout} from "@lodestar/utils";
 import {VersionedHashes} from "../../../execution/index.js";
 import {kzgCommitmentToVersionedHash} from "../../../util/blobs.js";
@@ -652,7 +652,8 @@ export class BlockInputColumns extends AbstractBlockInput<ForkColumnsDA, fulu.Da
   static createFromColumn(
     props: AddColumn & CreateBlockInputMeta & {sampledColumns: ColumnIndex[]; custodyColumns: ColumnIndex[]}
   ): BlockInputColumns {
-    const hasAllData = props.sampledColumns.length === 0;
+    const hasAllData =
+      props.daOutOfRange || props.columnSidecar.kzgCommitments.length === 0 || props.sampledColumns.length === 0;
     const state: BlockInputColumnsState = {
       hasBlock: false,
       hasAllData,
@@ -714,7 +715,9 @@ export class BlockInputColumns extends AbstractBlockInput<ForkColumnsDA, fulu.Da
       );
     }
 
-    const hasAllData = props.block.message.body.blobKzgCommitments.length === 0 || this.state.hasAllData;
+    const hasAllData =
+      (props.block.message.body as BeaconBlockBody<ForkPostFulu & ForkPreGloas>).blobKzgCommitments.length === 0 ||
+      this.state.hasAllData;
 
     this.state = {
       ...this.state,

package/src/chain/blocks/importBlock.ts

@@ -7,20 +7,14 @@ import {
   ForkChoiceErrorCode,
   NotReorgedReason,
 } from "@lodestar/fork-choice";
-import {
-  ForkPostAltair,
-  ForkPostElectra,
-  ForkSeq,
-  INTERVALS_PER_SLOT,
-  MAX_SEED_LOOKAHEAD,
-  SLOTS_PER_EPOCH,
-} from "@lodestar/params";
+import {ForkPostAltair, ForkPostElectra, ForkSeq, MAX_SEED_LOOKAHEAD, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {
   CachedBeaconStateAltair,
   EpochCache,
   RootCache,
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
+  computeTimeAtSlot,
   isExecutionStateType,
   isStartSlotOfEpoch,
   isStateValidatorsNodesPopulated,
@@ -85,7 +79,8 @@ export async function importBlock(
   const currentEpoch = computeEpochAtSlot(currentSlot);
   const blockEpoch = computeEpochAtSlot(blockSlot);
   const prevFinalizedEpoch = this.forkChoice.getFinalizedCheckpoint().epoch;
-  const blockDelaySec = (fullyVerifiedBlock.seenTimestampSec - postState.genesisTime) % this.config.SECONDS_PER_SLOT;
+  const blockDelaySec =
+    fullyVerifiedBlock.seenTimestampSec - computeTimeAtSlot(this.config, blockSlot, postState.genesisTime);
   const recvToValLatency = Date.now() / 1000 - (opts.seenTimestampSec ?? Date.now() / 1000);
   const fork = this.config.getForkSeq(blockSlot);
 
@@ -265,10 +260,11 @@ export async function importBlock(
       this.metrics.headSlot.set(newHead.slot);
       // Only track "recent" blocks. Otherwise sync can distort this metrics heavily.
       // We want to track recent blocks coming from gossip, unknown block sync, and API.
-      if (delaySec < SLOTS_PER_EPOCH * this.config.SECONDS_PER_SLOT) {
+      if (delaySec < (SLOTS_PER_EPOCH * this.config.SLOT_DURATION_MS) / 1000) {
         this.metrics.importBlock.elapsedTimeTillBecomeHead.observe(delaySec);
-        if (delaySec > this.config.SECONDS_PER_SLOT / INTERVALS_PER_SLOT) {
-          this.metrics.importBlock.setHeadAfterFirstInterval.inc();
+        const cutOffSec = this.config.getAttestationDueMs(this.config.getForkName(blockSlot)) / 1000;
+        if (delaySec > cutOffSec) {
+          this.metrics.importBlock.setHeadAfterCutoff.inc();
         }
       }
     }

package/src/chain/blocks/verifyBlocksDataAvailability.ts

@@ -1,5 +1,5 @@
 import {DataAvailabilityStatus} from "@lodestar/state-transition";
-import {DAType, IBlockInput} from "./blockInput/index.js";
+import {DAData, DAType, IBlockInput} from "./blockInput/index.js";
 
 // we can now wait for full 12 seconds because unavailable block sync will try pulling
 // the blobs from the network anyway after 500ms of seeing the block
@@ -18,7 +18,15 @@ export async function verifyBlocksDataAvailability(
   dataAvailabilityStatuses: DataAvailabilityStatus[];
   availableTime: number;
 }> {
-  await Promise.all(blocks.map((blockInput) => blockInput.waitForAllData(BLOB_AVAILABILITY_TIMEOUT, signal)));
+  const promises: Promise<DAData>[] = [];
+  for (const blockInput of blocks) {
+    // block verification is triggered on a verified gossip block so we only need to wait for all data
+    if (!blockInput.hasAllData()) {
+      promises.push(blockInput.waitForAllData(BLOB_AVAILABILITY_TIMEOUT, signal));
+    }
+  }
+  await Promise.all(promises);
+
   const availableTime = Math.max(0, Math.max(...blocks.map((blockInput) => blockInput.getTimeComplete())));
   const dataAvailabilityStatuses: DataAvailabilityStatus[] = blocks.map((blockInput) => {
     if (blockInput.type === DAType.PreData) {

package/src/chain/blocks/writeBlockInputToDb.ts

@@ -102,15 +102,7 @@ export async function removeEagerlyPersistedBlockInputs(this: BeaconChain, block
     if (!this.forkChoice.hasBlockHex(blockRootHex)) {
       blockToRemove.push(block);
 
-      if (isBlockInputColumns(blockInput)) {
-        const {custodyColumns} = this.custodyConfig;
-        const dataColumnsLen = custodyColumns.length;
-        const dataColumnSidecars = blockInput.getCustodyColumns();
-        if (dataColumnSidecars.length !== dataColumnsLen) {
-          throw Error(
-            `Invalid dataColumnSidecars=${dataColumnSidecars.length} for custody expected custodyColumnsLen=${dataColumnsLen}`
-          );
-        }
+      if (isBlockInputColumns(blockInput) && blockInput.getCustodyColumns().length > 0) {
         dataColumnsToRemove.push(blockRoot);
       } else if (isBlockInputBlobs(blockInput)) {
         const blobSidecars = blockInput.getBlobs();

package/src/chain/chain.ts

@@ -254,20 +254,9 @@ export class BeaconChain implements IBeaconChain {
     if (!clock) clock = new Clock({config, genesisTime: this.genesisTime, signal});
 
     this.blacklistedBlocks = new Map((opts.blacklistedBlocks ?? []).map((hex) => [hex, null]));
-    const preAggregateCutOffTime = (2 / 3) * this.config.SECONDS_PER_SLOT;
-    this.attestationPool = new AttestationPool(
-      config,
-      clock,
-      preAggregateCutOffTime,
-      this.opts?.preaggregateSlotDistance,
-      metrics
-    );
+    this.attestationPool = new AttestationPool(config, clock, this.opts?.preaggregateSlotDistance, metrics);
     this.aggregatedAttestationPool = new AggregatedAttestationPool(this.config, metrics);
-    this.syncCommitteeMessagePool = new SyncCommitteeMessagePool(
-      clock,
-      preAggregateCutOffTime,
-      this.opts?.preaggregateSlotDistance
-    );
+    this.syncCommitteeMessagePool = new SyncCommitteeMessagePool(config, clock, this.opts?.preaggregateSlotDistance);
     this.syncContributionAndProofPool = new SyncContributionAndProofPool(clock, metrics, logger);
 
     this.seenAggregatedAttestations = new SeenAggregatedAttestations(metrics);
@@ -730,7 +719,6 @@ export class BeaconChain implements IBeaconChain {
       feeRecipient,
       commonBlockBodyPromise,
       parentBlockRoot,
-      parentSlot,
     }: BlockAttributes & {commonBlockBodyPromise: Promise<CommonBlockBody>}
   ): Promise<{
     block: AssembledBlockType<T>;
@@ -756,7 +744,6 @@ export class BeaconChain implements IBeaconChain {
         graffiti,
         slot,
         feeRecipient,
-        parentSlot,
         parentBlockRoot,
         proposerIndex,
         proposerPubKey,
@@ -1150,7 +1137,7 @@ export class BeaconChain implements IBeaconChain {
     const metrics = this.metrics;
     if (metrics && (slot + 1) % SLOTS_PER_EPOCH === 0) {
       // On the last slot of the epoch
-      sleep((1000 * this.config.SECONDS_PER_SLOT) / 2)
+      sleep(this.config.SLOT_DURATION_MS / 2)
         .then(() => this.validatorMonitor?.onceEveryEndOfEpoch(this.getHeadState()))
         .catch((e) => {
           if (!isErrorAborted(e)) this.logger.error("Error on validator monitor onceEveryEndOfEpoch", {slot}, e);

package/src/chain/lightClient/index.ts

@@ -11,6 +11,7 @@ import {
   ForkName,
   ForkPostAltair,
   ForkPostBellatrix,
+  ForkPreGloas,
   ForkSeq,
   MIN_SYNC_COMMITTEE_PARTICIPANTS,
   SYNC_COMMITTEE_SIZE,
@@ -741,17 +742,24 @@ export function sumBits(bits: BitArray): number {
   return bits.getTrueBitIndexes().length;
 }
 
-export function blockToLightClientHeader(fork: ForkName, block: BeaconBlock<ForkPostAltair>): LightClientHeader {
+// TODO GLOAS: Pending light-client spec but this function probably won't be used
+// in Gloas. So we can assume any types here are pre-gloas
+export function blockToLightClientHeader(
+  fork: ForkName,
+  block: BeaconBlock<ForkPostAltair & ForkPreGloas>
+): LightClientHeader {
   const blockSlot = block.slot;
   const beacon: phase0.BeaconBlockHeader = {
     slot: blockSlot,
     proposerIndex: block.proposerIndex,
     parentRoot: block.parentRoot,
     stateRoot: block.stateRoot,
-    bodyRoot: (ssz[fork].BeaconBlockBody as SSZTypesFor<ForkPostAltair, "BeaconBlockBody">).hashTreeRoot(block.body),
+    bodyRoot: (ssz[fork].BeaconBlockBody as SSZTypesFor<ForkPostAltair & ForkPreGloas, "BeaconBlockBody">).hashTreeRoot(
+      block.body
+    ),
   };
   if (ForkSeq[fork] >= ForkSeq.capella) {
-    const blockBody = block.body as BeaconBlockBody<ForkPostBellatrix>;
+    const blockBody = block.body as BeaconBlockBody<ForkPostBellatrix & ForkPreGloas>;
     const execution = executionPayloadToPayloadHeader(ForkSeq[fork], blockBody.executionPayload);
     return {
       beacon,

package/src/chain/opPools/attestationPool.ts

@@ -74,7 +74,6 @@ export class AttestationPool {
   constructor(
     private readonly config: ChainForkConfig,
     private readonly clock: IClock,
-    private readonly cutOffSecFromSlot: number,
     private readonly preaggregateSlotDistance = 0,
     private readonly metrics: Metrics | null = null
   ) {}
@@ -98,7 +97,7 @@ export class AttestationPool {
    * `SignedAggregateAndProof`.
    *
    * If the attestation is too old (low slot) to be included in the pool it is simply dropped
-   * and no error is returned. Also if it's at clock slot but come to the pool later than 2/3
+   * and no error is returned. Also if it's at clock slot but come to the pool later than AGGREGATE_DUE_BPS
    * of slot time, it's dropped too since it's not helpful for the validator anymore
    *
    * Expects the attestation to be fully validated:
@@ -126,7 +125,7 @@ export class AttestationPool {
 
     // Reject gossip attestations in the current slot but come to this pool very late
     // for api attestations, we allow them to be added to the pool
-    if (!priority && this.clock.secFromSlot(slot) > this.cutOffSecFromSlot) {
+    if (!priority && this.clock.msFromSlot(slot) > this.config.getAggregateDueMs(fork)) {
       return InsertOutcome.Late;
     }
 

package/src/chain/opPools/syncCommitteeMessagePool.ts

@@ -1,5 +1,6 @@
 import {Signature, aggregateSignatures} from "@chainsafe/blst";
 import {BitArray} from "@chainsafe/ssz";
+import {ChainForkConfig} from "@lodestar/config";
 import {SYNC_COMMITTEE_SIZE, SYNC_COMMITTEE_SUBNET_COUNT} from "@lodestar/params";
 import {Root, Slot, SubcommitteeIndex, SubnetID, altair} from "@lodestar/types";
 import {MapDef, toRootHex} from "@lodestar/utils";
@@ -44,8 +45,8 @@ export class SyncCommitteeMessagePool {
   private lowestPermissibleSlot = 0;
 
   constructor(
+    private readonly config: ChainForkConfig,
     private readonly clock: IClock,
-    private readonly cutOffSecFromSlot: number,
     private readonly preaggregateSlotDistance = 0
   ) {}
 
@@ -68,6 +69,7 @@ export class SyncCommitteeMessagePool {
     priority?: boolean
   ): InsertOutcome {
     const {slot, beaconBlockRoot} = signature;
+    const fork = this.config.getForkName(slot);
     const rootHex = toRootHex(beaconBlockRoot);
     const lowestPermissibleSlot = this.lowestPermissibleSlot;
 
@@ -76,8 +78,8 @@ export class SyncCommitteeMessagePool {
       return InsertOutcome.Old;
     }
 
-    // validator gets SyncCommitteeContribution at 2/3 of slot, it's no use to preaggregate later than that time
-    if (!priority && this.clock.secFromSlot(slot) > this.cutOffSecFromSlot) {
+    // validator gets SyncCommitteeContribution at CONTRIBUTION_DUE_BPS of slot, it's no use to preaggregate later than that time
+    if (!priority && this.clock.msFromSlot(slot) > this.config.getSyncContributionDueMs(fork)) {
       return InsertOutcome.Late;
     }
 

package/src/chain/opPools/types.ts

@@ -13,7 +13,7 @@ export enum InsertOutcome {
   Old = "Old",
   /** The pool has reached its limit. No changes were made. */
   ReachLimit = "ReachLimit",
-  /** Messages don't bring any value, for example attestations come to the pool at > 2/3 of slot. No changes were made */
+  /** Messages don't bring any value, for example attestations come to the pool at > AGGREGATE_DUE_BPS of slot. No changes were made */
   Late = "Late",
   /** The data is know, and the new participants have been added to the aggregated signature */
   Aggregated = "Aggregated",

package/src/chain/prepareNextSlot.ts

@@ -22,17 +22,18 @@ import {IBeaconChain} from "./interface.js";
 import {getPayloadAttributesForSSE, prepareExecutionPayload} from "./produceBlock/produceBlockBody.js";
 import {RegenCaller} from "./regen/index.js";
 
-/* With 12s slot times, this scheduler will run 4s before the start of each slot (`12 / 3 = 4`). */
-export const SCHEDULER_LOOKAHEAD_FACTOR = 3;
+// TODO GLOAS: re-evaluate this timing
+/* With 12s slot times, this scheduler will run 4s before the start of each slot (`12 - 0.6667 * 12 = 4`). */
+export const PREPARE_NEXT_SLOT_BPS = 6667;
 
 /* We don't want to do more epoch transition than this */
 const PREPARE_EPOCH_LIMIT = 1;
 
 /**
  * At Bellatrix, if we are responsible for proposing in next slot, we want to prepare payload
- * 4s (1/3 slot) before the start of next slot
+ * 4s before the start of next slot at PREPARE_NEXT_SLOT_BPS of the current slot.
  *
- * For all forks, when clock is 1/3 slot before an epoch, we want to prepare for the next epoch
+ * For all forks, when clock reaches PREPARE_NEXT_SLOT_BPS of slot before an epoch, we want to prepare for the next epoch
  * transition from our head so that:
  * + validators vote for block head on time through attestation
  * + validators propose blocks on time
@@ -74,10 +75,9 @@ export class PrepareNextSlotScheduler {
     }
 
     try {
-      // At 1/3 slot time before the next slot, we either prepare payload or precompute
-      // epoch transition
-      const slotMs = this.config.SECONDS_PER_SLOT * 1000;
-      await sleep(slotMs - slotMs / SCHEDULER_LOOKAHEAD_FACTOR, this.signal);
+      // At PREPARE_NEXT_SLOT_BPS (~67%) of the current slot we prepare payload for the next slot
+      // or precompute epoch transition
+      await sleep(this.config.getSlotComponentDurationMs(PREPARE_NEXT_SLOT_BPS), this.signal);
 
       // calling updateHead() here before we produce a block to reduce reorg possibility
       const {slot: headSlot, blockRoot: headRoot} = this.chain.recomputeForkChoiceHead(

package/src/chain/produceBlock/produceBlockBody.ts

@@ -4,9 +4,11 @@ import {
   ForkPostBellatrix,
   ForkPostDeneb,
   ForkPostFulu,
+  ForkPreGloas,
   ForkSeq,
   isForkPostAltair,
   isForkPostBellatrix,
+  isForkPostGloas,
 } from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
@@ -90,7 +92,6 @@ export type BlockAttributes = {
   graffiti: Bytes32;
   slot: Slot;
   parentBlockRoot: Root;
-  parentSlot: Slot;
   feeRecipient?: string;
 };
 
@@ -182,7 +183,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 +315,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 +393,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});
@@ -723,15 +732,7 @@ export async function produceCommonBlockBody<T extends BlockType>(
   this: BeaconChain,
   blockType: T,
   currentState: CachedBeaconStateAllForks,
-  {
-    randaoReveal,
-    graffiti,
-    slot,
-    parentSlot,
-    parentBlockRoot,
-  }: BlockAttributes & {
-    parentSlot: Slot;
-  }
+  {randaoReveal, graffiti, slot, parentBlockRoot}: BlockAttributes
 ): Promise<CommonBlockBody> {
   const stepsMetrics =
     blockType === BlockType.Full
@@ -783,7 +784,8 @@ export async function produceCommonBlockBody<T extends BlockType>(
 
   const endSyncAggregate = stepsMetrics?.startTimer();
   if (ForkSeq[fork] >= ForkSeq.altair) {
-    const syncAggregate = this.syncContributionAndProofPool.getAggregate(parentSlot, parentBlockRoot);
+    const previousSlot = slot - 1;
+    const syncAggregate = this.syncContributionAndProofPool.getAggregate(previousSlot, parentBlockRoot);
     this.metrics?.production.producedSyncAggregateParticipants.observe(
       syncAggregate.syncCommitteeBits.getTrueBitIndexes().length
     );

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