@lodestar/beacon-node 1.35.0-dev.f80d2d52da → 1.35.0-dev.fd1dac853d

package/src/chain/validation/attesterSlashing.ts

@@ -0,0 +1,61 @@
+import {
+  assertValidAttesterSlashing,
+  getAttesterSlashableIndices,
+  getAttesterSlashingSignatureSets,
+} from "@lodestar/state-transition";
+import {AttesterSlashing} from "@lodestar/types";
+import {AttesterSlashingError, AttesterSlashingErrorCode, GossipAction} from "../errors/index.js";
+import {IBeaconChain} from "../index.js";
+
+export async function validateApiAttesterSlashing(
+  chain: IBeaconChain,
+  attesterSlashing: AttesterSlashing
+): Promise<void> {
+  const prioritizeBls = true;
+  return validateAttesterSlashing(chain, attesterSlashing, prioritizeBls);
+}
+
+export async function validateGossipAttesterSlashing(
+  chain: IBeaconChain,
+  attesterSlashing: AttesterSlashing
+): Promise<void> {
+  return validateAttesterSlashing(chain, attesterSlashing);
+}
+
+export async function validateAttesterSlashing(
+  chain: IBeaconChain,
+  attesterSlashing: AttesterSlashing,
+  prioritizeBls = false
+): Promise<void> {
+  // [IGNORE] At least one index in the intersection of the attesting indices of each attestation has not yet been seen
+  // in any prior attester_slashing (i.e.
+  //   attester_slashed_indices = set(attestation_1.attesting_indices).intersection(attestation_2.attesting_indices
+  // ), verify if any(attester_slashed_indices.difference(prior_seen_attester_slashed_indices))).
+  const intersectingIndices = getAttesterSlashableIndices(attesterSlashing);
+  if (chain.opPool.hasSeenAttesterSlashing(intersectingIndices)) {
+    throw new AttesterSlashingError(GossipAction.IGNORE, {
+      code: AttesterSlashingErrorCode.ALREADY_EXISTS,
+    });
+  }
+
+  const state = chain.getHeadState();
+
+  // [REJECT] All of the conditions within process_attester_slashing pass validation.
+  try {
+    // verifySignature = false, verified in batch below
+    assertValidAttesterSlashing(state, attesterSlashing, false);
+  } catch (e) {
+    throw new AttesterSlashingError(GossipAction.REJECT, {
+      code: AttesterSlashingErrorCode.INVALID,
+      error: e as Error,
+    });
+  }
+
+  const signatureSets = getAttesterSlashingSignatureSets(state, attesterSlashing);
+  if (!(await chain.bls.verifySignatureSets(signatureSets, {batchable: true, priority: prioritizeBls}))) {
+    throw new AttesterSlashingError(GossipAction.REJECT, {
+      code: AttesterSlashingErrorCode.INVALID,
+      error: Error("Invalid signature"),
+    });
+  }
+}

package/src/chain/validation/blobSidecar.ts

@@ -0,0 +1,301 @@
+import {ChainConfig} from "@lodestar/config";
+import {
+  ForkName,
+  KZG_COMMITMENT_INCLUSION_PROOF_DEPTH,
+  KZG_COMMITMENT_SUBTREE_INDEX0,
+  isForkPostElectra,
+} from "@lodestar/params";
+import {
+  computeEpochAtSlot,
+  computeStartSlotAtEpoch,
+  getBlockHeaderProposerSignatureSet,
+} from "@lodestar/state-transition";
+import {BlobIndex, Root, Slot, SubnetID, deneb, ssz} from "@lodestar/types";
+import {toRootHex, verifyMerkleBranch} from "@lodestar/utils";
+import {kzg} from "../../util/kzg.js";
+import {BlobSidecarErrorCode, BlobSidecarGossipError, BlobSidecarValidationError} from "../errors/blobSidecarError.js";
+import {GossipAction} from "../errors/gossipValidation.js";
+import {IBeaconChain} from "../interface.js";
+import {RegenCaller} from "../regen/index.js";
+
+export async function validateGossipBlobSidecar(
+  fork: ForkName,
+  chain: IBeaconChain,
+  blobSidecar: deneb.BlobSidecar,
+  subnet: SubnetID
+): Promise<void> {
+  const blobSlot = blobSidecar.signedBlockHeader.message.slot;
+
+  // [REJECT] The sidecar's index is consistent with `MAX_BLOBS_PER_BLOCK` -- i.e. `blob_sidecar.index < MAX_BLOBS_PER_BLOCK`.
+  const maxBlobsPerBlock = chain.config.getMaxBlobsPerBlock(computeEpochAtSlot(blobSlot));
+  if (blobSidecar.index >= maxBlobsPerBlock) {
+    throw new BlobSidecarGossipError(GossipAction.REJECT, {
+      code: BlobSidecarErrorCode.INDEX_TOO_LARGE,
+      blobIdx: blobSidecar.index,
+      maxBlobsPerBlock,
+    });
+  }
+
+  // [REJECT] The sidecar is for the correct subnet -- i.e. `compute_subnet_for_blob_sidecar(sidecar.index) == subnet_id`.
+  if (computeSubnetForBlobSidecar(fork, chain.config, blobSidecar.index) !== subnet) {
+    throw new BlobSidecarGossipError(GossipAction.REJECT, {
+      code: BlobSidecarErrorCode.INVALID_INDEX,
+      blobIdx: blobSidecar.index,
+      subnet,
+    });
+  }
+
+  // [IGNORE] The sidecar is not from a future slot (with a MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance) --
+  // i.e. validate that sidecar.slot <= current_slot (a client MAY queue future blocks for processing at
+  // the appropriate slot).
+  const currentSlotWithGossipDisparity = chain.clock.currentSlotWithGossipDisparity;
+  if (currentSlotWithGossipDisparity < blobSlot) {
+    throw new BlobSidecarGossipError(GossipAction.IGNORE, {
+      code: BlobSidecarErrorCode.FUTURE_SLOT,
+      currentSlot: currentSlotWithGossipDisparity,
+      blockSlot: blobSlot,
+    });
+  }
+
+  // [IGNORE] The sidecar is from a slot greater than the latest finalized slot -- i.e. validate that
+  // sidecar.slot > compute_start_slot_at_epoch(state.finalized_checkpoint.epoch)
+  const finalizedCheckpoint = chain.forkChoice.getFinalizedCheckpoint();
+  const finalizedSlot = computeStartSlotAtEpoch(finalizedCheckpoint.epoch);
+  if (blobSlot <= finalizedSlot) {
+    throw new BlobSidecarGossipError(GossipAction.IGNORE, {
+      code: BlobSidecarErrorCode.WOULD_REVERT_FINALIZED_SLOT,
+      blockSlot: blobSlot,
+      finalizedSlot,
+    });
+  }
+
+  // Check if the block is already known. We know it is post-finalization, so it is sufficient to check the fork choice.
+  //
+  // In normal operation this isn't necessary, however it is useful immediately after a
+  // reboot if the `observed_block_producers` cache is empty. In that case, without this
+  // check, we will load the parent and state from disk only to find out later that we
+  // already know this block.
+  const blockRoot = ssz.phase0.BeaconBlockHeader.hashTreeRoot(blobSidecar.signedBlockHeader.message);
+  const blockHex = toRootHex(blockRoot);
+  if (chain.forkChoice.getBlockHex(blockHex) !== null) {
+    throw new BlobSidecarGossipError(GossipAction.IGNORE, {code: BlobSidecarErrorCode.ALREADY_KNOWN, root: blockHex});
+  }
+
+  // TODO: freetheblobs - check for badblock
+  // TODO: freetheblobs - check that its first blob with valid signature
+
+  // _[IGNORE]_ The blob's block's parent (defined by `sidecar.block_parent_root`) has been seen (via both
+  // gossip and non-gossip sources) (a client MAY queue blocks for processing once the parent block is
+  // retrieved).
+  const parentRoot = toRootHex(blobSidecar.signedBlockHeader.message.parentRoot);
+  const parentBlock = chain.forkChoice.getBlockHex(parentRoot);
+  if (parentBlock === null) {
+    // If fork choice does *not* consider the parent to be a descendant of the finalized block,
+    // then there are two more cases:
+    //
+    // 1. We have the parent stored in our database. Because fork-choice has confirmed the
+    //    parent is *not* in our post-finalization DAG, all other blocks must be either
+    //    pre-finalization or conflicting with finalization.
+    // 2. The parent is unknown to us, we probably want to download it since it might actually
+    //    descend from the finalized root.
+    // (Non-Lighthouse): Since we prune all blocks non-descendant from finalized checking the `db.block` database won't be useful to guard
+    // against known bad fork blocks, so we throw PARENT_UNKNOWN for cases (1) and (2)
+    throw new BlobSidecarGossipError(GossipAction.IGNORE, {code: BlobSidecarErrorCode.PARENT_UNKNOWN, parentRoot});
+  }
+
+  // [REJECT] The blob is from a higher slot than its parent.
+  if (parentBlock.slot >= blobSlot) {
+    throw new BlobSidecarGossipError(GossipAction.IGNORE, {
+      code: BlobSidecarErrorCode.NOT_LATER_THAN_PARENT,
+      parentSlot: parentBlock.slot,
+      slot: blobSlot,
+    });
+  }
+
+  // getBlockSlotState also checks for whether the current finalized checkpoint is an ancestor of the block.
+  // As a result, we throw an IGNORE (whereas the spec says we should REJECT for this scenario).
+  // this is something we should change this in the future to make the code airtight to the spec.
+  // [IGNORE] The block's parent (defined by block.parent_root) has been seen (via both gossip and non-gossip sources) (a client MAY queue blocks for processing once the parent block is retrieved).
+  // [REJECT] The block's parent (defined by block.parent_root) passes validation.
+  const blockState = await chain.regen
+    .getBlockSlotState(parentRoot, blobSlot, {dontTransferCache: true}, RegenCaller.validateGossipBlock)
+    .catch(() => {
+      throw new BlobSidecarGossipError(GossipAction.IGNORE, {code: BlobSidecarErrorCode.PARENT_UNKNOWN, parentRoot});
+    });
+
+  // [REJECT] The proposer signature, signed_beacon_block.signature, is valid with respect to the proposer_index pubkey.
+  const signatureSet = getBlockHeaderProposerSignatureSet(blockState, blobSidecar.signedBlockHeader);
+  // Don't batch so verification is not delayed
+  if (!(await chain.bls.verifySignatureSets([signatureSet], {verifyOnMainThread: true}))) {
+    throw new BlobSidecarGossipError(GossipAction.REJECT, {
+      code: BlobSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID,
+    });
+  }
+
+  // verify if the blob inclusion proof is correct
+  if (!validateBlobSidecarInclusionProof(blobSidecar)) {
+    throw new BlobSidecarGossipError(GossipAction.REJECT, {
+      code: BlobSidecarErrorCode.INCLUSION_PROOF_INVALID,
+      slot: blobSidecar.signedBlockHeader.message.slot,
+      blobIdx: blobSidecar.index,
+    });
+  }
+
+  //  _[IGNORE]_ The sidecar is the only sidecar with valid signature received for the tuple
+  // `(sidecar.block_root, sidecar.index)`
+  //
+  // This is already taken care of by the way we group the blobs in getFullBlockInput helper
+  // but may be an error can be thrown there for this
+
+  // _[REJECT]_ The sidecar is proposed by the expected `proposer_index` for the block's slot in the
+  // context of the current shuffling (defined by `block_parent_root`/`slot`)
+  // If the `proposer_index` cannot immediately be verified against the expected shuffling, the sidecar
+  // MAY be queued for later processing while proposers for the block's branch are calculated -- in such
+  // a case _do not_ `REJECT`, instead `IGNORE` this message.
+  const proposerIndex = blobSidecar.signedBlockHeader.message.proposerIndex;
+  if (blockState.epochCtx.getBeaconProposer(blobSlot) !== proposerIndex) {
+    throw new BlobSidecarGossipError(GossipAction.REJECT, {
+      code: BlobSidecarErrorCode.INCORRECT_PROPOSER,
+      proposerIndex,
+    });
+  }
+
+  // blob, proof and commitment as a valid BLS G1 point gets verified in batch validation
+  try {
+    await validateBlobsAndBlobProofs([blobSidecar.kzgCommitment], [blobSidecar.blob], [blobSidecar.kzgProof]);
+  } catch (_e) {
+    throw new BlobSidecarGossipError(GossipAction.REJECT, {
+      code: BlobSidecarErrorCode.INVALID_KZG_PROOF,
+      blobIdx: blobSidecar.index,
+    });
+  }
+}
+
+/**
+ * Validate some blob sidecars in a block
+ *
+ * Requires the block to be known to the node
+ */
+export async function validateBlockBlobSidecars(
+  blockSlot: Slot,
+  blockRoot: Root,
+  blockBlobCount: number,
+  blobSidecars: deneb.BlobSidecars
+): Promise<void> {
+  if (blobSidecars.length === 0) {
+    return;
+  }
+
+  if (blockBlobCount === 0) {
+    throw new BlobSidecarValidationError({
+      code: BlobSidecarErrorCode.INCORRECT_SIDECAR_COUNT,
+      slot: blockSlot,
+      expected: blockBlobCount,
+      actual: blobSidecars.length,
+    });
+  }
+
+  // Hash the first sidecar block header and compare the rest via (cheaper) equality
+  const firstSidecarBlockHeader = blobSidecars[0].signedBlockHeader.message;
+  const firstBlockRoot = ssz.phase0.BeaconBlockHeader.hashTreeRoot(firstSidecarBlockHeader);
+  if (Buffer.compare(blockRoot, firstBlockRoot) !== 0) {
+    throw new BlobSidecarValidationError(
+      {
+        code: BlobSidecarErrorCode.INCORRECT_BLOCK,
+        slot: blockSlot,
+        blobIdx: 0,
+        expected: toRootHex(blockRoot),
+        actual: toRootHex(firstBlockRoot),
+      },
+      "BlobSidecar doesn't match corresponding block"
+    );
+  }
+
+  const commitments = [];
+  const blobs = [];
+  const proofs = [];
+  for (const blobSidecar of blobSidecars) {
+    const blobIdx = blobSidecar.index;
+    if (!ssz.phase0.BeaconBlockHeader.equals(blobSidecar.signedBlockHeader.message, firstSidecarBlockHeader)) {
+      throw new BlobSidecarValidationError(
+        {
+          code: BlobSidecarErrorCode.INCORRECT_BLOCK,
+          slot: blockSlot,
+          blobIdx,
+          expected: toRootHex(blockRoot),
+          actual: "unknown - compared via equality",
+        },
+        "BlobSidecar doesn't match corresponding block"
+      );
+    }
+
+    if (!validateBlobSidecarInclusionProof(blobSidecar)) {
+      throw new BlobSidecarValidationError(
+        {
+          code: BlobSidecarErrorCode.INCLUSION_PROOF_INVALID,
+          slot: blockSlot,
+          blobIdx,
+        },
+        "BlobSidecar inclusion proof invalid"
+      );
+    }
+
+    commitments.push(blobSidecar.kzgCommitment);
+    blobs.push(blobSidecar.blob);
+    proofs.push(blobSidecar.kzgProof);
+  }
+
+  // Final batch KZG proof verification
+  let reason: string | undefined = undefined;
+  try {
+    if (!(await kzg.asyncVerifyBlobKzgProofBatch(blobs, commitments, proofs))) {
+      reason = "Invalid verifyBlobKzgProofBatch";
+    }
+  } catch (e) {
+    reason = (e as Error).message;
+  }
+  if (reason !== undefined) {
+    throw new BlobSidecarValidationError(
+      {
+        code: BlobSidecarErrorCode.INVALID_KZG_PROOF_BATCH,
+        slot: blockSlot,
+        reason,
+      },
+      "BlobSidecar has invalid KZG proof batch"
+    );
+  }
+}
+
+export async function validateBlobsAndBlobProofs(
+  expectedKzgCommitments: deneb.BlobKzgCommitments,
+  blobs: deneb.Blobs,
+  proofs: deneb.KZGProofs
+): Promise<void> {
+  // assert verify_aggregate_kzg_proof(blobs, expected_kzg_commitments, kzg_aggregated_proof)
+  let isProofValid: boolean;
+  try {
+    isProofValid = await kzg.asyncVerifyBlobKzgProofBatch(blobs, expectedKzgCommitments, proofs);
+  } catch (e) {
+    (e as Error).message = `Error on verifyBlobKzgProofBatch: ${(e as Error).message}`;
+    throw e;
+  }
+  if (!isProofValid) {
+    throw Error("Invalid verifyBlobKzgProofBatch");
+  }
+}
+
+export function validateBlobSidecarInclusionProof(blobSidecar: deneb.BlobSidecar): boolean {
+  return verifyMerkleBranch(
+    ssz.deneb.KZGCommitment.hashTreeRoot(blobSidecar.kzgCommitment),
+    blobSidecar.kzgCommitmentInclusionProof,
+    KZG_COMMITMENT_INCLUSION_PROOF_DEPTH,
+    KZG_COMMITMENT_SUBTREE_INDEX0 + blobSidecar.index,
+    blobSidecar.signedBlockHeader.message.bodyRoot
+  );
+}
+
+function computeSubnetForBlobSidecar(fork: ForkName, config: ChainConfig, blobIndex: BlobIndex): SubnetID {
+  return (
+    blobIndex % (isForkPostElectra(fork) ? config.BLOB_SIDECAR_SUBNET_COUNT_ELECTRA : config.BLOB_SIDECAR_SUBNET_COUNT)
+  );
+}

package/src/chain/validation/block.ts

@@ -0,0 +1,188 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {ForkName, isForkPostDeneb} from "@lodestar/params";
+import {
+  computeEpochAtSlot,
+  computeStartSlotAtEpoch,
+  computeTimeAtSlot,
+  getBlockProposerSignatureSet,
+  isExecutionBlockBodyType,
+  isExecutionEnabled,
+  isExecutionStateType,
+} from "@lodestar/state-transition";
+import {SignedBeaconBlock, deneb} from "@lodestar/types";
+import {sleep, toRootHex} from "@lodestar/utils";
+import {MAXIMUM_GOSSIP_CLOCK_DISPARITY} from "../../constants/index.js";
+import {BlockErrorCode, BlockGossipError, GossipAction} from "../errors/index.js";
+import {IBeaconChain} from "../interface.js";
+import {RegenCaller} from "../regen/index.js";
+
+export async function validateGossipBlock(
+  config: ChainForkConfig,
+  chain: IBeaconChain,
+  signedBlock: SignedBeaconBlock,
+  fork: ForkName
+): Promise<void> {
+  const block = signedBlock.message;
+  const blockSlot = block.slot;
+
+  // [IGNORE] The block is not from a future slot (with a MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance) -- i.e.validate
+  // that signed_beacon_block.message.slot <= current_slot (a client MAY queue future blocks for processing at the
+  // appropriate slot).
+  const currentSlotWithGossipDisparity = chain.clock.currentSlotWithGossipDisparity;
+  if (currentSlotWithGossipDisparity < blockSlot) {
+    throw new BlockGossipError(GossipAction.IGNORE, {
+      code: BlockErrorCode.FUTURE_SLOT,
+      currentSlot: currentSlotWithGossipDisparity,
+      blockSlot,
+    });
+  }
+
+  // [IGNORE] The block is from a slot greater than the latest finalized slot -- i.e. validate that
+  // signed_beacon_block.message.slot > compute_start_slot_at_epoch(state.finalized_checkpoint.epoch)
+  const finalizedCheckpoint = chain.forkChoice.getFinalizedCheckpoint();
+  const finalizedSlot = computeStartSlotAtEpoch(finalizedCheckpoint.epoch);
+  if (blockSlot <= finalizedSlot) {
+    throw new BlockGossipError(GossipAction.IGNORE, {
+      code: BlockErrorCode.WOULD_REVERT_FINALIZED_SLOT,
+      blockSlot,
+      finalizedSlot,
+    });
+  }
+
+  // Check if the block is already known. We know it is post-finalization, so it is sufficient to check the fork choice.
+  //
+  // In normal operation this isn't necessary, however it is useful immediately after a
+  // reboot if the `observed_block_producers` cache is empty. In that case, without this
+  // check, we will load the parent and state from disk only to find out later that we
+  // already know this block.
+  const blockRoot = toRootHex(config.getForkTypes(blockSlot).BeaconBlock.hashTreeRoot(block));
+  if (chain.forkChoice.getBlockHex(blockRoot) !== null) {
+    throw new BlockGossipError(GossipAction.IGNORE, {code: BlockErrorCode.ALREADY_KNOWN, root: blockRoot});
+  }
+
+  // No need to check for badBlock
+  // Gossip de-duplicates messages so we shouldn't be able to receive a bad block twice
+
+  // [IGNORE] The block is the first block with valid signature received for the proposer for the slot, signed_beacon_block.message.slot.
+  const proposerIndex = block.proposerIndex;
+  if (chain.seenBlockProposers.isKnown(blockSlot, proposerIndex)) {
+    throw new BlockGossipError(GossipAction.IGNORE, {code: BlockErrorCode.REPEAT_PROPOSAL, proposerIndex});
+  }
+
+  // [REJECT] The current finalized_checkpoint is an ancestor of block -- i.e.
+  // get_ancestor(store, block.parent_root, compute_start_slot_at_epoch(store.finalized_checkpoint.epoch)) == store.finalized_checkpoint.root
+  const parentRoot = toRootHex(block.parentRoot);
+  const parentBlock = chain.forkChoice.getBlockHex(parentRoot);
+  if (parentBlock === null) {
+    // If fork choice does *not* consider the parent to be a descendant of the finalized block,
+    // then there are two more cases:
+    //
+    // 1. We have the parent stored in our database. Because fork-choice has confirmed the
+    //    parent is *not* in our post-finalization DAG, all other blocks must be either
+    //    pre-finalization or conflicting with finalization.
+    // 2. The parent is unknown to us, we probably want to download it since it might actually
+    //    descend from the finalized root.
+    // (Non-Lighthouse): Since we prune all blocks non-descendant from finalized checking the `db.block` database won't be useful to guard
+    // against known bad fork blocks, so we throw PARENT_UNKNOWN for cases (1) and (2)
+    throw new BlockGossipError(GossipAction.IGNORE, {code: BlockErrorCode.PARENT_UNKNOWN, parentRoot});
+  }
+
+  // [IGNORE] The attestation head block is too far behind the attestation slot, causing many skip slots.
+  // This is deemed a DoS risk because we need to get the proposerShuffling. To get the shuffling we have
+  // to do a bunch of epoch transitions, the longer the distance between the parent and block,
+  // the more we have to do. epochTransitions are expensive ~750ms, so we must limit how many a
+  // single bad block can trigger
+  // Note: Ensure this check is done before calling chain.regen.getBlockSlotStat as this is the function that does various epoch transitions.
+  // Note: This validation check is not part of the spec.
+  if (chain.opts.maxSkipSlots != null && parentBlock.slot + chain.opts.maxSkipSlots < blockSlot) {
+    throw new BlockGossipError(GossipAction.IGNORE, {
+      code: BlockErrorCode.TOO_MANY_SKIPPED_SLOTS,
+      parentSlot: parentBlock.slot,
+      blockSlot,
+    });
+  }
+
+  // [REJECT] The block is from a higher slot than its parent.
+  if (parentBlock.slot >= blockSlot) {
+    throw new BlockGossipError(GossipAction.IGNORE, {
+      code: BlockErrorCode.NOT_LATER_THAN_PARENT,
+      parentSlot: parentBlock.slot,
+      slot: blockSlot,
+    });
+  }
+
+  // [REJECT] The length of KZG commitments is less than or equal to the limitation defined in Consensus Layer -- i.e. validate that len(body.signed_beacon_block.message.blob_kzg_commitments) <= MAX_BLOBS_PER_BLOCK
+  if (isForkPostDeneb(fork)) {
+    const blobKzgCommitmentsLen = (block as deneb.BeaconBlock).body.blobKzgCommitments.length;
+    const maxBlobsPerBlock = config.getMaxBlobsPerBlock(computeEpochAtSlot(blockSlot));
+    if (blobKzgCommitmentsLen > maxBlobsPerBlock) {
+      throw new BlockGossipError(GossipAction.REJECT, {
+        code: BlockErrorCode.TOO_MANY_KZG_COMMITMENTS,
+        blobKzgCommitmentsLen,
+        commitmentLimit: maxBlobsPerBlock,
+      });
+    }
+  }
+
+  // use getPreState to reload state if needed. It also checks for whether the current finalized checkpoint is an ancestor of the block.
+  // As a result, we throw an IGNORE (whereas the spec says we should REJECT for this scenario).
+  // this is something we should change this in the future to make the code airtight to the spec.
+  // [IGNORE] The block's parent (defined by block.parent_root) has been seen (via both gossip and non-gossip sources) (a client MAY queue blocks for processing once the parent block is retrieved).
+  // [REJECT] The block's parent (defined by block.parent_root) passes validation.
+  const blockState = await chain.regen
+    .getPreState(block, {dontTransferCache: true}, RegenCaller.validateGossipBlock)
+    .catch(() => {
+      throw new BlockGossipError(GossipAction.IGNORE, {code: BlockErrorCode.PARENT_UNKNOWN, parentRoot});
+    });
+
+  // Extra conditions for merge fork blocks
+  // [REJECT] The block's execution payload timestamp is correct with respect to the slot
+  // -- i.e. execution_payload.timestamp == compute_timestamp_at_slot(state, block.slot).
+  if (fork === ForkName.bellatrix) {
+    if (!isExecutionBlockBodyType(block.body)) throw Error("Not merge block type");
+    const executionPayload = block.body.executionPayload;
+    if (isExecutionStateType(blockState) && isExecutionEnabled(blockState, block)) {
+      const expectedTimestamp = computeTimeAtSlot(config, blockSlot, chain.genesisTime);
+      if (executionPayload.timestamp !== computeTimeAtSlot(config, blockSlot, chain.genesisTime)) {
+        throw new BlockGossipError(GossipAction.REJECT, {
+          code: BlockErrorCode.INCORRECT_TIMESTAMP,
+          timestamp: executionPayload.timestamp,
+          expectedTimestamp,
+        });
+      }
+    }
+  }
+
+  // [REJECT] The proposer signature, signed_beacon_block.signature, is valid with respect to the proposer_index pubkey.
+  const signatureSet = getBlockProposerSignatureSet(blockState, signedBlock);
+  // Don't batch so verification is not delayed
+  if (!(await chain.bls.verifySignatureSets([signatureSet], {verifyOnMainThread: true}))) {
+    throw new BlockGossipError(GossipAction.REJECT, {
+      code: BlockErrorCode.PROPOSAL_SIGNATURE_INVALID,
+    });
+  }
+
+  // [REJECT] The block is proposed by the expected proposer_index for the block's slot in the context of the current
+  // shuffling (defined by parent_root/slot). If the proposer_index cannot immediately be verified against the expected
+  // shuffling, the block MAY be queued for later processing while proposers for the block's branch are calculated --
+  // in such a case do not REJECT, instead IGNORE this message.
+  if (blockState.epochCtx.getBeaconProposer(blockSlot) !== proposerIndex) {
+    throw new BlockGossipError(GossipAction.REJECT, {code: BlockErrorCode.INCORRECT_PROPOSER, proposerIndex});
+  }
+
+  // Check again in case there two blocks are processed concurrently
+  if (chain.seenBlockProposers.isKnown(blockSlot, proposerIndex)) {
+    throw new BlockGossipError(GossipAction.IGNORE, {code: BlockErrorCode.REPEAT_PROPOSAL, proposerIndex});
+  }
+
+  // Simple implementation of a pending block queue. Keeping the block here recycles the queue logic, and keeps the
+  // gossip validation promise without any extra infrastructure.
+  // Do the sleep at the end, since regen and signature validation can already take longer than `msToBlockSlot`.
+  const msToBlockSlot = computeTimeAtSlot(config, blockSlot, chain.genesisTime) * 1000 - Date.now();
+  if (msToBlockSlot <= MAXIMUM_GOSSIP_CLOCK_DISPARITY && msToBlockSlot > 0) {
+    // If block is between 0 and 500 ms early, hold it in a promise. Equivalent to a pending queue.
+    await sleep(msToBlockSlot);
+  }
+
+  chain.seenBlockProposers.add(blockSlot, proposerIndex);
+}

package/src/chain/validation/blsToExecutionChange.ts

@@ -0,0 +1,61 @@
+import {
+  CachedBeaconStateCapella,
+  getBlsToExecutionChangeSignatureSet,
+  isValidBlsToExecutionChange,
+} from "@lodestar/state-transition";
+import {capella} from "@lodestar/types";
+import {BlsToExecutionChangeError, BlsToExecutionChangeErrorCode, GossipAction} from "../errors/index.js";
+import {IBeaconChain} from "../index.js";
+
+export async function validateApiBlsToExecutionChange(
+  chain: IBeaconChain,
+  blsToExecutionChange: capella.SignedBLSToExecutionChange
+): Promise<void> {
+  const ignoreExists = true;
+  const prioritizeBls = true;
+  return validateBlsToExecutionChange(chain, blsToExecutionChange, {ignoreExists, prioritizeBls});
+}
+
+export async function validateGossipBlsToExecutionChange(
+  chain: IBeaconChain,
+  blsToExecutionChange: capella.SignedBLSToExecutionChange
+): Promise<void> {
+  return validateBlsToExecutionChange(chain, blsToExecutionChange);
+}
+
+async function validateBlsToExecutionChange(
+  chain: IBeaconChain,
+  blsToExecutionChange: capella.SignedBLSToExecutionChange,
+  opts: {ignoreExists?: boolean; prioritizeBls?: boolean} = {ignoreExists: false, prioritizeBls: false}
+): Promise<void> {
+  const {ignoreExists, prioritizeBls} = opts;
+  // [IGNORE] The blsToExecutionChange is the first valid blsToExecutionChange received for the validator with index
+  // signedBLSToExecutionChange.message.validatorIndex.
+  if (!ignoreExists && chain.opPool.hasSeenBlsToExecutionChange(blsToExecutionChange.message.validatorIndex)) {
+    throw new BlsToExecutionChangeError(GossipAction.IGNORE, {
+      code: BlsToExecutionChangeErrorCode.ALREADY_EXISTS,
+    });
+  }
+
+  // validate bls to executionChange
+  // NOTE: No need to advance head state since the signature's fork is handled with `broadcastedOnFork`,
+  // and chanes relevant to `isValidBlsToExecutionChange()` happen only on processBlock(), not processEpoch()
+  const state = chain.getHeadState();
+  const {config} = state;
+
+  // [REJECT] All of the conditions within process_bls_to_execution_change pass validation.
+  // verifySignature = false, verified in batch below
+  const {valid} = isValidBlsToExecutionChange(state as CachedBeaconStateCapella, blsToExecutionChange, false);
+  if (!valid) {
+    throw new BlsToExecutionChangeError(GossipAction.REJECT, {
+      code: BlsToExecutionChangeErrorCode.INVALID,
+    });
+  }
+
+  const signatureSet = getBlsToExecutionChangeSignatureSet(config, blsToExecutionChange);
+  if (!(await chain.bls.verifySignatureSets([signatureSet], {batchable: true, priority: prioritizeBls}))) {
+    throw new BlsToExecutionChangeError(GossipAction.REJECT, {
+      code: BlsToExecutionChangeErrorCode.INVALID_SIGNATURE,
+    });
+  }
+}