@lodestar/beacon-node 1.51.0-dev.d2b5232209 → 1.51.0-dev.d5620be4a1

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

@@ -1,15 +1,12 @@
-import {ForkName, ForkPostFulu, ForkPostGloas, ForkPreDeneb, ForkPreGloas, NUMBER_OF_COLUMNS} from "@lodestar/params";
-import {BeaconBlockBody, BlobIndex, ColumnIndex, SignedBeaconBlock, Slot, deneb, fulu, gloas} from "@lodestar/types";
-import {byteArrayEquals, fromHex, prettyBytes, toRootHex, withTimeout} from "@lodestar/utils";
+import {ForkName, ForkPostFulu, ForkPostGloas, ForkPreFulu, ForkPreGloas, NUMBER_OF_COLUMNS} from "@lodestar/params";
+import {BeaconBlockBody, ColumnIndex, SignedBeaconBlock, Slot, deneb, fulu, gloas} from "@lodestar/types";
+import {prettyBytes, toRootHex, withTimeout} from "@lodestar/utils";
 import {VersionedHashes} from "../../../execution/index.js";
 import {kzgCommitmentToVersionedHash} from "../../../util/blobs.js";
 import {BlockInputError, BlockInputErrorCode} from "./errors.js";
 import {
-  AddBlob,
   AddBlock,
   AddColumn,
-  BlobMeta,
-  BlobWithSource,
   BlockInputInit,
   ColumnWithSource,
   CreateBlockInputMeta,
@@ -17,22 +14,17 @@ import {
   DAType,
   IBlockInput,
   LogMetaBasic,
-  LogMetaBlobs,
   LogMetaColumns,
   MissingColumnMeta,
   PromiseParts,
   SourceMeta,
 } from "./types.js";
 
-export type BlockInput = BlockInputPreData | BlockInputBlobs | BlockInputColumns | BlockInputNoData;
+export type BlockInput = BlockInputPreData | BlockInputColumns | BlockInputNoData;
 
-export function isBlockInputPreDeneb(blockInput: IBlockInput): blockInput is BlockInputPreData {
+export function isBlockInputPreData(blockInput: IBlockInput): blockInput is BlockInputPreData {
   return blockInput.type === DAType.PreData;
 }
-export function isBlockInputBlobs(blockInput: IBlockInput): blockInput is BlockInputBlobs {
-  return blockInput.type === DAType.Blobs;
-}
-
 export function isBlockInputColumns(blockInput: IBlockInput): blockInput is BlockInputColumns {
   return blockInput.type === DAType.Columns;
 }
@@ -189,16 +181,18 @@ abstract class AbstractBlockInput<F extends ForkName = ForkName, TData extends D
 type BlockInputPreDataState = {
   hasBlock: true;
   hasAllData: true;
-  block: SignedBeaconBlock<ForkPreDeneb>;
+  block: SignedBeaconBlock<ForkPreFulu>;
   source: SourceMeta;
   timeCompleteSec: number;
 };
 
 /**
- * Pre-DA, BlockInput only has a single state.
+ * Pre-fulu BlockInput, it only has a single state.
  * - the block simply exists
+ *
+ * Legacy deneb..electra blob sidecars are not tracked.
  */
-export class BlockInputPreData extends AbstractBlockInput<ForkPreDeneb, null> {
+export class BlockInputPreData extends AbstractBlockInput<ForkPreFulu, null> {
   type = DAType.PreData as const;
 
   state: BlockInputPreDataState;
@@ -210,7 +204,7 @@ export class BlockInputPreData extends AbstractBlockInput<ForkPreDeneb, null> {
     this.blockPromise.resolve(state.block);
   }
 
-  static createFromBlock(props: AddBlock<ForkPreDeneb> & CreateBlockInputMeta): BlockInputPreData {
+  static createFromBlock(props: AddBlock<ForkPreFulu> & CreateBlockInputMeta): BlockInputPreData {
     const init: BlockInputInit = {
       daOutOfRange: props.daOutOfRange,
       timeCreated: props.seenTimestampSec,
@@ -250,332 +244,6 @@ export class BlockInputPreData extends AbstractBlockInput<ForkPreDeneb, null> {
   }
 }
 
-// Blobs DA
-
-export type ForkBlobsDA = ForkName.deneb | ForkName.electra;
-
-type BlockInputBlobsState =
-  | {
-      hasBlock: true;
-      hasAllData: true;
-      versionedHashes: VersionedHashes;
-      block: SignedBeaconBlock<ForkBlobsDA>;
-      source: SourceMeta;
-      timeCompleteSec: number;
-    }
-  | {
-      hasBlock: true;
-      hasAllData: false;
-      versionedHashes: VersionedHashes;
-      block: SignedBeaconBlock<ForkBlobsDA>;
-      source: SourceMeta;
-    }
-  | {
-      hasBlock: false;
-      hasAllData: false;
-    };
-
-/**
- * With blobs, BlockInput has several states:
- * - The block is seen and all blobs are seen
- * - The block is seen and all blobs are not yet seen
- * - The block is yet not seen and its unknown if all blobs are seen
- */
-export class BlockInputBlobs extends AbstractBlockInput<ForkBlobsDA, deneb.BlobSidecars> {
-  type = DAType.Blobs as const;
-
-  state: BlockInputBlobsState;
-  private blobsCache = new Map<BlobIndex, BlobWithSource>();
-
-  private constructor(init: BlockInputInit, state: BlockInputBlobsState) {
-    super(init);
-    this.state = state;
-  }
-
-  static createFromBlock(props: AddBlock<ForkBlobsDA> & CreateBlockInputMeta): BlockInputBlobs {
-    const hasAllData = props.daOutOfRange || props.block.message.body.blobKzgCommitments.length === 0;
-
-    const state = {
-      hasBlock: true,
-      hasAllData,
-      versionedHashes: props.block.message.body.blobKzgCommitments.map(kzgCommitmentToVersionedHash),
-      block: props.block,
-      source: {
-        source: props.source,
-        seenTimestampSec: props.seenTimestampSec,
-        peerIdStr: props.peerIdStr,
-      },
-      timeCompleteSec: hasAllData ? props.seenTimestampSec : undefined,
-    } as BlockInputBlobsState;
-    const init: BlockInputInit = {
-      daOutOfRange: props.daOutOfRange,
-      timeCreated: props.seenTimestampSec,
-      forkName: props.forkName,
-      slot: props.block.message.slot,
-      blockRootHex: props.blockRootHex,
-      parentRootHex: toRootHex(props.block.message.parentRoot),
-    };
-    const blockInput = new BlockInputBlobs(init, state);
-    blockInput.blockPromise.resolve(props.block);
-    if (hasAllData) {
-      blockInput.dataPromise.resolve([]);
-    }
-    return blockInput;
-  }
-
-  static createFromBlob(props: AddBlob & CreateBlockInputMeta): BlockInputBlobs {
-    const state: BlockInputBlobsState = {
-      hasBlock: false,
-      hasAllData: false,
-    };
-    const init: BlockInputInit = {
-      daOutOfRange: props.daOutOfRange,
-      timeCreated: props.seenTimestampSec,
-      forkName: props.forkName,
-      blockRootHex: props.blockRootHex,
-      parentRootHex: toRootHex(props.blobSidecar.signedBlockHeader.message.parentRoot),
-      slot: props.blobSidecar.signedBlockHeader.message.slot,
-    };
-    const blockInput = new BlockInputBlobs(init, state);
-    blockInput.blobsCache.set(props.blobSidecar.index, {
-      blobSidecar: props.blobSidecar,
-      source: props.source,
-      seenTimestampSec: props.seenTimestampSec,
-      peerIdStr: props.peerIdStr,
-    });
-    return blockInput;
-  }
-
-  getLogMeta(): LogMetaBlobs {
-    return {
-      slot: this.slot,
-      blockRoot: prettyBytes(this.blockRootHex),
-      timeCreatedSec: this.timeCreatedSec,
-      expectedBlobs: this.state.hasBlock ? this.state.block.message.body.blobKzgCommitments.length : "unknown",
-      receivedBlobs: this.blobsCache.size,
-    };
-  }
-
-  addBlock(
-    {blockRootHex, block, source, seenTimestampSec, peerIdStr}: AddBlock<ForkBlobsDA>,
-    opts = {throwOnDuplicateAdd: true}
-  ): void {
-    // this check suffices for checking slot, parentRoot, and forkName
-    if (blockRootHex !== this.blockRootHex) {
-      throw new BlockInputError(
-        {
-          code: BlockInputErrorCode.MISMATCHED_ROOT_HEX,
-          blockInputRoot: this.blockRootHex,
-          mismatchedRoot: blockRootHex,
-          source,
-          peerId: `${peerIdStr}`,
-        },
-        "addBlock blockRootHex does not match BlockInput.blockRootHex"
-      );
-    }
-
-    if (!opts.throwOnDuplicateAdd) {
-      return;
-    }
-
-    if (this.state.hasBlock) {
-      throw new BlockInputError(
-        {
-          code: BlockInputErrorCode.INVALID_CONSTRUCTION,
-          blockRoot: this.blockRootHex,
-        },
-        "Cannot addBlock to BlockInputBlobs after it already has a block"
-      );
-    }
-
-    for (const {blobSidecar} of this.blobsCache.values()) {
-      if (!blockAndBlobArePaired(block, blobSidecar)) {
-        this.blobsCache.delete(blobSidecar.index);
-        // TODO: (@matthewkeil) spec says to ignore invalid blobs but should we downscore the peer maybe?
-        // this.logger?.error(`Removing blobIndex=${blobSidecar.index} from BlockInput`, {}, err);
-      }
-    }
-
-    const hasAllData = this.blobsCache.size === block.message.body.blobKzgCommitments.length;
-
-    this.state = {
-      ...this.state,
-      hasBlock: true,
-      hasAllData,
-      block,
-      versionedHashes: block.message.body.blobKzgCommitments.map(kzgCommitmentToVersionedHash),
-      source: {
-        source,
-        seenTimestampSec,
-        peerIdStr,
-      },
-      timeCompleteSec: hasAllData ? seenTimestampSec : undefined,
-    } as BlockInputBlobsState;
-    this.blockPromise.resolve(block);
-    if (hasAllData) {
-      this.dataPromise.resolve(this.getBlobs());
-    }
-  }
-
-  hasBlob(blobIndex: BlobIndex): boolean {
-    return this.blobsCache.has(blobIndex);
-  }
-
-  getBlob(blobIndex: BlobIndex): deneb.BlobSidecar | undefined {
-    return this.blobsCache.get(blobIndex)?.blobSidecar;
-  }
-
-  addBlob(
-    {blockRootHex, blobSidecar, source, peerIdStr, seenTimestampSec}: AddBlob,
-    opts = {throwOnDuplicateAdd: true}
-  ): void {
-    // this check suffices for checking slot, parentRoot, and forkName
-    if (blockRootHex !== this.blockRootHex) {
-      throw new BlockInputError(
-        {
-          code: BlockInputErrorCode.MISMATCHED_ROOT_HEX,
-          blockInputRoot: this.blockRootHex,
-          mismatchedRoot: blockRootHex,
-          source: source,
-          peerId: `${peerIdStr}`,
-        },
-        "Blob BeaconBlockHeader blockRootHex does not match BlockInput.blockRootHex"
-      );
-    }
-
-    const isDuplicate = this.blobsCache.has(blobSidecar.index);
-    if (isDuplicate && opts.throwOnDuplicateAdd) {
-      throw new BlockInputError(
-        {
-          code: BlockInputErrorCode.INVALID_CONSTRUCTION,
-          blockRoot: this.blockRootHex,
-        },
-        "Cannot addBlob to BlockInputBlobs with duplicate blobIndex"
-      );
-    }
-
-    if (this.state.hasBlock) {
-      assertBlockAndBlobArePaired(this.blockRootHex, this.state.block, blobSidecar);
-    }
-
-    if (isDuplicate) {
-      return;
-    }
-
-    this.blobsCache.set(blobSidecar.index, {blobSidecar, source, seenTimestampSec, peerIdStr});
-
-    if (this.state.hasBlock && this.blobsCache.size === this.state.block.message.body.blobKzgCommitments.length) {
-      this.state = {
-        ...this.state,
-        hasAllData: true,
-        timeCompleteSec: seenTimestampSec,
-      };
-      this.dataPromise.resolve([...this.blobsCache.values()].map(({blobSidecar}) => blobSidecar));
-    }
-  }
-
-  getVersionedHashes(): VersionedHashes {
-    if (!this.state.hasBlock) {
-      throw new BlockInputError(
-        {
-          code: BlockInputErrorCode.INCOMPLETE_DATA,
-          ...this.getLogMeta(),
-        },
-        "Cannot get versioned hashes. Block is unknown"
-      );
-    }
-    return this.state.versionedHashes;
-  }
-
-  getMissingBlobMeta(): BlobMeta[] {
-    if (!this.state.hasBlock) {
-      throw new BlockInputError(
-        {
-          code: BlockInputErrorCode.INCOMPLETE_DATA,
-          ...this.getLogMeta(),
-        },
-        "Cannot get missing blobs. Block is unknown"
-      );
-    }
-    if (this.state.hasAllData) {
-      return [];
-    }
-
-    const blobMeta: BlobMeta[] = [];
-    const versionedHashes = this.state.versionedHashes;
-    for (let index = 0; index < versionedHashes.length; index++) {
-      if (!this.blobsCache.has(index)) {
-        blobMeta.push({
-          index,
-          blockRoot: fromHex(this.blockRootHex),
-          versionedHash: versionedHashes[index],
-        });
-      }
-    }
-    return blobMeta;
-  }
-
-  getAllBlobsWithSource(): BlobWithSource[] {
-    if (!this.state.hasAllData) {
-      throw new BlockInputError(
-        {
-          code: BlockInputErrorCode.INCOMPLETE_DATA,
-          ...this.getLogMeta(),
-        },
-        "Cannot get all blobs. DA status is not complete"
-      );
-    }
-    return [...this.blobsCache.values()];
-  }
-
-  getBlobs(): deneb.BlobSidecars {
-    return this.getAllBlobsWithSource().map(({blobSidecar}) => blobSidecar);
-  }
-
-  getSerializedCacheKeys(): object[] {
-    const objects: object[] = [];
-
-    if (this.state.hasBlock) {
-      objects.push(this.state.block);
-    }
-
-    for (const {blobSidecar} of this.blobsCache.values()) {
-      objects.push(blobSidecar);
-    }
-
-    return objects;
-  }
-}
-
-function blockAndBlobArePaired(block: SignedBeaconBlock<ForkBlobsDA>, blobSidecar: deneb.BlobSidecar): boolean {
-  const blockCommitment = block.message.body.blobKzgCommitments[blobSidecar.index];
-  if (!blockCommitment || !blobSidecar.kzgCommitment) {
-    return false;
-  }
-  return byteArrayEquals(blockCommitment, blobSidecar.kzgCommitment);
-}
-
-function assertBlockAndBlobArePaired(
-  blockRootHex: string,
-  block: SignedBeaconBlock<ForkBlobsDA>,
-  blobSidecar: deneb.BlobSidecar
-): void {
-  if (!blockAndBlobArePaired(block, blobSidecar)) {
-    // TODO: (@matthewkeil) should this eject the bad blob instead? No way to tell if the blob or the block
-    //       has the invalid commitment. Guessing it would be the blob though because we match via block
-    //       hashTreeRoot and we do not take a hashTreeRoot of the BlobSidecar
-    throw new BlockInputError(
-      {
-        code: BlockInputErrorCode.MISMATCHED_KZG_COMMITMENT,
-        blockRoot: blockRootHex,
-        slot: block.message.slot,
-        sidecarIndex: blobSidecar.index,
-      },
-      "BlobSidecar commitment does not match block commitment"
-    );
-  }
-}
-
 // Columns DA
 
 export type ForkColumnsDA = ForkName.fulu;

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

@@ -1,7 +1,7 @@
 import {Slot} from "@lodestar/types";
 import {LodestarError} from "@lodestar/utils";
 import {PeerIdStr} from "../../../util/peerId.js";
-import {BlockInputSource, LogMetaBlobs, LogMetaColumns} from "./types.js";
+import {BlockInputSource, LogMetaColumns} from "./types.js";
 
 export enum BlockInputErrorCode {
   // Bad Arguments
@@ -42,7 +42,6 @@ export type BlockInputErrorType =
       sidecarIndex: number;
       commitmentIndex?: number;
     }
-  | (LogMetaBlobs & {code: BlockInputErrorCode.INCOMPLETE_DATA})
   | (LogMetaColumns & {code: BlockInputErrorCode.INCOMPLETE_DATA});
 
 export class BlockInputError extends LodestarError<BlockInputErrorType> {}

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

@@ -1,15 +1,14 @@
 import {ForkName} from "@lodestar/params";
-import {ColumnIndex, DataColumnSidecar, RootHex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
+import {ColumnIndex, DataColumnSidecar, RootHex, SignedBeaconBlock, Slot, fulu} from "@lodestar/types";
 import {VersionedHashes} from "../../../execution/index.js";
 
 export enum DAType {
   PreData = "pre-data",
-  Blobs = "blobs",
   Columns = "columns",
   NoData = "no-data",
 }
 
-export type DAData = null | deneb.BlobSidecars | fulu.DataColumnSidecar[];
+export type DAData = null | fulu.DataColumnSidecar[];
 
 /**
  * Represents were input originated. Blocks and Data can come from different
@@ -37,11 +36,6 @@ export type LogMetaBasic = {
   timeCreatedSec: number;
 };
 
-export type LogMetaBlobs = LogMetaBasic & {
-  expectedBlobs: number | string;
-  receivedBlobs: number;
-};
-
 export type LogMetaColumns = LogMetaBasic & {
   expectedColumns: number;
   receivedColumns: number;
@@ -55,8 +49,6 @@ export type SourceMeta = {
 
 export type BlockWithSource = SourceMeta & {block: SignedBeaconBlock; blockRootHex: RootHex};
 
-export type BlobWithSource = SourceMeta & {blobSidecar: deneb.BlobSidecar};
-
 export type ColumnWithSource = SourceMeta & {columnSidecar: fulu.DataColumnSidecar};
 
 export type BlockHeaderMeta = {
@@ -82,20 +74,10 @@ export type AddBlock<F extends ForkName = ForkName> = SourceMeta & {
   blockRootHex: string;
 };
 
-export type AddBlob = BlobWithSource & {
-  blockRootHex: RootHex;
-};
-
 export type AddColumn = ColumnWithSource & {
   blockRootHex: RootHex;
 };
 
-export type BlobMeta = {
-  index: number;
-  blockRoot: Uint8Array;
-  versionedHash: Uint8Array;
-};
-
 export type MissingColumnMeta = {
   missing: ColumnIndex[];
   versionedHashes: VersionedHashes;

package/src/chain/blocks/importBlock.ts

@@ -1,11 +1,11 @@
 import {BitArray} from "@chainsafe/ssz";
 import {routes} from "@lodestar/api";
 import {
-  AncestorStatus,
-  ExecutionStatus,
   ForkChoiceError,
   ForkChoiceErrorCode,
+  InvalidBlockCode,
   NotReorgedReason,
+  ProtoBlock,
   getFinalizedExecutionBlockHash,
   getSafeExecutionBlockHash,
 } from "@lodestar/fork-choice";
@@ -43,11 +43,13 @@ import {callInNextEventLoop} from "../../util/eventLoop.js";
 import {isOptimisticBlock} from "../../util/forkChoice.js";
 import {isQueueErrorAborted} from "../../util/queue/index.js";
 import type {BeaconChain} from "../chain.js";
-import {ChainEvent, ReorgEventData} from "../emitter.js";
+import {ChainEvent} from "../emitter.js";
+import {BlockError, BlockErrorCode} from "../errors/index.js";
 import {ForkchoiceCaller} from "../forkChoice/index.js";
+import {IncludedAttesters} from "../opPools/singleAttestationPool.js";
 import {REPROCESS_MIN_TIME_TO_NEXT_SLOT_BPS} from "../reprocess.js";
 import {toCheckpointHex} from "../stateCache/persistentCheckpointsCache.js";
-import {isBlockInputBlobs, isBlockInputColumns} from "./blockInput/blockInput.js";
+import {isBlockInputColumns} from "./blockInput/blockInput.js";
 import {AttestationImportOpt, FullyVerifiedBlock, ImportBlockOpts} from "./types.js";
 import {getCheckpointFromState} from "./utils/checkpoint.js";
 
@@ -94,8 +96,8 @@ export async function importBlock(
   fullyVerifiedBlock: FullyVerifiedBlock,
   opts: ImportBlockOpts
 ): Promise<void> {
-  const {blockInput, postState, parentBlockSlot, dataAvailabilityStatus, indexedAttestations} = fullyVerifiedBlock;
-  let {executionStatus} = fullyVerifiedBlock;
+  const {blockInput, postState, parentBlockSlot, executionStatus, dataAvailabilityStatus, indexedAttestations} =
+    fullyVerifiedBlock;
   const block = blockInput.getBlock();
   const source = blockInput.getBlockSource();
   const {slot: blockSlot} = block.message;
@@ -131,35 +133,30 @@ export async function importBlock(
 
   // Should compute checkpoint balances before forkchoice.onBlock
   this.checkpointBalancesCache.processState(blockRootHex, postState);
-  if (isGloasBeaconBlock(block.message)) {
-    // A gloas block has no payload of its own, it inherits the status of the payload it builds on,
-    // i.e. the parent variant matching the bid's parent block hash. The parent's default (PENDING)
-    // variant does not reflect a SYNCING parent payload, and onBlock would then mark that payload VALID.
-    const parentRootHex = toRootHex(block.message.parentRoot);
-    const parentBlockHashHex = toRootHex(block.message.body.signedExecutionPayloadBid.message.parentBlockHash);
-    const parentBlock = this.forkChoice.getBlockHexAndBlockHash(parentRootHex, parentBlockHashHex);
-    if (parentBlock === null) {
-      throw Error(
-        `Parent block not found in forkChoice, parentRoot=${parentRootHex} parentBlockHash=${parentBlockHashHex}`
-      );
-    }
-    if (parentBlock.executionStatus === ExecutionStatus.Invalid) {
-      throw Error(`Parent block has invalid execution status, parentRoot=${parentRootHex}`);
+  const importDelayMs = this.clock.msFromSlot(blockSlot);
+  let blockSummary: ProtoBlock;
+  try {
+    blockSummary = this.forkChoice.onBlock(
+      block.message,
+      postState,
+      receiveDelayMs,
+      importDelayMs,
+      currentSlot,
+      executionStatus,
+      dataAvailabilityStatus
+    );
+  } catch (e) {
+    // The parent can be invalidated by a forkchoiceUpdated verdict after verifyBlocksSanityChecks passed
+    if (
+      e instanceof ForkChoiceError &&
+      e.type.code === ForkChoiceErrorCode.INVALID_BLOCK &&
+      e.type.err.code === InvalidBlockCode.PARENT_EXECUTION_INVALID
+    ) {
+      throw new BlockError(block, {code: BlockErrorCode.PARENT_EXECUTION_INVALID, parentRoot: e.type.err.root});
     }
-    executionStatus = parentBlock.executionStatus;
+    throw e;
   }
 
-  const importDelayMs = this.clock.msFromSlot(blockSlot);
-  const blockSummary = this.forkChoice.onBlock(
-    block.message,
-    postState,
-    receiveDelayMs,
-    importDelayMs,
-    currentSlot,
-    executionStatus,
-    dataAvailabilityStatus
-  );
-
   // This adds the state necessary to process the next block
   // Some block event handlers require state being in state cache so need to do this before emitting EventType.block
   this.regen.processState(blockRootHex, postState);
@@ -176,6 +173,9 @@ export async function importBlock(
   // Only process attestations of blocks with relevant attestations for the fork-choice:
   // If current epoch is N, and block is epoch X, block may include attestations for epoch X or X - 1.
   // The latest block that is useful is at epoch N - 1 which may include attestations for epoch N - 1 or N - 2.
+  // the pool is empty outside the slots before a local block proposal, nothing to prune then
+  const pruneSingleAttestations = fork >= ForkSeq.electra && !this.singleAttestationPool.isEmpty();
+  const includedAttesters: IncludedAttesters[] = [];
   if (importsBlockAttestations(opts, blockEpoch, currentEpoch)) {
     const attestations = block.message.body.attestations;
     const rootCache = new RootCache(postState);
@@ -190,6 +190,14 @@ export async function importBlock(
         const {target, beaconBlockRoot} = attestation.data;
 
         const attDataRoot = toRootHex(ssz.phase0.AttestationData.hashTreeRoot(indexedAttestation.data));
+        // the block includes these attesters even if fork choice below rejects the vote
+        if (pruneSingleAttestations) {
+          includedAttesters.push({
+            slot: attestation.data.slot,
+            attDataRootHex: attDataRoot,
+            attestingIndices: indexedAttestation.attestingIndices,
+          });
+        }
         addAttestation.call(
           this,
           postState,
@@ -321,19 +329,19 @@ export async function importBlock(
     });
   }
 
+  // only a block that becomes head prunes, not a side-branch import
+  if (pruneSingleAttestations && newHead.blockRoot === blockRootHex) {
+    callInNextEventLoop(() => {
+      const deleted = this.singleAttestationPool.onHead(blockRootHex, newHead.parentRoot, includedAttesters);
+      this.metrics?.opPool.singleAttestationPool.deletedByBlock.inc(deleted);
+    });
+  }
+
   if (newHead.blockRoot !== oldHead.blockRoot) {
-    // Set head state as strong reference
-    this.regen.updateHeadState(newHead, postState);
+    this.onHeadChanged(oldHead, newHead, postState);
 
     const delaySec = this.clock.secFromSlot(newHead.slot);
-    this.logger.verbose("New chain head", {
-      slot: newHead.slot,
-      root: newHead.blockRoot,
-      delaySec,
-    });
-
     if (this.metrics) {
-      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.
       const headFork = this.config.getForkName(newHead.slot);
@@ -346,32 +354,6 @@ export async function importBlock(
       }
     }
 
-    this.onNewHead(newHead);
-
-    this.metrics?.forkChoice.changedHead.inc();
-
-    const ancestorResult = this.forkChoice.getCommonAncestorDepth(oldHead, newHead);
-    if (ancestorResult.code === AncestorStatus.CommonAncestor) {
-      // CommonAncestor = chain reorg, old head and new head not direct descendants
-
-      const forkChoiceReorgEventData: ReorgEventData = {
-        depth: ancestorResult.depth,
-        epoch: computeEpochAtSlot(newHead.slot),
-        slot: newHead.slot,
-        newHeadBlock: newHead.blockRoot,
-        oldHeadBlock: oldHead.blockRoot,
-        newHeadState: newHead.stateRoot,
-        oldHeadState: oldHead.stateRoot,
-        executionOptimistic: isOptimisticBlock(newHead),
-      };
-
-      this.emitter.emit(routes.events.EventType.chainReorg, forkChoiceReorgEventData);
-      this.logger.verbose("Chain reorg", forkChoiceReorgEventData);
-
-      this.metrics?.forkChoice.reorg.inc();
-      this.metrics?.forkChoice.reorgDistance.observe(ancestorResult.depth);
-    }
-
     // Lightclient server support (only after altair)
     // - Persist state witness
     // - Use block's syncAggregate
@@ -470,7 +452,13 @@ export async function importBlock(
     const finalizedBlockHash = getFinalizedExecutionBlockHash(this.forkChoice);
     if (headBlockHash !== ZERO_HASH_HEX) {
       this.executionEngine
-        .notifyForkchoiceUpdate(this.config.getForkName(fcuHead.slot), headBlockHash, safeBlockHash, finalizedBlockHash)
+        .notifyForkchoiceUpdate(
+          this.config.getForkName(fcuHead.slot),
+          fcuHead.blockRoot,
+          headBlockHash,
+          safeBlockHash,
+          finalizedBlockHash
+        )
         .catch((e) => {
           if (!isErrorAborted(e) && !isQueueErrorAborted(e)) {
             this.logger.error("Error pushing notifyForkchoiceUpdate()", {headBlockHash, finalizedBlockHash}, e);
@@ -592,10 +580,6 @@ export async function importBlock(
     for (const {source} of blockInput.getSampledColumnsWithSource()) {
       this.metrics?.dataColumns.bySource.inc({source});
     }
-  } else if (isBlockInputBlobs(blockInput)) {
-    for (const {source} of blockInput.getAllBlobsWithSource()) {
-      this.metrics?.importBlock.blobsBySource.inc({blobsSource: source});
-    }
   }
 
   const reprocessGuardSec =