@lodestar/beacon-node 1.35.0-dev.91dadf81de → 1.35.0-dev.955e9f89ed

package/src/chain/blocks/verifyBlocksExecutionPayloads.ts

@@ -1,438 +0,0 @@
-import {ChainForkConfig} from "@lodestar/config";
-import {
-  ExecutionStatus,
-  IForkChoice,
-  LVHInvalidResponse,
-  LVHValidResponse,
-  MaybeValidExecutionStatus,
-  ProtoBlock,
-  assertValidTerminalPowBlock,
-} from "@lodestar/fork-choice";
-import {ForkSeq, SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY} from "@lodestar/params";
-import {
-  CachedBeaconStateAllForks,
-  isExecutionBlockBodyType,
-  isExecutionEnabled,
-  isExecutionStateType,
-  isMergeTransitionBlock as isMergeTransitionBlockFn,
-} from "@lodestar/state-transition";
-import {Slot, bellatrix, electra} from "@lodestar/types";
-import {ErrorAborted, Logger, toRootHex} from "@lodestar/utils";
-import {IEth1ForBlockProduction} from "../../eth1/index.js";
-import {ExecutionPayloadStatus, IExecutionEngine} from "../../execution/engine/interface.js";
-import {Metrics} from "../../metrics/metrics.js";
-import {IClock} from "../../util/clock.js";
-import {BlockError, BlockErrorCode} from "../errors/index.js";
-import {BlockProcessOpts} from "../options.js";
-import {isBlockInputBlobs, isBlockInputColumns} from "./blockInput/blockInput.js";
-import {IBlockInput} from "./blockInput/types.js";
-import {ImportBlockOpts} from "./types.js";
-
-export type VerifyBlockExecutionPayloadModules = {
-  eth1: IEth1ForBlockProduction;
-  executionEngine: IExecutionEngine;
-  clock: IClock;
-  logger: Logger;
-  metrics: Metrics | null;
-  forkChoice: IForkChoice;
-  config: ChainForkConfig;
-};
-
-type ExecAbortType = {blockIndex: number; execError: BlockError};
-export type SegmentExecStatus =
-  | {
-      execAborted: null;
-      executionStatuses: MaybeValidExecutionStatus[];
-      executionTime: number;
-      mergeBlockFound: bellatrix.BeaconBlock | null;
-    }
-  | {execAborted: ExecAbortType; invalidSegmentLVH?: LVHInvalidResponse; mergeBlockFound: null};
-
-type VerifyExecutionErrorResponse =
-  | {executionStatus: ExecutionStatus.Invalid; lvhResponse: LVHInvalidResponse; execError: BlockError}
-  | {executionStatus: null; lvhResponse: undefined; execError: BlockError};
-
-type VerifyBlockExecutionResponse =
-  | VerifyExecutionErrorResponse
-  | {executionStatus: ExecutionStatus.Valid; lvhResponse: LVHValidResponse; execError: null}
-  | {executionStatus: ExecutionStatus.Syncing; lvhResponse?: LVHValidResponse; execError: null}
-  | {executionStatus: ExecutionStatus.PreMerge; lvhResponse: undefined; execError: null};
-
-/**
- * Verifies 1 or more execution payloads from a linear sequence of blocks.
- *
- * Since the EL client must be aware of each parent, all payloads must be submitted in sequence.
- */
-export async function verifyBlocksExecutionPayload(
-  chain: VerifyBlockExecutionPayloadModules,
-  parentBlock: ProtoBlock,
-  blockInputs: IBlockInput[],
-  preState0: CachedBeaconStateAllForks,
-  signal: AbortSignal,
-  opts: BlockProcessOpts & ImportBlockOpts
-): Promise<SegmentExecStatus> {
-  const executionStatuses: MaybeValidExecutionStatus[] = [];
-  let mergeBlockFound: bellatrix.BeaconBlock | null = null;
-  const recvToValLatency = Date.now() / 1000 - (opts.seenTimestampSec ?? Date.now() / 1000);
-  const lastBlock = blockInputs.at(-1);
-
-  // Error in the same way as verifyBlocksSanityChecks if empty blocks
-  if (!lastBlock) {
-    throw Error("Empty partiallyVerifiedBlocks");
-  }
-
-  // For a block with SYNCING status (called optimistic block), it's okay to import with
-  // SYNCING status as EL could switch into syncing
-  //
-  // 1. On initial startup/restart
-  // 2. When some reorg might have occurred and EL doesn't has a parent root
-  //    (observed on devnets)
-  // 3. Because of some unavailable (and potentially invalid) root but there is no way
-  //    of knowing if this is invalid/unavailable. For unavailable block, some proposer
-  //    will (sooner or later) build on the available parent head which will
-  //    eventually win in fork-choice as other validators vote on VALID blocks.
-  //
-  // Once EL catches up again and respond VALID, the fork choice will be updated which
-  // will either validate or prune invalid blocks
-  //
-  // We need to track and keep updating if its safe to optimistically import these blocks.
-  // The following is how we determine for a block if its safe:
-  //
-  // (but we need to modify this check for this segment of blocks because it checks if the
-  //  parent of any block imported in forkchoice is post-merge and currently we could only
-  //  have blocks[0]'s parent imported in the chain as this is no longer one by one verify +
-  //  import.)
-  //
-  //
-  // When to import such blocks:
-  // From: https://github.com/ethereum/consensus-specs/pull/2844
-  // A block MUST NOT be optimistically imported, unless either of the following
-  // conditions are met:
-  //
-  // 1. Parent of the block has execution
-  //
-  //     Since with the sync optimizations, the previous block might not have been in the
-  //     forkChoice yet, so the below check could fail for safeSlotsToImportOptimistically
-  //
-  //     Luckily, we can depend on the preState0 to see if we are already post merge w.r.t
-  //     the blocks we are importing.
-  //
-  //     Or in other words if
-  //       - block status is syncing
-  //       - and we are not in a post merge world and is parent is not optimistically safe
-  //       - and we are syncing close to the chain head i.e. clock slot
-  //       - and parent is optimistically safe
-  //
-  //      then throw error
-  //
-  //
-  //       - if we haven't yet imported a post merge ancestor in forkchoice i.e.
-  //       - and we are syncing close to the clockSlot, i.e. merge Transition could be underway
-  //
-  //
-  // 2. The current slot (as per the system clock) is at least
-  //    SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY ahead of the slot of the block being
-  //    imported.
-  //    This means that the merge transition could be underway and we can't afford to import
-  //    a block which is not fully validated as it could affect liveliness of the network.
-  //
-  //
-  // For this segment of blocks:
-  //   We are optimistically safe with respect to this entire block segment if:
-  //    - all the blocks are way behind the current slot
-  //    - or we have already imported a post-merge parent of first block of this chain in forkchoice
-  const currentSlot = chain.clock.currentSlot;
-  const safeSlotsToImportOptimistically = opts.safeSlotsToImportOptimistically ?? SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY;
-  let isOptimisticallySafe =
-    parentBlock.executionStatus !== ExecutionStatus.PreMerge ||
-    lastBlock.slot + safeSlotsToImportOptimistically < currentSlot;
-
-  for (let blockIndex = 0; blockIndex < blockInputs.length; blockIndex++) {
-    const blockInput = blockInputs[blockIndex];
-    // If blocks are invalid in consensus the main promise could resolve before this loop ends.
-    // In that case stop sending blocks to execution engine
-    if (signal.aborted) {
-      throw new ErrorAborted("verifyBlockExecutionPayloads");
-    }
-    const verifyResponse = await verifyBlockExecutionPayload(
-      chain,
-      blockInput,
-      preState0,
-      opts,
-      isOptimisticallySafe,
-      currentSlot
-    );
-
-    // If execError has happened, then we need to extract the segmentExecStatus and return
-    if (verifyResponse.execError !== null) {
-      return getSegmentErrorResponse({verifyResponse, blockIndex}, parentBlock, blockInputs);
-    }
-
-    // If we are here then its because executionStatus is one of MaybeValidExecutionStatus
-    const {executionStatus} = verifyResponse;
-    // It becomes optimistically  safe for following blocks if a post-merge block is deemed fit
-    // for import. If it would not have been safe verifyBlockExecutionPayload would have
-    // returned execError and loop would have been aborted
-    if (executionStatus !== ExecutionStatus.PreMerge) {
-      isOptimisticallySafe = true;
-    }
-    executionStatuses.push(executionStatus);
-
-    const blockBody = blockInput.getBlock().message.body;
-    const isMergeTransitionBlock =
-      // If the merge block is found, stop the search as the isMergeTransitionBlockFn condition
-      // will still evaluate to true for the following blocks leading to errors (while syncing)
-      // as the preState0 still belongs to the pre state of the first block on segment
-      mergeBlockFound === null &&
-      isExecutionStateType(preState0) &&
-      isExecutionBlockBodyType(blockBody) &&
-      isMergeTransitionBlockFn(preState0, blockBody);
-
-    // If this is a merge transition block, check to ensure if it references
-    // a valid terminal PoW block.
-    //
-    // However specs define this check to be run inside forkChoice's onBlock
-    // (https://github.com/ethereum/consensus-specs/blob/dev/specs/bellatrix/fork-choice.md#on_block)
-    // but we perform the check here (as inspired from the lighthouse impl)
-    //
-    // Reasons:
-    //  1. If the block is not valid, we should fail early and not wait till
-    //     forkChoice import.
-    //  2. It makes logical sense to pair it with the block validations and
-    //     deal it with the external services like eth1 tracker here than
-    //     in import block
-    if (isMergeTransitionBlock) {
-      const mergeBlock = blockInput.getBlock().message as bellatrix.BeaconBlock;
-      const mergeBlockHash = toRootHex(chain.config.getForkTypes(mergeBlock.slot).BeaconBlock.hashTreeRoot(mergeBlock));
-      const powBlockRootHex = toRootHex(mergeBlock.body.executionPayload.parentHash);
-      const powBlock = await chain.eth1.getPowBlock(powBlockRootHex).catch((error) => {
-        // Lets just warn the user here, errors if any will be reported on
-        // `assertValidTerminalPowBlock` checks
-        chain.logger.warn(
-          "Error fetching terminal PoW block referred in the merge transition block",
-          {powBlockHash: powBlockRootHex, mergeBlockHash},
-          error
-        );
-        return null;
-      });
-
-      const powBlockParent =
-        powBlock &&
-        (await chain.eth1.getPowBlock(powBlock.parentHash).catch((error) => {
-          // Lets just warn the user here, errors if any will be reported on
-          // `assertValidTerminalPowBlock` checks
-          chain.logger.warn(
-            "Error fetching parent of the terminal PoW block referred in the merge transition block",
-            {powBlockParentHash: powBlock.parentHash, powBlock: powBlockRootHex, mergeBlockHash},
-            error
-          );
-          return null;
-        }));
-
-      // executionStatus will never == ExecutionStatus.PreMerge if it's the mergeBlock. But gotta make TS happy =D
-      if (executionStatus === ExecutionStatus.PreMerge) {
-        throw Error("Merge block must not have executionStatus == PreMerge");
-      }
-
-      assertValidTerminalPowBlock(chain.config, mergeBlock, {executionStatus, powBlock, powBlockParent});
-      // Valid execution payload, but may not be in a valid beacon chain block. Delay printing the POS ACTIVATED banner
-      // to the end of the verify block routine, which confirms that this block is fully valid.
-      mergeBlockFound = mergeBlock;
-    }
-  }
-
-  const executionTime = Date.now();
-  if (
-    blockInputs.length === 1 &&
-    opts.seenTimestampSec !== undefined &&
-    executionStatuses[0] === ExecutionStatus.Valid
-  ) {
-    const recvToValidation = executionTime / 1000 - opts.seenTimestampSec;
-    const validationTime = recvToValidation - recvToValLatency;
-
-    chain.metrics?.gossipBlock.executionPayload.recvToValidation.observe(recvToValidation);
-    chain.metrics?.gossipBlock.executionPayload.validationTime.observe(validationTime);
-
-    chain.logger.debug("Verified execution payload", {
-      slot: blockInputs[0].slot,
-      recvToValLatency,
-      recvToValidation,
-      validationTime,
-    });
-  }
-
-  return {
-    execAborted: null,
-    executionStatuses,
-    executionTime,
-    mergeBlockFound,
-  };
-}
-
-/**
- * Verifies a single block execution payload by sending it to the EL client (via HTTP).
- */
-export async function verifyBlockExecutionPayload(
-  chain: VerifyBlockExecutionPayloadModules,
-  blockInput: IBlockInput,
-  preState0: CachedBeaconStateAllForks,
-  opts: BlockProcessOpts,
-  isOptimisticallySafe: boolean,
-  currentSlot: Slot
-): Promise<VerifyBlockExecutionResponse> {
-  const block = blockInput.getBlock();
-  /** Not null if execution is enabled */
-  const executionPayloadEnabled =
-    isExecutionStateType(preState0) &&
-    isExecutionBlockBodyType(block.message.body) &&
-    // Safe to use with a state previous to block's preState. isMergeComplete can only transition from false to true.
-    // - If preState0 is after merge block: condition is true, and will always be true
-    // - If preState0 is before merge block: the block could lie but then state transition function will throw above
-    // It is kinda safe to send non-trusted payloads to the execution client because at most it can trigger sync.
-    // TODO: If this becomes a problem, do some basic verification beforehand, like checking the proposer signature.
-    isExecutionEnabled(preState0, block.message)
-      ? block.message.body.executionPayload
-      : null;
-
-  if (!executionPayloadEnabled) {
-    // isExecutionEnabled() -> false
-    return {executionStatus: ExecutionStatus.PreMerge, execError: null} as VerifyBlockExecutionResponse;
-  }
-
-  // TODO: Handle better notifyNewPayload() returning error is syncing
-  const fork = blockInput.forkName;
-  const versionedHashes =
-    isBlockInputBlobs(blockInput) || isBlockInputColumns(blockInput) ? blockInput.getVersionedHashes() : undefined;
-  const parentBlockRoot = ForkSeq[fork] >= ForkSeq.deneb ? block.message.parentRoot : undefined;
-  const executionRequests =
-    ForkSeq[fork] >= ForkSeq.electra ? (block.message.body as electra.BeaconBlockBody).executionRequests : undefined;
-
-  const logCtx = {slot: blockInput.slot, executionBlock: executionPayloadEnabled.blockNumber};
-  chain.logger.debug("Call engine api newPayload", logCtx);
-  const execResult = await chain.executionEngine.notifyNewPayload(
-    fork,
-    executionPayloadEnabled,
-    versionedHashes,
-    parentBlockRoot,
-    executionRequests
-  );
-  chain.logger.debug("Receive engine api newPayload result", {...logCtx, status: execResult.status});
-
-  chain.metrics?.engineNotifyNewPayloadResult.inc({result: execResult.status});
-
-  switch (execResult.status) {
-    case ExecutionPayloadStatus.VALID: {
-      const executionStatus: ExecutionStatus.Valid = ExecutionStatus.Valid;
-      const lvhResponse = {executionStatus, latestValidExecHash: execResult.latestValidHash};
-      return {executionStatus, lvhResponse, execError: null};
-    }
-
-    case ExecutionPayloadStatus.INVALID: {
-      const executionStatus: ExecutionStatus.Invalid = ExecutionStatus.Invalid;
-      const lvhResponse = {
-        executionStatus,
-        latestValidExecHash: execResult.latestValidHash,
-        invalidateFromParentBlockRoot: blockInput.parentRootHex,
-      };
-      const execError = new BlockError(block, {
-        code: BlockErrorCode.EXECUTION_ENGINE_ERROR,
-        execStatus: execResult.status,
-        errorMessage: execResult.validationError ?? "",
-      });
-      return {executionStatus, lvhResponse, execError};
-    }
-
-    // Accepted and Syncing have the same treatment, as final validation of block is pending
-    case ExecutionPayloadStatus.ACCEPTED:
-    case ExecutionPayloadStatus.SYNCING: {
-      // Check if the entire segment was deemed safe or, this block specifically itself if not in
-      // the safeSlotsToImportOptimistically window of current slot, then we can import else
-      // we need to throw and not import his block
-      const safeSlotsToImportOptimistically =
-        opts.safeSlotsToImportOptimistically ?? SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY;
-      if (!isOptimisticallySafe && blockInput.slot + safeSlotsToImportOptimistically >= currentSlot) {
-        const execError = new BlockError(block, {
-          code: BlockErrorCode.EXECUTION_ENGINE_ERROR,
-          execStatus: ExecutionPayloadStatus.UNSAFE_OPTIMISTIC_STATUS,
-          errorMessage: `not safe to import ${execResult.status} payload within ${opts.safeSlotsToImportOptimistically} of currentSlot`,
-        });
-        return {executionStatus: null, execError} as VerifyBlockExecutionResponse;
-      }
-
-      return {executionStatus: ExecutionStatus.Syncing, execError: null};
-    }
-
-    // If the block has is not valid, or it referenced an invalid terminal block then the
-    // block is invalid, however it has no bearing on any forkChoice cleanup
-    //
-    // There can be other reasons for which EL failed some of the observed ones are
-    // 1. Connection refused / can't connect to EL port
-    // 2. EL Internal Error
-    // 3. Geth sometimes gives invalid merkle root error which means invalid
-    //    but expects it to be handled in CL as of now. But we should log as warning
-    //    and give it as optimistic treatment and expect any other non-geth CL<>EL
-    //    combination to reject the invalid block and propose a block.
-    //    On kintsugi devnet, this has been observed to cause contiguous proposal failures
-    //    as the network is geth dominated, till a non geth node proposes and moves network
-    //    forward
-    // For network/unreachable errors, an optimization can be added to replay these blocks
-    // back. But for now, lets assume other mechanisms like unknown parent block of a future
-    // child block will cause it to replay
-
-    case ExecutionPayloadStatus.INVALID_BLOCK_HASH:
-    case ExecutionPayloadStatus.ELERROR:
-    case ExecutionPayloadStatus.UNAVAILABLE: {
-      const execError = new BlockError(block, {
-        code: BlockErrorCode.EXECUTION_ENGINE_ERROR,
-        execStatus: execResult.status,
-        errorMessage: execResult.validationError,
-      });
-      return {executionStatus: null, execError} as VerifyBlockExecutionResponse;
-    }
-  }
-}
-
-function getSegmentErrorResponse(
-  {verifyResponse, blockIndex}: {verifyResponse: VerifyExecutionErrorResponse; blockIndex: number},
-  parentBlock: ProtoBlock,
-  blocks: IBlockInput[]
-): SegmentExecStatus {
-  const {executionStatus, lvhResponse, execError} = verifyResponse;
-  let invalidSegmentLVH: LVHInvalidResponse | undefined = undefined;
-
-  if (
-    executionStatus === ExecutionStatus.Invalid &&
-    lvhResponse !== undefined &&
-    lvhResponse.latestValidExecHash !== null
-  ) {
-    let lvhFound = false;
-    for (let mayBeLVHIndex = blockIndex - 1; mayBeLVHIndex >= 0; mayBeLVHIndex--) {
-      const block = blocks[mayBeLVHIndex].getBlock();
-      if (
-        toRootHex((block.message.body as bellatrix.BeaconBlockBody).executionPayload.blockHash) ===
-        lvhResponse.latestValidExecHash
-      ) {
-        lvhFound = true;
-        break;
-      }
-    }
-
-    // If there is no valid in the segment then we have to propagate invalid response
-    // in forkchoice as well if
-    //  - if the parentBlock is also not the lvh
-    //  - and parentBlock is not pre merge
-    if (
-      !lvhFound &&
-      parentBlock.executionStatus !== ExecutionStatus.PreMerge &&
-      parentBlock.executionPayloadBlockHash !== lvhResponse.latestValidExecHash
-    ) {
-      invalidSegmentLVH = {
-        executionStatus: ExecutionStatus.Invalid,
-        latestValidExecHash: lvhResponse.latestValidExecHash,
-        invalidateFromParentBlockRoot: parentBlock.blockRoot,
-      };
-    }
-  }
-  const execAborted = {blockIndex, execError};
-  return {execAborted, invalidSegmentLVH} as SegmentExecStatus;
-}

package/src/chain/blocks/verifyBlocksSanityChecks.ts

@@ -1,129 +0,0 @@
-import {ChainForkConfig} from "@lodestar/config";
-import {IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
-import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {RootHex, Slot} from "@lodestar/types";
-import {toRootHex} from "@lodestar/utils";
-import {IClock} from "../../util/clock.js";
-import {BlockError, BlockErrorCode} from "../errors/index.js";
-import {IChainOptions} from "../options.js";
-import {IBlockInput} from "./blockInput/types.js";
-import {ImportBlockOpts} from "./types.js";
-
-/**
- * Verifies some early cheap sanity checks on the block before running the full state transition.
- *
- * - Parent is known to the fork-choice
- * - Check skipped slots limit
- * - check_block_relevancy()
- *   - Block not in the future
- *   - Not genesis block
- *   - Block's slot is < Infinity
- *   - Not finalized slot
- *   - Not already known
- */
-export function verifyBlocksSanityChecks(
-  chain: {
-    forkChoice: IForkChoice;
-    clock: IClock;
-    config: ChainForkConfig;
-    opts: IChainOptions;
-    blacklistedBlocks: Map<RootHex, Slot | null>;
-  },
-  blocks: IBlockInput[],
-  opts: ImportBlockOpts
-): {
-  relevantBlocks: IBlockInput[];
-  parentSlots: Slot[];
-  parentBlock: ProtoBlock | null;
-} {
-  if (blocks.length === 0) {
-    throw Error("Empty partiallyVerifiedBlocks");
-  }
-
-  const relevantBlocks: IBlockInput[] = [];
-  const parentSlots: Slot[] = [];
-  let parentBlock: ProtoBlock | null = null;
-
-  for (const blockInput of blocks) {
-    const block = blockInput.getBlock();
-    const blockSlot = block.message.slot;
-    const blockHash = toRootHex(chain.config.getForkTypes(block.message.slot).BeaconBlock.hashTreeRoot(block.message));
-
-    if (chain.blacklistedBlocks.has(blockHash)) {
-      // Blacklisting blocks via CLI flag only requires to set the block hash
-      if (chain.blacklistedBlocks.get(blockHash) === null) {
-        // Set actual slot observed when processing the block
-        chain.blacklistedBlocks.set(blockHash, blockSlot);
-      }
-      throw new BlockError(block, {code: BlockErrorCode.BLACKLISTED_BLOCK});
-    }
-
-    if (chain.blacklistedBlocks.has(toRootHex(block.message.parentRoot))) {
-      chain.blacklistedBlocks.set(blockHash, blockSlot);
-      throw new BlockError(block, {code: BlockErrorCode.BLACKLISTED_BLOCK});
-    }
-
-    // Not genesis block
-    // IGNORE if `partiallyVerifiedBlock.ignoreIfKnown`
-    if (blockSlot === 0) {
-      if (opts.ignoreIfKnown) {
-        continue;
-      }
-      throw new BlockError(block, {code: BlockErrorCode.GENESIS_BLOCK});
-    }
-
-    // Not finalized slot
-    // IGNORE if `partiallyVerifiedBlock.ignoreIfFinalized`
-    const finalizedSlot = computeStartSlotAtEpoch(chain.forkChoice.getFinalizedCheckpoint().epoch);
-    if (blockSlot <= finalizedSlot) {
-      if (opts.ignoreIfFinalized) {
-        continue;
-      }
-      throw new BlockError(block, {code: BlockErrorCode.WOULD_REVERT_FINALIZED_SLOT, blockSlot, finalizedSlot});
-    }
-
-    const relevantLastBlock = relevantBlocks.at(-1);
-    let parentBlockSlot: Slot;
-
-    if (relevantLastBlock) {
-      parentBlockSlot = relevantLastBlock.getBlock().message.slot;
-    } else {
-      // When importing a block segment, only the first NON-IGNORED block must be known to the fork-choice.
-      const parentRoot = toRootHex(block.message.parentRoot);
-      parentBlock = chain.forkChoice.getBlockHex(parentRoot);
-      if (!parentBlock) {
-        throw new BlockError(block, {code: BlockErrorCode.PARENT_UNKNOWN, parentRoot});
-      }
-      // Parent is known to the fork-choice
-      parentBlockSlot = parentBlock.slot;
-    }
-
-    // Block not in the future, also checks for infinity
-    const currentSlot = chain.clock.currentSlot;
-    if (blockSlot > currentSlot) {
-      throw new BlockError(block, {code: BlockErrorCode.FUTURE_SLOT, blockSlot, currentSlot});
-    }
-
-    // Not already known
-    // IGNORE if `partiallyVerifiedBlock.ignoreIfKnown`
-    if (chain.forkChoice.hasBlockHex(blockHash)) {
-      if (opts.ignoreIfKnown) {
-        continue;
-      }
-
-      throw new BlockError(block, {code: BlockErrorCode.ALREADY_KNOWN, root: blockHash});
-    }
-
-    // Block is relevant
-    relevantBlocks.push(blockInput);
-    parentSlots.push(parentBlockSlot);
-  }
-
-  // Just assert to be over cautious and for purposes to be more explicit for someone
-  // going through the code segment
-  if (parentBlock === null && relevantBlocks.length > 0) {
-    throw Error(`Internal error, parentBlock should not be null for relevantBlocks=${relevantBlocks.length}`);
-  }
-
-  return {relevantBlocks, parentSlots, parentBlock};
-}

package/src/chain/blocks/verifyBlocksSignatures.ts

@@ -1,105 +0,0 @@
-import {CachedBeaconStateAllForks, getBlockSignatureSets} from "@lodestar/state-transition";
-import {SignedBeaconBlock} from "@lodestar/types";
-import {Logger} from "@lodestar/utils";
-import {Metrics} from "../../metrics/metrics.js";
-import {nextEventLoop} from "../../util/eventLoop.js";
-import {IBlsVerifier} from "../bls/index.js";
-import {BlockError, BlockErrorCode} from "../errors/blockError.js";
-import {ImportBlockOpts} from "./types.js";
-
-/**
- * Verifies 1 or more block's signatures from a group of blocks in the same epoch.
- * getBlockSignatureSets() guarantees to return the correct signingRoots as long as all blocks belong in the same
- * epoch as `preState0`. Otherwise the shufflings won't be correct.
- *
- * Since all data is known in advance all signatures are verified at once in parallel.
- */
-export async function verifyBlocksSignatures(
-  bls: IBlsVerifier,
-  logger: Logger,
-  metrics: Metrics | null,
-  preState0: CachedBeaconStateAllForks,
-  blocks: SignedBeaconBlock[],
-  opts: ImportBlockOpts
-): Promise<{verifySignaturesTime: number}> {
-  const isValidPromises: Promise<boolean>[] = [];
-  const recvToValLatency = Date.now() / 1000 - (opts.seenTimestampSec ?? Date.now() / 1000);
-
-  // Verifies signatures after running state transition, so all SyncCommittee signed roots are known at this point.
-  // We must ensure block.slot <= state.slot before running getAllBlockSignatureSets().
-  // NOTE: If in the future multiple blocks signatures are verified at once, all blocks must be in the same epoch
-  // so the attester and proposer shufflings are correct.
-  for (const [i, block] of blocks.entries()) {
-    // Use [i] to make clear that the index has to be correct to blame the right block below on BlockError()
-    isValidPromises[i] = opts.validSignatures
-      ? // Skip all signature verification
-        Promise.resolve(true)
-      : //
-        // Verify signatures per block to track which block is invalid
-        bls.verifySignatureSets(
-          getBlockSignatureSets(preState0, block, {
-            skipProposerSignature: opts.validProposerSignature,
-          })
-        );
-
-    // getBlockSignatureSets() takes 45ms in benchmarks for 2022Q2 mainnet blocks (100 sigs). When syncing a 32 blocks
-    // segments it will block the event loop for 1400 ms, which is too much. This call will allow the event loop to
-    // yield, which will cause one block's state transition to run. However, the tradeoff is okay and doesn't slow sync
-    if ((i + 1) % 8 === 0) {
-      await nextEventLoop();
-    }
-  }
-
-  // `rejectFirstInvalidResolveAllValid()` returns on isValid result with its index
-  const res = await rejectFirstInvalidResolveAllValid(isValidPromises);
-  if (!res.allValid) {
-    throw new BlockError(blocks[res.index], {code: BlockErrorCode.INVALID_SIGNATURE, state: preState0});
-  }
-
-  const verifySignaturesTime = Date.now();
-  if (blocks.length === 1 && opts.seenTimestampSec !== undefined) {
-    const recvToValidation = verifySignaturesTime / 1000 - opts.seenTimestampSec;
-    const validationTime = recvToValidation - recvToValLatency;
-
-    metrics?.gossipBlock.signatureVerification.recvToValidation.observe(recvToValidation);
-    metrics?.gossipBlock.signatureVerification.validationTime.observe(validationTime);
-
-    logger.debug("Verified block signatures", {
-      slot: blocks[0].message.slot,
-      recvToValLatency,
-      recvToValidation,
-      validationTime,
-    });
-  }
-
-  return {verifySignaturesTime};
-}
-
-type AllValidRes = {allValid: true} | {allValid: false; index: number};
-
-/**
- * From an array of promises that resolve a boolean isValid
- * - if all valid, await all and return
- * - if one invalid, abort immediately and return index of invalid
- */
-export function rejectFirstInvalidResolveAllValid(isValidPromises: Promise<boolean>[]): Promise<AllValidRes> {
-  return new Promise<AllValidRes>((resolve, reject) => {
-    let validCount = 0;
-
-    for (let i = 0; i < isValidPromises.length; i++) {
-      isValidPromises[i]
-        .then((isValid) => {
-          if (isValid) {
-            if (++validCount >= isValidPromises.length) {
-              resolve({allValid: true});
-            }
-          } else {
-            resolve({allValid: false, index: i});
-          }
-        })
-        .catch((e) => {
-          reject(e);
-        });
-    }
-  });
-}