@lodestar/state-transition 1.35.0-dev.8ea34e52ba → 1.35.0-dev.901d719660

package/src/block/processConsolidationRequest.ts

@@ -0,0 +1,147 @@
+import {FAR_FUTURE_EPOCH, MIN_ACTIVATION_BALANCE, PENDING_CONSOLIDATIONS_LIMIT} from "@lodestar/params";
+import {electra, ssz} from "@lodestar/types";
+import {CachedBeaconStateElectra} from "../types.js";
+import {hasEth1WithdrawalCredential} from "../util/capella.js";
+import {
+  hasCompoundingWithdrawalCredential,
+  hasExecutionWithdrawalCredential,
+  isPubkeyKnown,
+  switchToCompoundingValidator,
+} from "../util/electra.js";
+import {computeConsolidationEpochAndUpdateChurn} from "../util/epoch.js";
+import {getConsolidationChurnLimit, getPendingBalanceToWithdraw, isActiveValidator} from "../util/validator.js";
+
+// TODO Electra: Clean up necessary as there is a lot of overlap with isValidSwitchToCompoundRequest
+export function processConsolidationRequest(
+  state: CachedBeaconStateElectra,
+  consolidationRequest: electra.ConsolidationRequest
+): void {
+  const {sourcePubkey, targetPubkey, sourceAddress} = consolidationRequest;
+  if (!isPubkeyKnown(state, sourcePubkey) || !isPubkeyKnown(state, targetPubkey)) {
+    return;
+  }
+
+  const sourceIndex = state.epochCtx.getValidatorIndex(sourcePubkey);
+  const targetIndex = state.epochCtx.getValidatorIndex(targetPubkey);
+
+  if (sourceIndex === null || targetIndex === null) {
+    return;
+  }
+
+  if (isValidSwitchToCompoundRequest(state, consolidationRequest)) {
+    switchToCompoundingValidator(state, sourceIndex);
+    // Early return since we have already switched validator to compounding
+    return;
+  }
+
+  // Verify that source != target, so a consolidation cannot be used as an exit.
+  if (sourceIndex === targetIndex) {
+    return;
+  }
+
+  // If the pending consolidations queue is full, consolidation requests are ignored
+  if (state.pendingConsolidations.length >= PENDING_CONSOLIDATIONS_LIMIT) {
+    return;
+  }
+
+  // If there is too little available consolidation churn limit, consolidation requests are ignored
+  if (getConsolidationChurnLimit(state.epochCtx) <= MIN_ACTIVATION_BALANCE) {
+    return;
+  }
+
+  const sourceValidator = state.validators.get(sourceIndex);
+  const targetValidator = state.validators.getReadonly(targetIndex);
+  const sourceWithdrawalAddress = sourceValidator.withdrawalCredentials.subarray(12);
+  const currentEpoch = state.epochCtx.epoch;
+
+  // Verify source withdrawal credentials
+  const hasCorrectCredential = hasExecutionWithdrawalCredential(sourceValidator.withdrawalCredentials);
+  const isCorrectSourceAddress = Buffer.compare(sourceWithdrawalAddress, sourceAddress) === 0;
+  if (!(hasCorrectCredential && isCorrectSourceAddress)) {
+    return;
+  }
+
+  // Verify that target has compounding withdrawal credentials
+  if (!hasCompoundingWithdrawalCredential(targetValidator.withdrawalCredentials)) {
+    return;
+  }
+
+  // Verify the source and the target are active
+  if (!isActiveValidator(sourceValidator, currentEpoch) || !isActiveValidator(targetValidator, currentEpoch)) {
+    return;
+  }
+
+  // Verify exits for source and target have not been initiated
+  if (sourceValidator.exitEpoch !== FAR_FUTURE_EPOCH || targetValidator.exitEpoch !== FAR_FUTURE_EPOCH) {
+    return;
+  }
+
+  // Verify the source has been active long enough
+  if (currentEpoch < sourceValidator.activationEpoch + state.config.SHARD_COMMITTEE_PERIOD) {
+    return;
+  }
+
+  // Verify the source has no pending withdrawals in the queue
+  if (getPendingBalanceToWithdraw(state, sourceIndex) > 0) {
+    return;
+  }
+
+  // Initiate source validator exit and append pending consolidation
+  // TODO Electra: See if we can get rid of big int
+  const exitEpoch = computeConsolidationEpochAndUpdateChurn(state, BigInt(sourceValidator.effectiveBalance));
+  sourceValidator.exitEpoch = exitEpoch;
+  sourceValidator.withdrawableEpoch = exitEpoch + state.config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY;
+
+  const pendingConsolidation = ssz.electra.PendingConsolidation.toViewDU({
+    sourceIndex,
+    targetIndex,
+  });
+  state.pendingConsolidations.push(pendingConsolidation);
+}
+
+/**
+ * Determine if we should set consolidation target validator to compounding credential
+ */
+function isValidSwitchToCompoundRequest(
+  state: CachedBeaconStateElectra,
+  consolidationRequest: electra.ConsolidationRequest
+): boolean {
+  const {sourcePubkey, targetPubkey, sourceAddress} = consolidationRequest;
+  const sourceIndex = state.epochCtx.getValidatorIndex(sourcePubkey);
+  const targetIndex = state.epochCtx.getValidatorIndex(targetPubkey);
+
+  // Verify pubkey exists
+  if (sourceIndex === null) {
+    // this check is mainly to make the compiler happy, pubkey is checked by the consumer already
+    return false;
+  }
+
+  // Switch to compounding requires source and target be equal
+  if (sourceIndex !== targetIndex) {
+    return false;
+  }
+
+  const sourceValidator = state.validators.getReadonly(sourceIndex);
+  const sourceWithdrawalAddress = sourceValidator.withdrawalCredentials.subarray(12);
+  // Verify request has been authorized
+  if (Buffer.compare(sourceWithdrawalAddress, sourceAddress) !== 0) {
+    return false;
+  }
+
+  // Verify source withdrawal credentials
+  if (!hasEth1WithdrawalCredential(sourceValidator.withdrawalCredentials)) {
+    return false;
+  }
+
+  // Verify the source is active
+  if (!isActiveValidator(sourceValidator, state.epochCtx.epoch)) {
+    return false;
+  }
+
+  // Verify exit for source has not been initiated
+  if (sourceValidator.exitEpoch !== FAR_FUTURE_EPOCH) {
+    return false;
+  }
+
+  return true;
+}

package/src/block/processDeposit.ts

@@ -0,0 +1,166 @@
+import {PublicKey, Signature, verify} from "@chainsafe/blst";
+import {BeaconConfig} from "@lodestar/config";
+import {
+  DEPOSIT_CONTRACT_TREE_DEPTH,
+  DOMAIN_DEPOSIT,
+  EFFECTIVE_BALANCE_INCREMENT,
+  FAR_FUTURE_EPOCH,
+  ForkSeq,
+  GENESIS_SLOT,
+  MAX_EFFECTIVE_BALANCE,
+} from "@lodestar/params";
+import {BLSPubkey, Bytes32, UintNum64, electra, phase0, ssz} from "@lodestar/types";
+import {verifyMerkleBranch} from "@lodestar/utils";
+import {ZERO_HASH} from "../constants/index.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateAltair, CachedBeaconStateElectra} from "../types.js";
+import {computeDomain, computeSigningRoot, getMaxEffectiveBalance, increaseBalance} from "../util/index.js";
+
+/**
+ * Process a Deposit operation. Potentially adds a new validator to the registry. Mutates the validators and balances
+ * trees, pushing contigious values at the end.
+ *
+ * PERF: Work depends on number of Deposit per block. On regular networks the average is 0 / block.
+ */
+export function processDeposit(fork: ForkSeq, state: CachedBeaconStateAllForks, deposit: phase0.Deposit): void {
+  // verify the merkle branch
+  if (
+    !verifyMerkleBranch(
+      ssz.phase0.DepositData.hashTreeRoot(deposit.data),
+      deposit.proof,
+      DEPOSIT_CONTRACT_TREE_DEPTH + 1,
+      state.eth1DepositIndex,
+      state.eth1Data.depositRoot
+    )
+  ) {
+    throw new Error("Deposit has invalid merkle proof");
+  }
+
+  // deposits must be processed in order
+  state.eth1DepositIndex += 1;
+
+  applyDeposit(fork, state, deposit.data);
+}
+
+/**
+ * Adds a new validator into the registry. Or increase balance if already exist.
+ * Follows applyDeposit() in consensus spec. Will be used by processDeposit() and processDepositRequest()
+ *
+ */
+export function applyDeposit(
+  fork: ForkSeq,
+  state: CachedBeaconStateAllForks,
+  deposit: phase0.DepositData | electra.DepositRequest
+): void {
+  const {config, epochCtx, validators} = state;
+  const {pubkey, withdrawalCredentials, amount, signature} = deposit;
+
+  const cachedIndex = epochCtx.getValidatorIndex(pubkey);
+  const isNewValidator = cachedIndex === null || !Number.isSafeInteger(cachedIndex) || cachedIndex >= validators.length;
+
+  if (fork < ForkSeq.electra) {
+    if (isNewValidator) {
+      if (isValidDepositSignature(config, pubkey, withdrawalCredentials, amount, signature)) {
+        addValidatorToRegistry(fork, state, pubkey, withdrawalCredentials, amount);
+      }
+    } else {
+      // increase balance by deposit amount right away pre-electra
+      increaseBalance(state, cachedIndex, amount);
+    }
+  } else {
+    const stateElectra = state as CachedBeaconStateElectra;
+    const pendingDeposit = ssz.electra.PendingDeposit.toViewDU({
+      pubkey,
+      withdrawalCredentials,
+      amount,
+      signature,
+      slot: GENESIS_SLOT, // Use GENESIS_SLOT to distinguish from a pending deposit request
+    });
+
+    if (isNewValidator) {
+      if (isValidDepositSignature(config, pubkey, withdrawalCredentials, amount, deposit.signature)) {
+        addValidatorToRegistry(fork, state, pubkey, withdrawalCredentials, 0);
+        stateElectra.pendingDeposits.push(pendingDeposit);
+      }
+    } else {
+      stateElectra.pendingDeposits.push(pendingDeposit);
+    }
+  }
+}
+
+export function addValidatorToRegistry(
+  fork: ForkSeq,
+  state: CachedBeaconStateAllForks,
+  pubkey: BLSPubkey,
+  withdrawalCredentials: Bytes32,
+  amount: UintNum64
+): void {
+  const {validators, epochCtx} = state;
+  // add validator and balance entries
+  const effectiveBalance = Math.min(
+    amount - (amount % EFFECTIVE_BALANCE_INCREMENT),
+    fork < ForkSeq.electra ? MAX_EFFECTIVE_BALANCE : getMaxEffectiveBalance(withdrawalCredentials)
+  );
+  validators.push(
+    ssz.phase0.Validator.toViewDU({
+      pubkey,
+      withdrawalCredentials,
+      activationEligibilityEpoch: FAR_FUTURE_EPOCH,
+      activationEpoch: FAR_FUTURE_EPOCH,
+      exitEpoch: FAR_FUTURE_EPOCH,
+      withdrawableEpoch: FAR_FUTURE_EPOCH,
+      effectiveBalance,
+      slashed: false,
+    })
+  );
+
+  const validatorIndex = validators.length - 1;
+  // TODO Electra: Review this
+  // Updating here is better than updating at once on epoch transition
+  // - Simplify genesis fn applyDeposits(): effectiveBalanceIncrements is populated immediately
+  // - Keep related code together to reduce risk of breaking this cache
+  // - Should have equal performance since it sets a value in a flat array
+  epochCtx.effectiveBalanceIncrementsSet(validatorIndex, effectiveBalance);
+
+  // now that there is a new validator, update the epoch context with the new pubkey
+  epochCtx.addPubkey(validatorIndex, pubkey);
+
+  // Only after altair:
+  if (fork >= ForkSeq.altair) {
+    const stateAltair = state as CachedBeaconStateAltair;
+
+    stateAltair.inactivityScores.push(0);
+
+    // add participation caches
+    stateAltair.previousEpochParticipation.push(0);
+    stateAltair.currentEpochParticipation.push(0);
+  }
+
+  state.balances.push(amount);
+}
+
+export function isValidDepositSignature(
+  config: BeaconConfig,
+  pubkey: Uint8Array,
+  withdrawalCredentials: Uint8Array,
+  amount: number,
+  depositSignature: Uint8Array
+): boolean {
+  // verify the deposit signature (proof of posession) which is not checked by the deposit contract
+  const depositMessage = {
+    pubkey,
+    withdrawalCredentials,
+    amount,
+  };
+  // fork-agnostic domain since deposits are valid across forks
+  const domain = computeDomain(DOMAIN_DEPOSIT, config.GENESIS_FORK_VERSION, ZERO_HASH);
+  const signingRoot = computeSigningRoot(ssz.phase0.DepositMessage, depositMessage, domain);
+  try {
+    // Pubkeys must be checked for group + inf. This must be done only once when the validator deposit is processed
+    const publicKey = PublicKey.fromBytes(pubkey, true);
+    const signature = Signature.fromBytes(depositSignature, true);
+
+    return verify(signingRoot, publicKey, signature);
+  } catch (_e) {
+    return false; // Catch all BLS errors: failed key validation, failed signature validation, invalid signature
+  }
+}

package/src/block/processDepositRequest.ts

@@ -0,0 +1,19 @@
+import {UNSET_DEPOSIT_REQUESTS_START_INDEX} from "@lodestar/params";
+import {electra, ssz} from "@lodestar/types";
+import {CachedBeaconStateElectra} from "../types.js";
+
+export function processDepositRequest(state: CachedBeaconStateElectra, depositRequest: electra.DepositRequest): void {
+  if (state.depositRequestsStartIndex === UNSET_DEPOSIT_REQUESTS_START_INDEX) {
+    state.depositRequestsStartIndex = depositRequest.index;
+  }
+
+  // Create pending deposit
+  const pendingDeposit = ssz.electra.PendingDeposit.toViewDU({
+    pubkey: depositRequest.pubkey,
+    withdrawalCredentials: depositRequest.withdrawalCredentials,
+    amount: depositRequest.amount,
+    signature: depositRequest.signature,
+    slot: state.slot,
+  });
+  state.pendingDeposits.push(pendingDeposit);
+}

package/src/block/processEth1Data.ts

@@ -0,0 +1,86 @@
+import {Node} from "@chainsafe/persistent-merkle-tree";
+import {CompositeViewDU} from "@chainsafe/ssz";
+import {EPOCHS_PER_ETH1_VOTING_PERIOD, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {phase0, ssz} from "@lodestar/types";
+import {BeaconStateAllForks, CachedBeaconStateAllForks} from "../types.js";
+
+/**
+ * Store vote counts for every eth-execution block that has votes; if any eth-execution block wins majority support within a 1024-slot
+ * voting period, formally accept that eth-execution block and set it as the official "latest known eth-execution block" in the eth-consensus state.
+ *
+ * PERF: Processing cost depends on the current amount of votes.
+ * - Best case: Vote is already decided, zero work. See becomesNewEth1Data conditions
+ * - Worst case: 1023 votes and no majority vote yet.
+ */
+export function processEth1Data(state: CachedBeaconStateAllForks, eth1Data: phase0.Eth1Data): void {
+  // Convert to view first to hash once and compare hashes
+  const eth1DataView = ssz.phase0.Eth1Data.toViewDU(eth1Data);
+
+  if (becomesNewEth1Data(state, eth1DataView)) {
+    state.eth1Data = eth1DataView;
+  }
+
+  state.eth1DataVotes.push(eth1DataView);
+}
+
+/**
+ * Returns true if adding the given `eth1Data` to `state.eth1DataVotes` would
+ * result in a change to `state.eth1Data`.
+ */
+export function becomesNewEth1Data(
+  state: BeaconStateAllForks,
+  newEth1Data: CompositeViewDU<typeof ssz.phase0.Eth1Data>
+): boolean {
+  const SLOTS_PER_ETH1_VOTING_PERIOD = EPOCHS_PER_ETH1_VOTING_PERIOD * SLOTS_PER_EPOCH;
+
+  // If there are not more than 50% votes, then we do not have to count to find a winner.
+  if ((state.eth1DataVotes.length + 1) * 2 <= SLOTS_PER_ETH1_VOTING_PERIOD) {
+    return false;
+  }
+
+  // Nothing to do if the state already has this as eth1data (happens a lot after majority vote is in)
+  if (isEqualEth1DataView(state.eth1Data, newEth1Data)) {
+    return false;
+  }
+
+  // Close to half the EPOCHS_PER_ETH1_VOTING_PERIOD it can be expensive to do so many comparisions.
+  // `eth1DataVotes.getAllReadonly()` navigates the tree once to fetch all the LeafNodes efficiently.
+  // Then isEqualEth1DataView compares cached roots (HashObject as of Jan 2022) which is much cheaper
+  // than doing structural equality, which requires tree -> value conversions
+  let sameVotesCount = 0;
+  // biome-ignore lint/complexity/noForEach: ssz api
+  state.eth1DataVotes.forEach((eth1DataVote) => {
+    if (isEqualEth1DataView(eth1DataVote, newEth1Data)) {
+      sameVotesCount++;
+    }
+  });
+
+  // The +1 is to account for the `eth1Data` supplied to the function.
+  if ((sameVotesCount + 1) * 2 > SLOTS_PER_ETH1_VOTING_PERIOD) {
+    return true;
+  }
+  return false;
+}
+
+function isEqualEth1DataView(
+  eth1DataA: CompositeViewDU<typeof ssz.phase0.Eth1Data>,
+  eth1DataB: CompositeViewDU<typeof ssz.phase0.Eth1Data>
+): boolean {
+  return isEqualNode(eth1DataA.node, eth1DataB.node);
+}
+
+// TODO: Upstream to persistent-merkle-tree
+function isEqualNode(nA: Node, nB: Node): boolean {
+  const hA = nA.rootHashObject;
+  const hB = nB.rootHashObject;
+  return (
+    hA.h0 === hB.h0 &&
+    hA.h1 === hB.h1 &&
+    hA.h2 === hB.h2 &&
+    hA.h3 === hB.h3 &&
+    hA.h4 === hB.h4 &&
+    hA.h5 === hB.h5 &&
+    hA.h6 === hB.h6 &&
+    hA.h7 === hB.h7
+  );
+}

package/src/block/processExecutionPayload.ts

@@ -0,0 +1,84 @@
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {ForkName, ForkSeq, isForkPostDeneb} from "@lodestar/params";
+import {BeaconBlockBody, BlindedBeaconBlockBody, deneb, isExecutionPayload} from "@lodestar/types";
+import {toHex, toRootHex} from "@lodestar/utils";
+import {CachedBeaconStateBellatrix, CachedBeaconStateCapella} from "../types.js";
+import {
+  executionPayloadToPayloadHeader,
+  getFullOrBlindedPayloadFromBody,
+  isMergeTransitionComplete,
+} from "../util/execution.js";
+import {computeEpochAtSlot, computeTimeAtSlot, getRandaoMix} from "../util/index.js";
+import {BlockExternalData, ExecutionPayloadStatus} from "./externalData.js";
+
+export function processExecutionPayload(
+  fork: ForkSeq,
+  state: CachedBeaconStateBellatrix | CachedBeaconStateCapella,
+  body: BeaconBlockBody | BlindedBeaconBlockBody,
+  externalData: Omit<BlockExternalData, "dataAvailabilityStatus">
+): void {
+  const payload = getFullOrBlindedPayloadFromBody(body);
+  const forkName = ForkName[ForkSeq[fork] as ForkName];
+  // Verify consistency of the parent hash, block number, base fee per gas and gas limit
+  // with respect to the previous execution payload header
+  if (isMergeTransitionComplete(state)) {
+    const {latestExecutionPayloadHeader} = state;
+    if (!byteArrayEquals(payload.parentHash, latestExecutionPayloadHeader.blockHash)) {
+      throw Error(
+        `Invalid execution payload parentHash ${toRootHex(payload.parentHash)} latest blockHash ${toRootHex(
+          latestExecutionPayloadHeader.blockHash
+        )}`
+      );
+    }
+  }
+
+  // Verify random
+  const expectedRandom = getRandaoMix(state, state.epochCtx.epoch);
+  if (!byteArrayEquals(payload.prevRandao, expectedRandom)) {
+    throw Error(`Invalid execution payload random ${toHex(payload.prevRandao)} expected=${toHex(expectedRandom)}`);
+  }
+
+  // Verify timestamp
+  //
+  // Note: inlined function in if statement
+  // def compute_timestamp_at_slot(state: BeaconState, slot: Slot) -> uint64:
+  //   slots_since_genesis = slot - GENESIS_SLOT
+  //   return uint64(state.genesis_time + slots_since_genesis * SLOT_DURATION_MS / 1000)
+  if (payload.timestamp !== computeTimeAtSlot(state.config, state.slot, state.genesisTime)) {
+    throw Error(`Invalid timestamp ${payload.timestamp} genesisTime=${state.genesisTime} slot=${state.slot}`);
+  }
+
+  if (isForkPostDeneb(forkName)) {
+    const maxBlobsPerBlock = state.config.getMaxBlobsPerBlock(computeEpochAtSlot(state.slot));
+    const blobKzgCommitmentsLen = (body as deneb.BeaconBlockBody).blobKzgCommitments?.length ?? 0;
+    if (blobKzgCommitmentsLen > maxBlobsPerBlock) {
+      throw Error(`blobKzgCommitmentsLen of ${blobKzgCommitmentsLen} exceeds limit=${maxBlobsPerBlock}`);
+    }
+  }
+
+  // Verify the execution payload is valid
+  //
+  // if executionEngine is null, executionEngine.onPayload MUST be called after running processBlock to get the
+  // correct randao mix. Since executionEngine will be an async call in most cases it is called afterwards to keep
+  // the state transition sync
+  //
+  // Equivalent to `assert executionEngine.notifyNewPayload(payload)`
+  if (isExecutionPayload(payload)) {
+    switch (externalData.executionPayloadStatus) {
+      case ExecutionPayloadStatus.preMerge:
+        throw Error("executionPayloadStatus preMerge");
+      case ExecutionPayloadStatus.invalid:
+        throw Error("Invalid execution payload");
+      case ExecutionPayloadStatus.valid:
+        break; // ok
+    }
+  }
+
+  const payloadHeader = isExecutionPayload(payload) ? executionPayloadToPayloadHeader(fork, payload) : payload;
+
+  // TODO Deneb: Types are not happy by default. Since it's a generic type going through ViewDU
+  // transformation then into all forks compatible probably some weird intersection incompatibility happens
+  state.latestExecutionPayloadHeader = state.config
+    .getPostBellatrixForkTypes(state.slot)
+    .ExecutionPayloadHeader.toViewDU(payloadHeader) as typeof state.latestExecutionPayloadHeader;
+}

package/src/block/processOperations.ts

@@ -0,0 +1,83 @@
+import {ForkSeq} from "@lodestar/params";
+import {BeaconBlockBody, capella, electra} from "@lodestar/types";
+import {BeaconStateTransitionMetrics} from "../metrics.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateCapella, CachedBeaconStateElectra} from "../types.js";
+import {getEth1DepositCount} from "../util/deposit.js";
+import {processAttestations} from "./processAttestations.js";
+import {processAttesterSlashing} from "./processAttesterSlashing.js";
+import {processBlsToExecutionChange} from "./processBlsToExecutionChange.js";
+import {processConsolidationRequest} from "./processConsolidationRequest.js";
+import {processDeposit} from "./processDeposit.js";
+import {processDepositRequest} from "./processDepositRequest.js";
+import {processProposerSlashing} from "./processProposerSlashing.js";
+import {processVoluntaryExit} from "./processVoluntaryExit.js";
+import {processWithdrawalRequest} from "./processWithdrawalRequest.js";
+import {ProcessBlockOpts} from "./types.js";
+
+export {
+  processProposerSlashing,
+  processAttesterSlashing,
+  processAttestations,
+  processDeposit,
+  processVoluntaryExit,
+  processWithdrawalRequest,
+  processBlsToExecutionChange,
+  processDepositRequest,
+  processConsolidationRequest,
+};
+
+export function processOperations(
+  fork: ForkSeq,
+  state: CachedBeaconStateAllForks,
+  body: BeaconBlockBody,
+  opts: ProcessBlockOpts = {verifySignatures: true},
+  metrics?: BeaconStateTransitionMetrics | null
+): void {
+  // verify that outstanding deposits are processed up to the maximum number of deposits
+  const maxDeposits = getEth1DepositCount(state);
+  if (body.deposits.length !== maxDeposits) {
+    throw new Error(
+      `Block contains incorrect number of deposits: depositCount=${body.deposits.length} expected=${maxDeposits}`
+    );
+  }
+
+  for (const proposerSlashing of body.proposerSlashings) {
+    processProposerSlashing(fork, state, proposerSlashing, opts.verifySignatures);
+  }
+  for (const attesterSlashing of body.attesterSlashings) {
+    processAttesterSlashing(fork, state, attesterSlashing, opts.verifySignatures);
+  }
+
+  processAttestations(fork, state, body.attestations, opts.verifySignatures, metrics);
+
+  for (const deposit of body.deposits) {
+    processDeposit(fork, state, deposit);
+  }
+
+  for (const voluntaryExit of body.voluntaryExits) {
+    processVoluntaryExit(fork, state, voluntaryExit, opts.verifySignatures);
+  }
+
+  if (fork >= ForkSeq.capella) {
+    for (const blsToExecutionChange of (body as capella.BeaconBlockBody).blsToExecutionChanges) {
+      processBlsToExecutionChange(state as CachedBeaconStateCapella, blsToExecutionChange);
+    }
+  }
+
+  if (fork >= ForkSeq.electra) {
+    const stateElectra = state as CachedBeaconStateElectra;
+    const bodyElectra = body as electra.BeaconBlockBody;
+
+    for (const depositRequest of bodyElectra.executionRequests.deposits) {
+      processDepositRequest(stateElectra, depositRequest);
+    }
+
+    for (const elWithdrawalRequest of bodyElectra.executionRequests.withdrawals) {
+      processWithdrawalRequest(fork, stateElectra, elWithdrawalRequest);
+    }
+
+    for (const elConsolidationRequest of bodyElectra.executionRequests.consolidations) {
+      processConsolidationRequest(stateElectra, elConsolidationRequest);
+    }
+  }
+}

package/src/block/processProposerSlashing.ts

@@ -0,0 +1,66 @@
+import {ForkSeq} from "@lodestar/params";
+import {phase0, ssz} from "@lodestar/types";
+import {getProposerSlashingSignatureSets} from "../signatureSets/index.js";
+import {CachedBeaconStateAllForks} from "../types.js";
+import {isSlashableValidator} from "../util/index.js";
+import {verifySignatureSet} from "../util/signatureSets.js";
+import {slashValidator} from "./slashValidator.js";
+
+/**
+ * Process a ProposerSlashing operation. Initiates the exit of a validator, decreases the balance of the slashed
+ * validator and increases the block proposer balance.
+ *
+ * PERF: Work depends on number of ProposerSlashing per block. On regular networks the average is 0 / block.
+ */
+export function processProposerSlashing(
+  fork: ForkSeq,
+  state: CachedBeaconStateAllForks,
+  proposerSlashing: phase0.ProposerSlashing,
+  verifySignatures = true
+): void {
+  assertValidProposerSlashing(state, proposerSlashing, verifySignatures);
+
+  slashValidator(fork, state, proposerSlashing.signedHeader1.message.proposerIndex);
+}
+
+export function assertValidProposerSlashing(
+  state: CachedBeaconStateAllForks,
+  proposerSlashing: phase0.ProposerSlashing,
+  verifySignatures = true
+): void {
+  const header1 = proposerSlashing.signedHeader1.message;
+  const header2 = proposerSlashing.signedHeader2.message;
+
+  // verify header slots match
+  if (header1.slot !== header2.slot) {
+    throw new Error(`ProposerSlashing slots do not match: slot1=${header1.slot} slot2=${header2.slot}`);
+  }
+
+  // verify header proposer indices match
+  if (header1.proposerIndex !== header2.proposerIndex) {
+    throw new Error(
+      `ProposerSlashing proposer indices do not match: proposerIndex1=${header1.proposerIndex} proposerIndex2=${header2.proposerIndex}`
+    );
+  }
+
+  // verify headers are different
+  if (ssz.phase0.BeaconBlockHeaderBigint.equals(header1, header2)) {
+    throw new Error("ProposerSlashing headers are equal");
+  }
+
+  // verify the proposer is slashable
+  const proposer = state.validators.getReadonly(header1.proposerIndex);
+  if (!isSlashableValidator(proposer, state.epochCtx.epoch)) {
+    throw new Error("ProposerSlashing proposer is not slashable");
+  }
+
+  // verify signatures
+  if (verifySignatures) {
+    const signatureSets = getProposerSlashingSignatureSets(state, proposerSlashing);
+    for (let i = 0; i < signatureSets.length; i++) {
+      if (!verifySignatureSet(signatureSets[i])) {
+        throw new Error(`ProposerSlashing header${i + 1} signature invalid`);
+      }
+    }
+  }
+}

package/src/block/processRandao.ts

@@ -0,0 +1,27 @@
+import {digest} from "@chainsafe/as-sha256";
+import {EPOCHS_PER_HISTORICAL_VECTOR} from "@lodestar/params";
+import {BeaconBlock} from "@lodestar/types";
+import {xor} from "@lodestar/utils";
+import {verifyRandaoSignature} from "../signatureSets/index.js";
+import {CachedBeaconStateAllForks} from "../types.js";
+import {getRandaoMix} from "../util/index.js";
+
+/**
+ * Commit a randao reveal to generate pseudorandomness seeds
+ *
+ * PERF: Fixed work independent of block contents.
+ */
+export function processRandao(state: CachedBeaconStateAllForks, block: BeaconBlock, verifySignature = true): void {
+  const {epochCtx} = state;
+  const epoch = epochCtx.epoch;
+  const randaoReveal = block.body.randaoReveal;
+
+  // verify RANDAO reveal
+  if (verifySignature && !verifyRandaoSignature(state, block)) {
+    throw new Error("RANDAO reveal is an invalid signature");
+  }
+
+  // mix in RANDAO reveal
+  const randaoMix = xor(getRandaoMix(state, epoch), digest(randaoReveal));
+  state.randaoMixes.set(epoch % EPOCHS_PER_HISTORICAL_VECTOR, randaoMix);
+}