@lodestar/state-transition 1.35.0-dev.6e3c7ca8d0 → 1.35.0-dev.792fcea33a

package/src/block/isValidIndexedAttestation.ts

@@ -0,0 +1,70 @@
+import {ForkSeq, MAX_COMMITTEES_PER_SLOT, MAX_VALIDATORS_PER_COMMITTEE} from "@lodestar/params";
+import {IndexedAttestation, IndexedAttestationBigint} from "@lodestar/types";
+import {getIndexedAttestationBigintSignatureSet, getIndexedAttestationSignatureSet} from "../signatureSets/index.js";
+import {CachedBeaconStateAllForks} from "../types.js";
+import {verifySignatureSet} from "../util/index.js";
+
+/**
+ * Check if `indexedAttestation` has sorted and unique indices and a valid aggregate signature.
+ */
+export function isValidIndexedAttestation(
+  state: CachedBeaconStateAllForks,
+  indexedAttestation: IndexedAttestation,
+  verifySignature: boolean
+): boolean {
+  if (!isValidIndexedAttestationIndices(state, indexedAttestation.attestingIndices)) {
+    return false;
+  }
+
+  if (verifySignature) {
+    return verifySignatureSet(getIndexedAttestationSignatureSet(state, indexedAttestation));
+  }
+  return true;
+}
+
+export function isValidIndexedAttestationBigint(
+  state: CachedBeaconStateAllForks,
+  indexedAttestation: IndexedAttestationBigint,
+  verifySignature: boolean
+): boolean {
+  if (!isValidIndexedAttestationIndices(state, indexedAttestation.attestingIndices)) {
+    return false;
+  }
+
+  if (verifySignature) {
+    return verifySignatureSet(getIndexedAttestationBigintSignatureSet(state, indexedAttestation));
+  }
+  return true;
+}
+
+/**
+ * Check if `indexedAttestation` has sorted and unique indices and a valid aggregate signature.
+ */
+export function isValidIndexedAttestationIndices(state: CachedBeaconStateAllForks, indices: number[]): boolean {
+  // verify max number of indices
+  const maxIndices =
+    state.config.getForkSeq(state.slot) >= ForkSeq.electra
+      ? MAX_VALIDATORS_PER_COMMITTEE * MAX_COMMITTEES_PER_SLOT
+      : MAX_VALIDATORS_PER_COMMITTEE;
+  if (!(indices.length > 0 && indices.length <= maxIndices)) {
+    return false;
+  }
+
+  // verify indices are sorted and unique.
+  // Just check if they are monotonically increasing,
+  // instead of creating a set and sorting it. Should be (O(n)) instead of O(n log(n))
+  let prev = -1;
+  for (const index of indices) {
+    if (index <= prev) return false;
+    prev = index;
+  }
+
+  // check if indices are out of bounds, by checking the highest index (since it is sorted)
+  // TODO - SLOW CODE - Does this .length check the tree and is expensive?
+  const lastIndex = indices.at(-1);
+  if (lastIndex && lastIndex >= state.validators.length) {
+    return false;
+  }
+
+  return true;
+}

package/src/block/processAttestationPhase0.ts

@@ -0,0 +1,158 @@
+import {ForkSeq, MIN_ATTESTATION_INCLUSION_DELAY, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {Attestation, Slot, electra, phase0, ssz} from "@lodestar/types";
+import {assert, toRootHex} from "@lodestar/utils";
+import {CachedBeaconStateAllForks, CachedBeaconStatePhase0} from "../types.js";
+import {computeEndSlotAtEpoch, computeEpochAtSlot} from "../util/index.js";
+import {isValidIndexedAttestation} from "./index.js";
+
+/**
+ * Process an Attestation operation. Validates an attestation and appends it to state.currentEpochAttestations or
+ * state.previousEpochAttestations to be processed in bulk at the epoch transition.
+ *
+ * PERF: Work depends on number of Attestation per block. On mainnet the average is 89.7 / block, with 87.8 participant
+ * true bits on average. See `packages/state-transition/test/perf/analyzeBlocks.ts`
+ */
+export function processAttestationPhase0(
+  state: CachedBeaconStatePhase0,
+  attestation: phase0.Attestation,
+  verifySignature = true
+): void {
+  const {epochCtx} = state;
+  const slot = state.slot;
+  const data = attestation.data;
+
+  validateAttestation(ForkSeq.phase0, state, attestation);
+
+  const pendingAttestation = ssz.phase0.PendingAttestation.toViewDU({
+    data: data,
+    aggregationBits: attestation.aggregationBits,
+    inclusionDelay: slot - data.slot,
+    proposerIndex: epochCtx.getBeaconProposer(slot),
+  });
+
+  if (data.target.epoch === epochCtx.epoch) {
+    if (!ssz.phase0.Checkpoint.equals(data.source, state.currentJustifiedCheckpoint)) {
+      throw new Error(
+        `Attestation source does not equal current justified checkpoint: source=${checkpointToStr(
+          data.source
+        )} currentJustifiedCheckpoint=${checkpointToStr(state.currentJustifiedCheckpoint)}`
+      );
+    }
+    state.currentEpochAttestations.push(pendingAttestation);
+  } else {
+    if (!ssz.phase0.Checkpoint.equals(data.source, state.previousJustifiedCheckpoint)) {
+      throw new Error(
+        `Attestation source does not equal previous justified checkpoint: source=${checkpointToStr(
+          data.source
+        )} previousJustifiedCheckpoint=${checkpointToStr(state.previousJustifiedCheckpoint)}`
+      );
+    }
+    state.previousEpochAttestations.push(pendingAttestation);
+  }
+
+  if (!isValidIndexedAttestation(state, epochCtx.getIndexedAttestation(ForkSeq.phase0, attestation), verifySignature)) {
+    throw new Error("Attestation is not valid");
+  }
+}
+
+export function validateAttestation(fork: ForkSeq, state: CachedBeaconStateAllForks, attestation: Attestation): void {
+  const {epochCtx} = state;
+  const slot = state.slot;
+  const data = attestation.data;
+  const computedEpoch = computeEpochAtSlot(data.slot);
+  const committeeCount = epochCtx.getCommitteeCountPerSlot(computedEpoch);
+
+  if (!(data.target.epoch === epochCtx.previousShuffling.epoch || data.target.epoch === epochCtx.epoch)) {
+    throw new Error(
+      "Attestation target epoch not in previous or current epoch: " +
+        `targetEpoch=${data.target.epoch} currentEpoch=${epochCtx.epoch}`
+    );
+  }
+  if (!(data.target.epoch === computedEpoch)) {
+    throw new Error(
+      "Attestation target epoch does not match epoch computed from slot: " +
+        `targetEpoch=${data.target.epoch} computedEpoch=${computedEpoch}`
+    );
+  }
+
+  // post deneb, the attestations are valid till end of next epoch
+  if (!(data.slot + MIN_ATTESTATION_INCLUSION_DELAY <= slot && isTimelyTarget(fork, slot - data.slot))) {
+    const windowStart = data.slot + MIN_ATTESTATION_INCLUSION_DELAY;
+    const windowEnd = fork >= ForkSeq.deneb ? computeEndSlotAtEpoch(computedEpoch + 1) : data.slot + SLOTS_PER_EPOCH;
+
+    throw new Error(
+      `Attestation slot not within inclusion window: slot=${data.slot} window=${windowStart}..${windowEnd}`
+    );
+  }
+
+  if (fork >= ForkSeq.electra) {
+    assert.equal(data.index, 0, `AttestationData.index must be zero: index=${data.index}`);
+    const attestationElectra = attestation as electra.Attestation;
+    const committeeIndices = attestationElectra.committeeBits.getTrueBitIndexes();
+
+    const lastCommitteeIndex = committeeIndices.at(-1);
+    if (lastCommitteeIndex === undefined) {
+      throw Error("Attestation should have at least one committee bit set");
+    }
+
+    if (lastCommitteeIndex >= committeeCount) {
+      throw new Error(
+        `Attestation committee index exceeds committee count: lastCommitteeIndex=${lastCommitteeIndex} numCommittees=${committeeCount}`
+      );
+    }
+
+    const validatorsByCommittee = epochCtx.getBeaconCommittees(data.slot, committeeIndices);
+    const aggregationBitsArray = attestationElectra.aggregationBits.toBoolArray();
+
+    // Total number of attestation participants of every committee specified
+    let committeeOffset = 0;
+    for (const committeeValidators of validatorsByCommittee) {
+      const committeeAggregationBits = aggregationBitsArray.slice(
+        committeeOffset,
+        committeeOffset + committeeValidators.length
+      );
+
+      // Assert aggregation bits in this committee have at least one true bit
+      if (committeeAggregationBits.every((bit) => !bit)) {
+        throw new Error("Every committee in aggregation bits must have at least one attester");
+      }
+
+      committeeOffset += committeeValidators.length;
+    }
+
+    // Bitfield length matches total number of participants
+    assert.equal(
+      attestationElectra.aggregationBits.bitLen,
+      committeeOffset,
+      `Attestation aggregation bits length does not match total number of committee participants aggregationBitsLength=${attestation.aggregationBits.bitLen} participantCount=${committeeOffset}`
+    );
+  } else {
+    if (!(data.index < committeeCount)) {
+      throw new Error(
+        "Attestation committee index not within current committee count: " +
+          `committeeIndex=${data.index} committeeCount=${committeeCount}`
+      );
+    }
+
+    const committee = epochCtx.getBeaconCommittee(data.slot, data.index);
+    if (attestation.aggregationBits.bitLen !== committee.length) {
+      throw new Error(
+        "Attestation aggregation bits length does not match committee length: " +
+          `aggregationBitsLength=${attestation.aggregationBits.bitLen} committeeLength=${committee.length}`
+      );
+    }
+  }
+}
+
+// Modified https://github.com/ethereum/consensus-specs/pull/3360
+export function isTimelyTarget(fork: ForkSeq, inclusionDistance: Slot): boolean {
+  // post deneb attestation is valid till end of next epoch for target
+  if (fork >= ForkSeq.deneb) {
+    return true;
+  }
+  return inclusionDistance <= SLOTS_PER_EPOCH;
+}
+
+export function checkpointToStr(checkpoint: phase0.Checkpoint): string {
+  return `${toRootHex(checkpoint.root)}:${checkpoint.epoch}`;
+}

package/src/block/processAttestations.ts

@@ -0,0 +1,25 @@
+import {ForkSeq} from "@lodestar/params";
+import {Attestation} from "@lodestar/types";
+import {BeaconStateTransitionMetrics} from "../metrics.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateAltair, CachedBeaconStatePhase0} from "../types.js";
+import {processAttestationPhase0} from "./processAttestationPhase0.js";
+import {processAttestationsAltair} from "./processAttestationsAltair.js";
+
+/**
+ * TODO
+ */
+export function processAttestations(
+  fork: ForkSeq,
+  state: CachedBeaconStateAllForks,
+  attestations: Attestation[],
+  verifySignatures = true,
+  metrics?: BeaconStateTransitionMetrics | null
+): void {
+  if (fork === ForkSeq.phase0) {
+    for (const attestation of attestations) {
+      processAttestationPhase0(state as CachedBeaconStatePhase0, attestation, verifySignatures);
+    }
+  } else {
+    processAttestationsAltair(fork, state as CachedBeaconStateAltair, attestations, verifySignatures, metrics);
+  }
+}

package/src/block/processAttestationsAltair.ts

@@ -0,0 +1,184 @@
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {
+  ForkSeq,
+  MIN_ATTESTATION_INCLUSION_DELAY,
+  PROPOSER_WEIGHT,
+  SLOTS_PER_EPOCH,
+  TIMELY_HEAD_FLAG_INDEX,
+  TIMELY_HEAD_WEIGHT,
+  TIMELY_SOURCE_FLAG_INDEX,
+  TIMELY_SOURCE_WEIGHT,
+  TIMELY_TARGET_FLAG_INDEX,
+  TIMELY_TARGET_WEIGHT,
+  WEIGHT_DENOMINATOR,
+} from "@lodestar/params";
+import {Attestation, Epoch, phase0} from "@lodestar/types";
+import {intSqrt} from "@lodestar/utils";
+import {BeaconStateTransitionMetrics} from "../metrics.js";
+import {getAttestationWithIndicesSignatureSet} from "../signatureSets/indexedAttestation.js";
+import {CachedBeaconStateAltair} from "../types.js";
+import {increaseBalance, verifySignatureSet} from "../util/index.js";
+import {RootCache} from "../util/rootCache.js";
+import {checkpointToStr, isTimelyTarget, validateAttestation} from "./processAttestationPhase0.js";
+
+const PROPOSER_REWARD_DOMINATOR = ((WEIGHT_DENOMINATOR - PROPOSER_WEIGHT) * WEIGHT_DENOMINATOR) / PROPOSER_WEIGHT;
+
+/** Same to https://github.com/ethereum/eth2.0-specs/blob/v1.1.0-alpha.5/specs/altair/beacon-chain.md#has_flag */
+const TIMELY_SOURCE = 1 << TIMELY_SOURCE_FLAG_INDEX;
+const TIMELY_TARGET = 1 << TIMELY_TARGET_FLAG_INDEX;
+const TIMELY_HEAD = 1 << TIMELY_HEAD_FLAG_INDEX;
+const SLOTS_PER_EPOCH_SQRT = intSqrt(SLOTS_PER_EPOCH);
+
+export function processAttestationsAltair(
+  fork: ForkSeq,
+  state: CachedBeaconStateAltair,
+  attestations: Attestation[],
+  verifySignature = true,
+  metrics?: BeaconStateTransitionMetrics | null
+): void {
+  const {epochCtx} = state;
+  const {effectiveBalanceIncrements} = epochCtx;
+  const stateSlot = state.slot;
+  const rootCache = new RootCache(state);
+  const currentEpoch = epochCtx.epoch;
+
+  // Process all attestations first and then increase the balance of the proposer once
+  let proposerReward = 0;
+  let newSeenAttesters = 0;
+  let newSeenAttestersEffectiveBalance = 0;
+  for (const attestation of attestations) {
+    const data = attestation.data;
+
+    validateAttestation(fork, state, attestation);
+
+    // Retrieve the validator indices from the attestation participation bitfield
+    const attestingIndices = epochCtx.getAttestingIndices(fork, attestation);
+
+    // this check is done last because its the most expensive (if signature verification is toggled on)
+    // TODO: Why should we verify an indexed attestation that we just created? If it's just for the signature
+    // we can verify only that and nothing else.
+    if (verifySignature) {
+      const sigSet = getAttestationWithIndicesSignatureSet(state, attestation, attestingIndices);
+      if (!verifySignatureSet(sigSet)) {
+        throw new Error("Attestation signature is not valid");
+      }
+    }
+
+    const inCurrentEpoch = data.target.epoch === currentEpoch;
+    const epochParticipation = inCurrentEpoch ? state.currentEpochParticipation : state.previousEpochParticipation;
+
+    const flagsAttestation = getAttestationParticipationStatus(
+      fork,
+      data,
+      stateSlot - data.slot,
+      epochCtx.epoch,
+      rootCache
+    );
+
+    // For each participant, update their participation
+    // In epoch processing, this participation info is used to calculate balance updates
+    let totalBalanceIncrementsWithWeight = 0;
+    const validators = state.validators;
+    for (const validatorIndex of attestingIndices) {
+      const flags = epochParticipation.get(validatorIndex);
+
+      // For normal block, > 90% of attestations belong to current epoch
+      // At epoch boundary, 100% of attestations belong to previous epoch
+      // so we want to update the participation flag tree in batch
+
+      // Note ParticipationFlags type uses option {setBitwiseOR: true}, .set() does a |= operation
+      epochParticipation.set(validatorIndex, flagsAttestation);
+      // epochParticipation.setStatus(index, newStatus);
+
+      // Returns flags that are NOT set before (~ bitwise NOT) AND are set after
+      const flagsNewSet = ~flags & flagsAttestation;
+      if (flagsNewSet !== 0) {
+        newSeenAttesters++;
+        newSeenAttestersEffectiveBalance += effectiveBalanceIncrements[validatorIndex];
+      }
+
+      // Spec:
+      // baseReward = state.validators[index].effectiveBalance / EFFECTIVE_BALANCE_INCREMENT * baseRewardPerIncrement;
+      // proposerRewardNumerator += baseReward * totalWeight
+      let totalWeight = 0;
+      if ((flagsNewSet & TIMELY_SOURCE) === TIMELY_SOURCE) totalWeight += TIMELY_SOURCE_WEIGHT;
+      if ((flagsNewSet & TIMELY_TARGET) === TIMELY_TARGET) totalWeight += TIMELY_TARGET_WEIGHT;
+      if ((flagsNewSet & TIMELY_HEAD) === TIMELY_HEAD) totalWeight += TIMELY_HEAD_WEIGHT;
+
+      if (totalWeight > 0) {
+        totalBalanceIncrementsWithWeight += effectiveBalanceIncrements[validatorIndex] * totalWeight;
+      }
+
+      // TODO: describe issue. Compute progressive target balances
+      // When processing each attestation, increase the cummulative target balance. Only applies post-altair
+      if ((flagsNewSet & TIMELY_TARGET) === TIMELY_TARGET) {
+        const validator = validators.getReadonly(validatorIndex);
+        if (!validator.slashed) {
+          if (inCurrentEpoch) {
+            epochCtx.currentTargetUnslashedBalanceIncrements += effectiveBalanceIncrements[validatorIndex];
+          } else {
+            epochCtx.previousTargetUnslashedBalanceIncrements += effectiveBalanceIncrements[validatorIndex];
+          }
+        }
+      }
+    }
+
+    // Do the discrete math inside the loop to ensure a deterministic result
+    const totalIncrements = totalBalanceIncrementsWithWeight;
+    const proposerRewardNumerator = totalIncrements * state.epochCtx.baseRewardPerIncrement;
+    proposerReward += Math.floor(proposerRewardNumerator / PROPOSER_REWARD_DOMINATOR);
+  }
+
+  metrics?.newSeenAttestersPerBlock.set(newSeenAttesters);
+  metrics?.newSeenAttestersEffectiveBalancePerBlock.set(newSeenAttestersEffectiveBalance);
+  metrics?.attestationsPerBlock.set(attestations.length);
+
+  increaseBalance(state, epochCtx.getBeaconProposer(state.slot), proposerReward);
+  state.proposerRewards.attestations = proposerReward;
+}
+
+/**
+ * https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/altair/beacon-chain.md#get_attestation_participation_flag_indices
+ */
+export function getAttestationParticipationStatus(
+  fork: ForkSeq,
+  data: phase0.AttestationData,
+  inclusionDelay: number,
+  currentEpoch: Epoch,
+  rootCache: RootCache
+): number {
+  const justifiedCheckpoint =
+    data.target.epoch === currentEpoch ? rootCache.currentJustifiedCheckpoint : rootCache.previousJustifiedCheckpoint;
+
+  // The source and target votes are part of the FFG vote, the head vote is part of the fork choice vote
+  // Both are tracked to properly incentivise validators
+  //
+  // The source vote always matches the justified checkpoint (else its invalid)
+  // The target vote should match the most recent checkpoint (eg: the first root of the epoch)
+  // The head vote should match the root at the attestation slot (eg: the root at data.slot)
+  const isMatchingSource = checkpointValueEquals(data.source, justifiedCheckpoint);
+  if (!isMatchingSource) {
+    throw new Error(
+      `Attestation source does not equal justified checkpoint: source=${checkpointToStr(
+        data.source
+      )} justifiedCheckpoint=${checkpointToStr(justifiedCheckpoint)}`
+    );
+  }
+
+  const isMatchingTarget = byteArrayEquals(data.target.root, rootCache.getBlockRoot(data.target.epoch));
+
+  // a timely head is only be set if the target is _also_ matching
+  const isMatchingHead =
+    isMatchingTarget && byteArrayEquals(data.beaconBlockRoot, rootCache.getBlockRootAtSlot(data.slot));
+
+  let flags = 0;
+  if (isMatchingSource && inclusionDelay <= SLOTS_PER_EPOCH_SQRT) flags |= TIMELY_SOURCE;
+  if (isMatchingTarget && isTimelyTarget(fork, inclusionDelay)) flags |= TIMELY_TARGET;
+  if (isMatchingHead && inclusionDelay === MIN_ATTESTATION_INCLUSION_DELAY) flags |= TIMELY_HEAD;
+
+  return flags;
+}
+
+export function checkpointValueEquals(cp1: phase0.Checkpoint, cp2: phase0.Checkpoint): boolean {
+  return cp1.epoch === cp2.epoch && byteArrayEquals(cp1.root, cp2.root);
+}

package/src/block/processAttesterSlashing.ts

@@ -0,0 +1,59 @@
+import {ForkSeq} from "@lodestar/params";
+import {AttesterSlashing} from "@lodestar/types";
+import {CachedBeaconStateAllForks} from "../types.js";
+import {getAttesterSlashableIndices, isSlashableAttestationData, isSlashableValidator} from "../util/index.js";
+import {isValidIndexedAttestationBigint} from "./isValidIndexedAttestation.js";
+import {slashValidator} from "./slashValidator.js";
+
+/**
+ * Process an AttesterSlashing operation. Initiates the exit of a validator, decreases the balance of the slashed
+ * validators and increases the block proposer balance.
+ *
+ * PERF: Work depends on number of AttesterSlashing per block. On regular networks the average is 0 / block.
+ */
+export function processAttesterSlashing(
+  fork: ForkSeq,
+  state: CachedBeaconStateAllForks,
+  attesterSlashing: AttesterSlashing,
+  verifySignatures = true
+): void {
+  assertValidAttesterSlashing(state, attesterSlashing, verifySignatures);
+
+  const intersectingIndices = getAttesterSlashableIndices(attesterSlashing);
+
+  let slashedAny = false;
+  const validators = state.validators; // Get the validators sub tree once for all indices
+  // Spec requires to sort indexes beforehand
+  for (const index of intersectingIndices.sort((a, b) => a - b)) {
+    if (isSlashableValidator(validators.getReadonly(index), state.epochCtx.epoch)) {
+      slashValidator(fork, state, index);
+      slashedAny = true;
+    }
+  }
+
+  if (!slashedAny) {
+    throw new Error("AttesterSlashing did not result in any slashings");
+  }
+}
+
+export function assertValidAttesterSlashing(
+  state: CachedBeaconStateAllForks,
+  attesterSlashing: AttesterSlashing,
+  verifySignatures = true
+): void {
+  const attestation1 = attesterSlashing.attestation1;
+  const attestation2 = attesterSlashing.attestation2;
+
+  if (!isSlashableAttestationData(attestation1.data, attestation2.data)) {
+    throw new Error("AttesterSlashing is not slashable");
+  }
+
+  // In state transition, AttesterSlashing attestations are only partially validated. Their slot and epoch could
+  // be higher than the clock and the slashing would still be valid. Same applies to attestation data index, which
+  // can be any arbitrary value. Must use bigint variants to hash correctly to all possible values
+  for (const [i, attestation] of [attestation1, attestation2].entries()) {
+    if (!isValidIndexedAttestationBigint(state, attestation, verifySignatures)) {
+      throw new Error(`AttesterSlashing attestation${i} is invalid`);
+    }
+  }
+}

package/src/block/processBlobKzgCommitments.ts

@@ -0,0 +1,21 @@
+import {BlockExternalData, ExecutionPayloadStatus} from "./externalData.js";
+
+/**
+ * https://github.com/ethereum/consensus-specs/blob/11a037fd9227e29ee809c9397b09f8cc3383a8c0/specs/eip4844/beacon-chain.md#blob-kzg-commitments
+ *
+ * def process_blob_kzg_commitments(state: BeaconState, body: BeaconBlockBody):
+ *   assert verify_kzg_commitments_against_transactions(
+ *     body.execution_payload.transactions,
+ *     body.blob_kzg_commitments
+ *   )
+ */
+export function processBlobKzgCommitments(externalData: BlockExternalData): void {
+  switch (externalData.executionPayloadStatus) {
+    case ExecutionPayloadStatus.preMerge:
+      throw Error("executionPayloadStatus preMerge");
+    case ExecutionPayloadStatus.invalid:
+      throw Error("Invalid execution payload");
+    case ExecutionPayloadStatus.valid:
+      break; // ok
+  }
+}

package/src/block/processBlockHeader.ts

@@ -0,0 +1,54 @@
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {BeaconBlock, BlindedBeaconBlock, ssz} from "@lodestar/types";
+import {toRootHex} from "@lodestar/utils";
+import {ZERO_HASH} from "../constants/index.js";
+import {CachedBeaconStateAllForks} from "../types.js";
+import {blindedOrFullBlockToHeader} from "../util/index.js";
+/**
+ * Converts a Deposit record (created by the eth-execution deposit contract) into a Validator object that goes into the eth-consensus state.
+ *
+ * PERF: Fixed work independent of block contents.
+ * NOTE: `block` body root MUST be pre-cached.
+ */
+export function processBlockHeader(state: CachedBeaconStateAllForks, block: BeaconBlock | BlindedBeaconBlock): void {
+  const slot = state.slot;
+  // verify that the slots match
+  if (block.slot !== slot) {
+    throw new Error(`Block slot does not match state slot blockSlot=${block.slot} stateSlot=${slot}`);
+  }
+  // Verify that the block is newer than latest block header
+  if (!(block.slot > state.latestBlockHeader.slot)) {
+    throw new Error(
+      `Block is not newer than latest block header blockSlot=${block.slot} latestBlockHeader.slot=${state.latestBlockHeader.slot}`
+    );
+  }
+  // verify that proposer index is the correct index
+  const proposerIndex = state.epochCtx.getBeaconProposer(slot);
+  if (block.proposerIndex !== proposerIndex) {
+    throw new Error(
+      `Block proposer index does not match state proposer index blockProposerIndex=${block.proposerIndex} stateProposerIndex=${proposerIndex}`
+    );
+  }
+
+  // verify that the parent matches
+  if (!byteArrayEquals(block.parentRoot, ssz.phase0.BeaconBlockHeader.hashTreeRoot(state.latestBlockHeader))) {
+    throw new Error(
+      `Block parent root ${toRootHex(block.parentRoot)} does not match state latest block, block slot=${slot}`
+    );
+  }
+
+  const blockHeader = blindedOrFullBlockToHeader(state.config, block);
+  // cache current block as the new latest block
+  state.latestBlockHeader = ssz.phase0.BeaconBlockHeader.toViewDU({
+    slot,
+    proposerIndex,
+    parentRoot: block.parentRoot,
+    stateRoot: ZERO_HASH,
+    bodyRoot: blockHeader.bodyRoot,
+  });
+
+  // verify proposer is not slashed. Only once per block, may use the slower read from tree
+  if (state.validators.getReadonly(proposerIndex).slashed) {
+    throw new Error("Block proposer is slashed");
+  }
+}

package/src/block/processBlsToExecutionChange.ts

@@ -0,0 +1,78 @@
+import {digest} from "@chainsafe/as-sha256";
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {BLS_WITHDRAWAL_PREFIX, ETH1_ADDRESS_WITHDRAWAL_PREFIX} from "@lodestar/params";
+import {capella} from "@lodestar/types";
+import {toHex} from "@lodestar/utils";
+import {verifyBlsToExecutionChangeSignature} from "../signatureSets/index.js";
+import {CachedBeaconStateCapella} from "../types.js";
+
+export function processBlsToExecutionChange(
+  state: CachedBeaconStateCapella,
+  signedBlsToExecutionChange: capella.SignedBLSToExecutionChange
+): void {
+  const addressChange = signedBlsToExecutionChange.message;
+
+  const validation = isValidBlsToExecutionChange(state, signedBlsToExecutionChange, true);
+  if (!validation.valid) {
+    throw validation.error;
+  }
+
+  const validator = state.validators.get(addressChange.validatorIndex);
+  const newWithdrawalCredentials = new Uint8Array(32);
+  newWithdrawalCredentials[0] = ETH1_ADDRESS_WITHDRAWAL_PREFIX;
+  newWithdrawalCredentials.set(addressChange.toExecutionAddress, 12);
+
+  // Set the new credentials back
+  validator.withdrawalCredentials = newWithdrawalCredentials;
+}
+
+export function isValidBlsToExecutionChange(
+  state: CachedBeaconStateCapella,
+  signedBLSToExecutionChange: capella.SignedBLSToExecutionChange,
+  verifySignature = true
+): {valid: true} | {valid: false; error: Error} {
+  const addressChange = signedBLSToExecutionChange.message;
+
+  if (addressChange.validatorIndex >= state.validators.length) {
+    return {
+      valid: false,
+      error: Error(
+        `withdrawalValidatorIndex ${addressChange.validatorIndex} > state.validators len ${state.validators.length}`
+      ),
+    };
+  }
+
+  const validator = state.validators.getReadonly(addressChange.validatorIndex);
+  const {withdrawalCredentials} = validator;
+  if (withdrawalCredentials[0] !== BLS_WITHDRAWAL_PREFIX) {
+    return {
+      valid: false,
+      error: Error(
+        `Invalid withdrawalCredentials prefix expected=${BLS_WITHDRAWAL_PREFIX} actual=${withdrawalCredentials[0]}`
+      ),
+    };
+  }
+
+  const digestCredentials = digest(addressChange.fromBlsPubkey);
+  // Set the BLS_WITHDRAWAL_PREFIX on the digestCredentials for direct match
+  digestCredentials[0] = BLS_WITHDRAWAL_PREFIX;
+  if (!byteArrayEquals(withdrawalCredentials, digestCredentials)) {
+    return {
+      valid: false,
+      error: Error(
+        `Invalid withdrawalCredentials expected=${toHex(withdrawalCredentials)} actual=${toHex(digestCredentials)}`
+      ),
+    };
+  }
+
+  if (verifySignature && !verifyBlsToExecutionChangeSignature(state, signedBLSToExecutionChange)) {
+    return {
+      valid: false,
+      error: Error(
+        `Signature could not be verified for BLS to Execution Change for validatorIndex${addressChange.validatorIndex}`
+      ),
+    };
+  }
+
+  return {valid: true};
+}