@lodestar/beacon-node 1.51.0-dev.fac22802f6 → 1.51.0-dev.fb216e169a

package/src/chain/opPools/singleAttestationPool.ts

@@ -0,0 +1,287 @@
+import {ATTESTATION_SUBNET_COUNT, ForkPostElectra} from "@lodestar/params";
+import {EffectiveBalanceIncrements} from "@lodestar/state-transition";
+import {BLSSignature, CommitteeIndex, RootHex, SingleAttestation, Slot, ValidatorIndex, phase0} from "@lodestar/types";
+import {Metrics} from "../../metrics/metrics.js";
+import {ProposerTracker} from "../proposerTracker.js";
+import {InsertOutcome} from "./types.js";
+
+type DataRootHex = string;
+
+/** Position of a validator in its committee, i.e. its bit in `aggregationBits` */
+type ValidatorCommitteeIndex = number;
+
+/** `data` and `committeeIndex` are shared per data root and committee, only keep what packing reads */
+type StoredSingle = {attesterIndex: ValidatorIndex; signature: BLSSignature};
+
+type CommitteeSingles = {
+  /** Bit length of this committee's `aggregationBits` */
+  committeeSize: number;
+  singles: Map<ValidatorCommitteeIndex, StoredSingle>;
+};
+
+type DataRootSingles = {
+  /** Same for every single attestation under this data root */
+  data: phase0.AttestationData;
+  byCommittee: Map<CommitteeIndex, CommitteeSingles>;
+};
+
+/** Single attestations of not yet included committee members, signatures are not aggregated yet */
+export type SinglesForCommittee = {
+  committeeSize: number;
+  singles: {validatorCommitteeIndex: ValidatorCommitteeIndex; single: StoredSingle}[];
+  newSeenEffectiveBalance: number;
+  newSeenAttesters: number;
+};
+
+/** Attesters of an attestation included in a block, `attestingIndices` is not sorted */
+export type IncludedAttesters = {slot: Slot; attDataRootHex: DataRootHex; attestingIndices: ValidatorIndex[]};
+
+/**
+ * Backstop only, single attestations included in a canonical block are deleted (see `onHead`) so the real retention is
+ * far lower. Sized for all subnets during the default 8 slots before a proposal (`slotsToSubscribeBeforeProposalDuty`)
+ * with no block at all and up to 1024 attesters per committee, i.e. ~2M active validators. Earlier slots of the
+ * collected window only add the few subnets the node subscribes to anyway. Beyond it, newer singles are dropped
+ */
+const MAX_SINGLE_ATTESTATIONS_RETAINED = 8 * ATTESTATION_SUBNET_COUNT * 1024;
+
+/**
+ * Single attestations to be packed into a block produced by this node, for votes that no aggregate covers.
+ * Callers only add to it for vote slots of an upcoming local proposal, see `ProposerTracker.shouldCollect()`.
+ * They are kept even if an aggregate covers them since proposers may not include that aggregate, until a canonical
+ * block includes them.
+ */
+export class SingleAttestationPool {
+  private readonly singlesByCommitteeByDataRootBySlot = new Map<Slot, Map<DataRootHex, DataRootSingles>>();
+  private size = 0;
+  /** Attesters included by the head block, deleted once a child of it becomes head */
+  private pendingPrune: {blockRoot: RootHex; included: IncludedAttesters[]} | null = null;
+
+  constructor(metrics: Metrics | null = null) {
+    metrics?.opPool.singleAttestationPool.size.addCollect(() =>
+      metrics.opPool.singleAttestationPool.size.set(this.size)
+    );
+  }
+
+  /**
+   * @param validatorCommitteeIndex position of the attester in its committee, computed by gossip validation
+   */
+  add(
+    attestation: SingleAttestation<ForkPostElectra>,
+    attDataRootHex: DataRootHex,
+    validatorCommitteeIndex: ValidatorCommitteeIndex,
+    committeeSize: number
+  ): InsertOutcome {
+    if (this.size >= MAX_SINGLE_ATTESTATIONS_RETAINED) {
+      return InsertOutcome.ReachLimit;
+    }
+
+    const {data, committeeIndex, attesterIndex, signature} = attestation;
+    let singlesByCommitteeByDataRoot = this.singlesByCommitteeByDataRootBySlot.get(data.slot);
+    if (singlesByCommitteeByDataRoot === undefined) {
+      singlesByCommitteeByDataRoot = new Map();
+      this.singlesByCommitteeByDataRootBySlot.set(data.slot, singlesByCommitteeByDataRoot);
+    }
+
+    let dataRootSingles = singlesByCommitteeByDataRoot.get(attDataRootHex);
+    if (dataRootSingles === undefined) {
+      dataRootSingles = {data, byCommittee: new Map()};
+      singlesByCommitteeByDataRoot.set(attDataRootHex, dataRootSingles);
+    }
+
+    let committee = dataRootSingles.byCommittee.get(committeeIndex);
+    if (committee === undefined) {
+      committee = {committeeSize, singles: new Map()};
+      dataRootSingles.byCommittee.set(committeeIndex, committee);
+    }
+
+    if (committee.singles.has(validatorCommitteeIndex)) {
+      return InsertOutcome.AlreadyKnown;
+    }
+
+    committee.singles.set(validatorCommitteeIndex, {attesterIndex, signature});
+    this.size++;
+    return InsertOutcome.NewData;
+  }
+
+  /**
+   * Delete single attestations included by the parent of the new head. Not the ones of the head itself: a proposer
+   * boost reorg of a weak head must keep them, once a child of it is the head that reorg can no longer happen.
+   * @param included attesters of the attestations included in the new head block
+   * @returns number of deleted single attestations
+   */
+  onHead(blockRoot: RootHex, parentRoot: RootHex, included: IncludedAttesters[]): number {
+    if (this.singlesByCommitteeByDataRootBySlot.size === 0) {
+      this.pendingPrune = null;
+      return 0;
+    }
+
+    // a reorg or a parent imported while the pool was empty drops the pending block without deleting
+    const deleted = this.pendingPrune?.blockRoot === parentRoot ? this.deleteIncluded(this.pendingPrune.included) : 0;
+    this.pendingPrune = {blockRoot, included};
+    return deleted;
+  }
+
+  /** Drop vote slots that no upcoming local proposal can include */
+  prune(proposerTracker: ProposerTracker): void {
+    for (const [slot, singlesByCommitteeByDataRoot] of this.singlesByCommitteeByDataRootBySlot) {
+      if (proposerTracker.shouldCollect(slot)) {
+        continue;
+      }
+
+      for (const dataRootSingles of singlesByCommitteeByDataRoot.values()) {
+        for (const committee of dataRootSingles.byCommittee.values()) {
+          this.size -= committee.singles.size;
+        }
+      }
+      this.singlesByCommitteeByDataRootBySlot.delete(slot);
+    }
+
+    if (this.singlesByCommitteeByDataRootBySlot.size === 0) {
+      this.pendingPrune = null;
+    }
+  }
+
+  isEmpty(): boolean {
+    return this.singlesByCommitteeByDataRootBySlot.size === 0;
+  }
+
+  getStoredSlots(): Slot[] {
+    return Array.from(this.singlesByCommitteeByDataRootBySlot.keys());
+  }
+
+  getDataRoots(slot: Slot): Map<DataRootHex, phase0.AttestationData> {
+    const dataRoots = new Map<DataRootHex, phase0.AttestationData>();
+    for (const [attDataRootHex, dataRootSingles] of this.singlesByCommitteeByDataRootBySlot.get(slot) ?? []) {
+      dataRoots.set(attDataRootHex, dataRootSingles.data);
+    }
+    return dataRoots;
+  }
+
+  getCommitteeIndices(slot: Slot, attDataRootHex: DataRootHex): CommitteeIndex[] {
+    return Array.from(this.singlesByCommitteeByDataRootBySlot.get(slot)?.get(attDataRootHex)?.byCommittee.keys() ?? []);
+  }
+
+  /**
+   * Single attestations of a committee whose attesters are in `notSeenCommitteeMembers`, i.e. not on chain and not
+   * covered by the aggregates picked for the block. `notSeenCommitteeMembers` is only read.
+   * Returns at most `maxCount` single attestations with the highest effective balances, without removing them from the
+   * pool.
+   */
+  getUncovered(
+    slot: Slot,
+    attDataRootHex: DataRootHex,
+    committeeIndex: CommitteeIndex,
+    notSeenCommitteeMembers: ReadonlySet<ValidatorCommitteeIndex>,
+    effectiveBalanceIncrements: EffectiveBalanceIncrements,
+    maxCount: number
+  ): SinglesForCommittee | null {
+    const committee = this.singlesByCommitteeByDataRootBySlot
+      .get(slot)
+      ?.get(attDataRootHex)
+      ?.byCommittee.get(committeeIndex);
+    if (committee === undefined) {
+      return null;
+    }
+
+    const singles: SinglesForCommittee["singles"] = [];
+    // walk the smaller side, notSeenCommitteeMembers is usually tiny but close to the committee size if no aggregate
+    if (notSeenCommitteeMembers.size <= committee.singles.size) {
+      for (const validatorCommitteeIndex of notSeenCommitteeMembers) {
+        const single = committee.singles.get(validatorCommitteeIndex);
+        if (single !== undefined) {
+          singles.push({validatorCommitteeIndex, single});
+        }
+      }
+    } else {
+      for (const [validatorCommitteeIndex, single] of committee.singles) {
+        if (notSeenCommitteeMembers.has(validatorCommitteeIndex)) {
+          singles.push({validatorCommitteeIndex, single});
+        }
+      }
+    }
+    if (singles.length > maxCount) {
+      singles.sort(
+        (a, b) =>
+          effectiveBalanceIncrements[b.single.attesterIndex] - effectiveBalanceIncrements[a.single.attesterIndex]
+      );
+      singles.length = maxCount;
+    }
+    if (singles.length === 0) {
+      return null;
+    }
+
+    let newSeenEffectiveBalance = 0;
+    for (const {single} of singles) {
+      newSeenEffectiveBalance += effectiveBalanceIncrements[single.attesterIndex];
+    }
+    return {committeeSize: committee.committeeSize, singles, newSeenEffectiveBalance, newSeenAttesters: singles.length};
+  }
+
+  /**
+   * Delete single attestations whose votes are already on chain, they add nothing to a block built on top of it.
+   * @param includedAttestations one entry per attestation in the body of a canonical block (the parent of the new
+   * head): the attestation slot and data root, and the validators it covers. A single attestation is included if its
+   * attester is in `attestingIndices` of an entry with the same slot and data root.
+   * @returns number of deleted single attestations
+   */
+  private deleteIncluded(includedAttestations: IncludedAttesters[]): number {
+    // a block may include several attestations of the same data, merge their attesters per data root
+    const includedAttestersByDataRootBySlot = new Map<Slot, Map<DataRootHex, Set<ValidatorIndex>>>();
+    for (const {slot, attDataRootHex, attestingIndices} of includedAttestations) {
+      if (this.singlesByCommitteeByDataRootBySlot.get(slot)?.has(attDataRootHex) !== true) {
+        continue;
+      }
+      let includedAttestersByDataRoot = includedAttestersByDataRootBySlot.get(slot);
+      if (includedAttestersByDataRoot === undefined) {
+        includedAttestersByDataRoot = new Map();
+        includedAttestersByDataRootBySlot.set(slot, includedAttestersByDataRoot);
+      }
+      let includedAttesters = includedAttestersByDataRoot.get(attDataRootHex);
+      if (includedAttesters === undefined) {
+        includedAttesters = new Set();
+        includedAttestersByDataRoot.set(attDataRootHex, includedAttesters);
+      }
+      for (const attesterIndex of attestingIndices) {
+        includedAttesters.add(attesterIndex);
+      }
+    }
+
+    let deleted = 0;
+    for (const [slot, includedAttestersByDataRoot] of includedAttestersByDataRootBySlot) {
+      const singlesByCommitteeByDataRoot = this.singlesByCommitteeByDataRootBySlot.get(slot);
+      if (singlesByCommitteeByDataRoot === undefined) {
+        continue;
+      }
+
+      for (const [attDataRootHex, includedAttesters] of includedAttestersByDataRoot) {
+        const dataRootSingles = singlesByCommitteeByDataRoot.get(attDataRootHex);
+        if (dataRootSingles === undefined) {
+          continue;
+        }
+
+        for (const [committeeIndex, committee] of dataRootSingles.byCommittee) {
+          for (const [validatorCommitteeIndex, {attesterIndex}] of committee.singles) {
+            if (includedAttesters.has(attesterIndex)) {
+              committee.singles.delete(validatorCommitteeIndex);
+              deleted++;
+            }
+          }
+          if (committee.singles.size === 0) {
+            dataRootSingles.byCommittee.delete(committeeIndex);
+          }
+        }
+
+        if (dataRootSingles.byCommittee.size === 0) {
+          singlesByCommitteeByDataRoot.delete(attDataRootHex);
+        }
+      }
+
+      if (singlesByCommitteeByDataRoot.size === 0) {
+        this.singlesByCommitteeByDataRootBySlot.delete(slot);
+      }
+    }
+
+    this.size -= deleted;
+    return deleted;
+  }
+}

package/src/chain/opPools/syncCommitteeMessagePool.ts

@@ -2,8 +2,9 @@ import {BitArray} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
 import {Signature, aggregateSignatures} from "@lodestar/native/blst";
 import {SYNC_COMMITTEE_SIZE, SYNC_COMMITTEE_SUBNET_COUNT} from "@lodestar/params";
+import {G2_POINT_AT_INFINITY} from "@lodestar/state-transition";
 import {Root, Slot, SubcommitteeIndex, SubnetID, altair} from "@lodestar/types";
-import {MapDef, toRootHex} from "@lodestar/utils";
+import {MapDef, byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {IClock} from "../../util/clock.js";
 import {InsertOutcome, OpPoolError, OpPoolErrorCode} from "./types.js";
 import {pruneBySlot, signatureFromBytesNoCheck} from "./utils.js";
@@ -110,10 +111,16 @@ export class SyncCommitteeMessagePool {
       return null;
     }
 
+    const signature = contribution.signature.toBytes();
+    // The point at infinity is not a valid contribution signature, do not serve such a contribution
+    if (byteArrayEquals(signature, G2_POINT_AT_INFINITY)) {
+      return null;
+    }
+
     return {
       ...contribution,
       aggregationBits: contribution.aggregationBits,
-      signature: contribution.signature.toBytes(),
+      signature,
     };
   }
 

package/src/chain/opPools/syncContributionAndProofPool.ts

@@ -4,7 +4,7 @@ import {Signature, aggregateSignatures} from "@lodestar/native/blst";
 import {SYNC_COMMITTEE_SIZE, SYNC_COMMITTEE_SUBNET_SIZE} from "@lodestar/params";
 import {G2_POINT_AT_INFINITY} from "@lodestar/state-transition";
 import {Root, Slot, SubnetID, altair, ssz} from "@lodestar/types";
-import {Logger, MapDef, toRootHex} from "@lodestar/utils";
+import {Logger, MapDef, byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
 import {IClock} from "../../util/clock.js";
 import {InsertOutcome, OpPoolError, OpPoolErrorCode} from "./types.js";
@@ -234,8 +234,18 @@ export function aggregate(
   }
 
   metrics?.opPool.syncContributionAndProofPool.getAggregateParticipants.set(participationCount);
+
+  const syncCommitteeSignature = aggregateSignatures(signatures).toBytes();
+  // The point at infinity is only a valid sync aggregate signature with empty participation bits
+  if (byteArrayEquals(syncCommitteeSignature, G2_POINT_AT_INFINITY)) {
+    return {
+      syncCommitteeBits: BitArray.fromBitLen(SYNC_COMMITTEE_SIZE),
+      syncCommitteeSignature,
+    };
+  }
+
   return {
     syncCommitteeBits,
-    syncCommitteeSignature: aggregateSignatures(signatures).toBytes(),
+    syncCommitteeSignature,
   };
 }

package/src/chain/options.ts

@@ -43,8 +43,6 @@ export type IChainOptions = BlockProcessOpts &
     disableProposerSlashings?: boolean;
     /** Ensure blobs returned by the execution engine are valid */
     sanityCheckExecutionEngineBlobs?: boolean;
-    /** Max number of produced blobs by local validators to cache */
-    maxCachedBlobSidecars?: number;
     /** Max number of produced block roots (blinded or full) cached for broadcast validations */
     maxCachedProducedRoots?: number;
     initialCustodyGroupCount?: number;
@@ -90,6 +88,11 @@ export type PoolOpts = {
    * Only preaggregate attestation/sync committee message since clockSlot - preaggregateSlotDistance
    */
   preaggregateSlotDistance?: number;
+  /**
+   * Dev only: collect single attestations of every vote slot a block at the clock slot can include regardless of
+   * proposal duties, so that any produced block can pack them. Combine with `subscribeAllSubnets`
+   */
+  singleAttestationIgnoreProposalDuty?: boolean;
 };
 
 export type SeenCacheOpts = {

package/src/chain/produceBlock/produceBlockBody.ts

@@ -72,12 +72,13 @@ import {
 } from "@lodestar/utils";
 import {ZERO_HASH_HEX} from "../../constants/index.js";
 import {numToQuantity} from "../../execution/engine/utils.js";
-import {IExecutionBuilder, IExecutionEngine, PayloadAttributes, PayloadId} from "../../execution/index.js";
+import {IExecutionBuilder, PayloadAttributes, PayloadId} from "../../execution/index.js";
 import {getShufflingDependentRoot} from "../../util/dependentRoot.js";
 import {fromGraffitiBytes} from "../../util/graffiti.js";
 import {kzg} from "../../util/kzg.js";
 import {BeaconProposerCache} from "../beaconProposerCache.js";
 import type {BeaconChain} from "../chain.js";
+import {ForkChoiceExecutionEngine} from "../forkChoiceExecutionEngine.js";
 import {CommonBlockBody} from "../interface.js";
 import {InclusionListStore, ProposerPreferencesPool} from "../opPools/index.js";
 import {validateBlobsAndKzgCommitments, validateCellsAndKzgCommitments} from "./validateBlobsAndKzgCommitments.js";
@@ -742,7 +743,7 @@ export async function produceBlockBody<T extends BlockType>(
  */
 export async function prepareExecutionPayload(
   chain: {
-    executionEngine: IExecutionEngine;
+    executionEngine: ForkChoiceExecutionEngine;
     config: ChainForkConfig;
     forkChoice: IForkChoice;
     proposerPreferencesPool: ProposerPreferencesPool;
@@ -807,6 +808,7 @@ export async function prepareExecutionPayload(
 
     payloadId = await chain.executionEngine.notifyForkchoiceUpdate(
       fork,
+      toRootHex(parentBlockRoot),
       toRootHex(parentBlockHash),
       safeBlockHash,
       finalizedBlockHash,
@@ -1125,11 +1127,13 @@ export async function produceCommonBlockBody<T extends BlockType>(
     this.opPool.getSlashingsAndExits(currentState, blockType, this.metrics);
 
   const endAttestations = stepsMetrics?.startTimer();
+  // TODO: extract to a separate BeaconChain method to coordinate the 2 op-pools
   const attestations = this.aggregatedAttestationPool.getAttestationsForBlock(
     fork,
     this.forkChoice,
     this.shufflingCache,
-    currentState
+    currentState,
+    this.singleAttestationPool
   );
   endAttestations?.({
     step: BlockProductionStep.attestations,

package/src/chain/proposerTracker.ts

@@ -0,0 +1,94 @@
+import {MIN_ATTESTATION_INCLUSION_DELAY} from "@lodestar/params";
+import {computeEpochAtSlot, computeStartSlotAtEpoch} from "@lodestar/state-transition";
+import {Slot} from "@lodestar/types";
+import {Metrics} from "../metrics/metrics.js";
+
+/**
+ * Track upcoming block proposals of validators connected to this node, and the vote slots those blocks can include,
+ * to only then insert single attestations into the SingleAttestationPool
+ */
+export class ProposerTracker {
+  /** Local proposal slots that have not passed yet */
+  private readonly proposalSlots = new Set<Slot>();
+  /** Vote slots of tracked proposals, see `getFirstIncludableVoteSlot` */
+  private readonly collectableSlots = new Set<Slot>();
+  private clockSlot = 0;
+
+  /**
+   * @param ignoreProposalDuty dev only, collect every vote slot a block at the clock slot can include regardless of
+   * local proposals
+   */
+  constructor(
+    private readonly ignoreProposalDuty = false,
+    metrics: Metrics | null = null
+  ) {
+    metrics?.proposerTracker.proposalSlots.addCollect(() =>
+      metrics.proposerTracker.proposalSlots.set(this.proposalSlots.size)
+    );
+    metrics?.proposerTracker.collectableSlot.addCollect(() =>
+      metrics.proposerTracker.collectableSlot.set(this.shouldCollect(this.clockSlot) ? 1 : 0)
+    );
+  }
+
+  /**
+   * Idempotent, a known proposal is ignored
+   * @returns true if the proposal was not tracked before
+   */
+  addProposal(proposalSlot: Slot): boolean {
+    if (this.proposalSlots.has(proposalSlot)) {
+      return false;
+    }
+
+    this.proposalSlots.add(proposalSlot);
+    for (
+      let voteSlot = getFirstIncludableVoteSlot(proposalSlot);
+      voteSlot <= proposalSlot - MIN_ATTESTATION_INCLUSION_DELAY;
+      voteSlot++
+    ) {
+      this.collectableSlots.add(voteSlot);
+    }
+    return true;
+  }
+
+  shouldCollect(attestationSlot: Slot): boolean {
+    if (this.ignoreProposalDuty) {
+      // to test block production without proposal duties
+      return attestationSlot >= getFirstIncludableVoteSlot(this.clockSlot);
+    }
+    return this.collectableSlots.has(attestationSlot);
+  }
+
+  /**
+   * Drop proposals that have passed. A proposal is kept during its own slot so that its single attestations stay
+   * available until the block is produced. Vote slots are dropped once no remaining proposal can include them.
+   */
+  prune(clockSlot: Slot): void {
+    this.clockSlot = clockSlot;
+    for (const proposalSlot of this.proposalSlots) {
+      if (proposalSlot < clockSlot) {
+        this.proposalSlots.delete(proposalSlot);
+      }
+    }
+
+    if (this.proposalSlots.size === 0) {
+      this.collectableSlots.clear();
+      return;
+    }
+
+    // Each remaining proposal covers its own vote slots, so a vote slot below the lowest one is covered by none
+    const lowestCollectableVoteSlot = getFirstIncludableVoteSlot(Math.min(...this.proposalSlots));
+    for (const voteSlot of this.collectableSlots) {
+      if (voteSlot < lowestCollectableVoteSlot) {
+        this.collectableSlots.delete(voteSlot);
+      }
+    }
+  }
+}
+
+/**
+ * Since deneb (EIP-7045) a block includes attestations of its current and previous epoch, so the first vote slot it can
+ * include is the start of the previous epoch, 32 to 63 slots before it on mainnet
+ */
+function getFirstIncludableVoteSlot(blockSlot: Slot): Slot {
+  return computeStartSlotAtEpoch(Math.max(computeEpochAtSlot(blockSlot) - 1, 0));
+}

package/src/chain/regen/interface.ts

@@ -52,7 +52,7 @@ export interface IStateRegenerator extends IStateRegeneratorInternal {
   onCheckpoint(finalizedEpoch: Epoch, justifiedEpoch: Epoch, headStateRoot: RootHex): void;
   processState(blockRootHex: RootHex, postState: IBeaconStateView): void;
   addCheckpointState(cp: phase0.Checkpoint, item: IBeaconStateView): void;
-  updateHeadState(newHead: ProtoBlock, maybeHeadState: IBeaconStateView): void;
+  updateHeadState(newHead: ProtoBlock, maybeHeadState?: IBeaconStateView): void;
   updatePreComputedCheckpoint(rootHex: RootHex, epoch: Epoch): number | null;
 }
 

package/src/chain/regen/queued.ts

@@ -154,18 +154,20 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     this.checkpointStateCache.add(cp, item);
   }
 
-  updateHeadState(newHead: ProtoBlock, maybeHeadState: IBeaconStateView): void {
+  updateHeadState(newHead: ProtoBlock, maybeHeadState?: IBeaconStateView): void {
     const {stateRoot: newHeadStateRoot, blockRoot: newHeadBlockRoot, slot: newHeadSlot} = newHead;
-    const maybeHeadStateRoot = toRootHex(maybeHeadState.hashTreeRoot());
+    const maybeHeadStateRoot = maybeHeadState ? toRootHex(maybeHeadState.hashTreeRoot()) : undefined;
     const logCtx = {
       newHeadSlot,
       newHeadBlockRoot,
       newHeadStateRoot,
-      maybeHeadSlot: maybeHeadState.slot,
+      maybeHeadSlot: maybeHeadState?.slot,
       maybeHeadStateRoot,
     };
     const headState =
-      newHeadStateRoot === maybeHeadStateRoot ? maybeHeadState : this.blockStateCache.get(newHeadStateRoot);
+      maybeHeadState && newHeadStateRoot === maybeHeadStateRoot
+        ? maybeHeadState
+        : this.blockStateCache.get(newHeadStateRoot);
 
     if (headState) {
       this.blockStateCache.setHeadState(headState);