@lodestar/state-transition 1.35.0-dev.f80d2d52da → 1.35.0-dev.fd1dac853d

package/src/index.ts

@@ -0,0 +1,67 @@
+export {
+  type BlockExternalData,
+  DataAvailabilityStatus,
+  ExecutionPayloadStatus,
+} from "./block/externalData.js";
+export {getAttestationParticipationStatus, processAttestationsAltair} from "./block/processAttestationsAltair.js";
+export {assertValidAttesterSlashing} from "./block/processAttesterSlashing.js";
+export {isValidBlsToExecutionChange} from "./block/processBlsToExecutionChange.js";
+// BeaconChain, to prepare new blocks
+export {becomesNewEth1Data} from "./block/processEth1Data.js";
+export {assertValidProposerSlashing} from "./block/processProposerSlashing.js";
+// BeaconChain validation
+export {isValidVoluntaryExit} from "./block/processVoluntaryExit.js";
+// Withdrawals for new blocks
+export {getExpectedWithdrawals} from "./block/processWithdrawals.js";
+export {ProposerRewardType} from "./block/types.js";
+export {
+  type EffectiveBalanceIncrements,
+  getEffectiveBalanceIncrementsWithLen,
+  getEffectiveBalanceIncrementsZeroed,
+} from "./cache/effectiveBalanceIncrements.js";
+export {
+  EpochCache,
+  EpochCacheError,
+  EpochCacheErrorCode,
+  type EpochCacheImmutableData,
+  createEmptyEpochCacheImmutableData,
+} from "./cache/epochCache.js";
+export {type EpochTransitionCache, beforeProcessEpoch} from "./cache/epochTransitionCache.js";
+// Aux data-structures
+export {type Index2PubkeyCache} from "./cache/pubkeyCache.js";
+// Main state caches
+export {
+  type BeaconStateCache,
+  createCachedBeaconState,
+  isCachedBeaconState,
+  isStateBalancesNodesPopulated,
+  isStateValidatorsNodesPopulated,
+  loadCachedBeaconState,
+} from "./cache/stateCache.js";
+export * from "./constants/index.js";
+export type {EpochTransitionStep} from "./epoch/index.js";
+export {type BeaconStateTransitionMetrics, getMetrics} from "./metrics.js";
+export * from "./signatureSets/index.js";
+export * from "./stateTransition.js";
+export type {
+  BeaconStateAllForks,
+  BeaconStateAltair,
+  BeaconStateBellatrix,
+  BeaconStateCapella,
+  BeaconStateDeneb,
+  BeaconStateElectra,
+  BeaconStateExecutions,
+  BeaconStateFulu,
+  // Non-cached states
+  BeaconStatePhase0,
+  CachedBeaconStateAllForks,
+  CachedBeaconStateAltair,
+  CachedBeaconStateBellatrix,
+  CachedBeaconStateCapella,
+  CachedBeaconStateDeneb,
+  CachedBeaconStateElectra,
+  CachedBeaconStateExecutions,
+  CachedBeaconStateFulu,
+  CachedBeaconStatePhase0,
+} from "./types.js";
+export * from "./util/index.js";

package/src/metrics.ts

@@ -0,0 +1,169 @@
+import {MetricsRegister} from "@lodestar/utils";
+import {ProposerRewardType} from "./block/types.js";
+import {EpochTransitionStep} from "./epoch/index.js";
+import {StateCloneSource, StateHashTreeRootSource} from "./stateTransition.js";
+import {CachedBeaconStateAllForks} from "./types.js";
+
+export type BeaconStateTransitionMetrics = ReturnType<typeof getMetrics>;
+
+/**
+ * A collection of metrics used throughout the State Transition.
+ */
+export function getMetrics(register: MetricsRegister) {
+  // Using function style instead of class to prevent having to re-declare all MetricsPrometheus types.
+
+  return {
+    epochTransitionTime: register.histogram({
+      name: "lodestar_stfn_epoch_transition_seconds",
+      help: "Time to process a single epoch transition in seconds",
+      // as of Sep 2025, on mainnet, epoch transition time of lodestar is never less than 0.5s, and it could be up to 3s
+      buckets: [0.2, 0.5, 0.75, 1, 1.25, 1.5, 2, 2.5, 3, 10],
+    }),
+    epochTransitionCommitTime: register.histogram({
+      name: "lodestar_stfn_epoch_transition_commit_seconds",
+      help: "Time to call commit after process a single epoch transition in seconds",
+      buckets: [0.01, 0.05, 0.1, 0.2, 0.5, 0.75, 1],
+    }),
+    epochTransitionStepTime: register.histogram<{step: EpochTransitionStep}>({
+      name: "lodestar_stfn_epoch_transition_step_seconds",
+      help: "Time to call each step of epoch transition in seconds",
+      labelNames: ["step"],
+      buckets: [0.01, 0.05, 0.1, 0.2, 0.5, 0.75, 1],
+    }),
+    processBlockTime: register.histogram({
+      name: "lodestar_stfn_process_block_seconds",
+      help: "Time to process a single block in seconds",
+      // TODO: Add metrics for each step
+      // Block processing can take 5-40ms, 100ms max
+      buckets: [0.005, 0.01, 0.02, 0.05, 0.1, 1],
+    }),
+    processBlockCommitTime: register.histogram({
+      name: "lodestar_stfn_process_block_commit_seconds",
+      help: "Time to call commit after process a single block in seconds",
+      buckets: [0.005, 0.01, 0.02, 0.05, 0.1, 1],
+    }),
+    stateHashTreeRootTime: register.histogram<{source: StateHashTreeRootSource}>({
+      name: "lodestar_stfn_hash_tree_root_seconds",
+      help: "Time to compute the hash tree root of a post state in seconds",
+      buckets: [0.05, 0.1, 0.2, 0.5, 1, 1.5],
+      labelNames: ["source"],
+    }),
+    numEffectiveBalanceUpdates: register.gauge({
+      name: "lodestar_stfn_effective_balance_updates_count",
+      help: "Total count of effective balance updates",
+    }),
+    validatorsInActivationQueue: register.gauge({
+      name: "lodestar_stfn_validators_in_activation_queue",
+      help: "Current number of validators in the activation queue",
+    }),
+    validatorsInExitQueue: register.gauge({
+      name: "lodestar_stfn_validators_in_exit_queue",
+      help: "Current number of validators in the exit queue",
+    }),
+    preStateBalancesNodesPopulatedMiss: register.gauge<{source: StateCloneSource}>({
+      name: "lodestar_stfn_balances_nodes_populated_miss_total",
+      help: "Total count state.balances nodesPopulated is false on stfn",
+      labelNames: ["source"],
+    }),
+    preStateBalancesNodesPopulatedHit: register.gauge<{source: StateCloneSource}>({
+      name: "lodestar_stfn_balances_nodes_populated_hit_total",
+      help: "Total count state.balances nodesPopulated is true on stfn",
+      labelNames: ["source"],
+    }),
+    preStateValidatorsNodesPopulatedMiss: register.gauge<{source: StateCloneSource}>({
+      name: "lodestar_stfn_validators_nodes_populated_miss_total",
+      help: "Total count state.validators nodesPopulated is false on stfn",
+      labelNames: ["source"],
+    }),
+    preStateValidatorsNodesPopulatedHit: register.gauge<{source: StateCloneSource}>({
+      name: "lodestar_stfn_validators_nodes_populated_hit_total",
+      help: "Total count state.validators nodesPopulated is true on stfn",
+      labelNames: ["source"],
+    }),
+    preStateClonedCount: register.histogram({
+      name: "lodestar_stfn_state_cloned_count",
+      help: "Histogram of cloned count per state every time state.clone() is called",
+      buckets: [1, 2, 5, 10, 50, 250],
+    }),
+    postStateBalancesNodesPopulatedHit: register.gauge({
+      name: "lodestar_stfn_post_state_balances_nodes_populated_hit_total",
+      help: "Total count state.validators nodesPopulated is true on stfn for post state",
+    }),
+    postStateBalancesNodesPopulatedMiss: register.gauge({
+      name: "lodestar_stfn_post_state_balances_nodes_populated_miss_total",
+      help: "Total count state.validators nodesPopulated is false on stfn for post state",
+    }),
+    postStateValidatorsNodesPopulatedHit: register.gauge({
+      name: "lodestar_stfn_post_state_validators_nodes_populated_hit_total",
+      help: "Total count state.validators nodesPopulated is true on stfn for post state",
+    }),
+    postStateValidatorsNodesPopulatedMiss: register.gauge({
+      name: "lodestar_stfn_post_state_validators_nodes_populated_miss_total",
+      help: "Total count state.validators nodesPopulated is false on stfn for post state",
+    }),
+    newSeenAttestersPerBlock: register.gauge({
+      name: "lodestar_stfn_new_seen_attesters_per_block_total",
+      help: "Total count of new seen attesters per block",
+    }),
+    newSeenAttestersEffectiveBalancePerBlock: register.gauge({
+      name: "lodestar_stfn_new_seen_attesters_effective_balance_per_block_total",
+      help: "Total effective balance increment of new seen attesters per block",
+    }),
+    attestationsPerBlock: register.gauge({
+      name: "lodestar_stfn_attestations_per_block_total",
+      help: "Total count of attestations per block",
+    }),
+    proposerRewards: register.gauge<{type: ProposerRewardType}>({
+      name: "lodestar_stfn_proposer_rewards_total",
+      help: "Proposer reward by type per block",
+      labelNames: ["type"],
+    }),
+  };
+}
+
+export function onStateCloneMetrics(
+  state: CachedBeaconStateAllForks,
+  metrics: BeaconStateTransitionMetrics,
+  source: StateCloneSource
+): void {
+  metrics.preStateClonedCount.observe(state.clonedCount);
+
+  if (isBalancesNodesPopulated(state)) {
+    metrics.preStateBalancesNodesPopulatedHit.inc({source});
+  } else {
+    metrics.preStateBalancesNodesPopulatedMiss.inc({source});
+  }
+
+  if (isValidatorsNodesPopulated(state)) {
+    metrics.preStateValidatorsNodesPopulatedHit.inc({source});
+  } else {
+    metrics.preStateValidatorsNodesPopulatedMiss.inc({source});
+  }
+}
+
+export function onPostStateMetrics(postState: CachedBeaconStateAllForks, metrics: BeaconStateTransitionMetrics): void {
+  if (isBalancesNodesPopulated(postState)) {
+    metrics.postStateBalancesNodesPopulatedHit.inc();
+  } else {
+    metrics.postStateBalancesNodesPopulatedMiss.inc();
+  }
+
+  if (isValidatorsNodesPopulated(postState)) {
+    metrics.postStateValidatorsNodesPopulatedHit.inc();
+  } else {
+    metrics.postStateValidatorsNodesPopulatedMiss.inc();
+  }
+}
+
+// Given a CachedBeaconState, check if validators array internal cache is populated.
+// This cache is populated during epoch transition, and should be preserved for performance.
+// If the cache is missing too often, means that our clone strategy is not working well.
+function isValidatorsNodesPopulated(state: CachedBeaconStateAllForks): boolean {
+  // biome-ignore lint/complexity/useLiteralKeys: It is a private attribute
+  return state.validators["nodesPopulated"] === true;
+}
+
+function isBalancesNodesPopulated(state: CachedBeaconStateAllForks): boolean {
+  // biome-ignore lint/complexity/useLiteralKeys: It is a private attribute
+  return state.balances["nodesPopulated"] === true;
+}

package/src/signatureSets/attesterSlashings.ts

@@ -0,0 +1,39 @@
+import {DOMAIN_BEACON_ATTESTER} from "@lodestar/params";
+import {AttesterSlashing, IndexedAttestationBigint, SignedBeaconBlock, ssz} from "@lodestar/types";
+import {CachedBeaconStateAllForks} from "../types.js";
+import {ISignatureSet, SignatureSetType, computeSigningRoot, computeStartSlotAtEpoch} from "../util/index.js";
+
+/** Get signature sets from all AttesterSlashing objects in a block */
+export function getAttesterSlashingsSignatureSets(
+  state: CachedBeaconStateAllForks,
+  signedBlock: SignedBeaconBlock
+): ISignatureSet[] {
+  return signedBlock.message.body.attesterSlashings.flatMap((attesterSlashing) =>
+    getAttesterSlashingSignatureSets(state, attesterSlashing)
+  );
+}
+
+/** Get signature sets from a single AttesterSlashing object */
+export function getAttesterSlashingSignatureSets(
+  state: CachedBeaconStateAllForks,
+  attesterSlashing: AttesterSlashing
+): ISignatureSet[] {
+  return [attesterSlashing.attestation1, attesterSlashing.attestation2].map((attestation) =>
+    getIndexedAttestationBigintSignatureSet(state, attestation)
+  );
+}
+
+export function getIndexedAttestationBigintSignatureSet(
+  state: CachedBeaconStateAllForks,
+  indexedAttestation: IndexedAttestationBigint
+): ISignatureSet {
+  const slot = computeStartSlotAtEpoch(Number(indexedAttestation.data.target.epoch as bigint));
+  const domain = state.config.getDomain(state.slot, DOMAIN_BEACON_ATTESTER, slot);
+
+  return {
+    type: SignatureSetType.aggregate,
+    pubkeys: indexedAttestation.attestingIndices.map((i) => state.epochCtx.index2pubkey[i]),
+    signingRoot: computeSigningRoot(ssz.phase0.AttestationDataBigint, indexedAttestation.data, domain),
+    signature: indexedAttestation.signature,
+  };
+}

package/src/signatureSets/blsToExecutionChange.ts

@@ -0,0 +1,43 @@
+import {PublicKey} from "@chainsafe/blst";
+import {BeaconConfig} from "@lodestar/config";
+import {DOMAIN_BLS_TO_EXECUTION_CHANGE, ForkName} from "@lodestar/params";
+import {capella, ssz} from "@lodestar/types";
+import {CachedBeaconStateAllForks} from "../types.js";
+import {ISignatureSet, SignatureSetType, computeSigningRoot, verifySignatureSet} from "../util/index.js";
+
+export function verifyBlsToExecutionChangeSignature(
+  state: CachedBeaconStateAllForks,
+  signedBLSToExecutionChange: capella.SignedBLSToExecutionChange
+): boolean {
+  return verifySignatureSet(getBlsToExecutionChangeSignatureSet(state.config, signedBLSToExecutionChange));
+}
+
+/**
+ * Extract signatures to allow validating all block signatures at once
+ */
+export function getBlsToExecutionChangeSignatureSet(
+  config: BeaconConfig,
+  signedBLSToExecutionChange: capella.SignedBLSToExecutionChange
+): ISignatureSet {
+  // signatureFork for signing domain is fixed
+  const signatureFork = ForkName.phase0;
+  const domain = config.getDomainAtFork(signatureFork, DOMAIN_BLS_TO_EXECUTION_CHANGE);
+
+  return {
+    type: SignatureSetType.single,
+    // The withdrawal pubkey is the same as signedBLSToExecutionChange's fromBlsPubkey as it should
+    // be validated against the withdrawal credentials digest
+    pubkey: PublicKey.fromBytes(signedBLSToExecutionChange.message.fromBlsPubkey, true),
+    signingRoot: computeSigningRoot(ssz.capella.BLSToExecutionChange, signedBLSToExecutionChange.message, domain),
+    signature: signedBLSToExecutionChange.signature,
+  };
+}
+
+export function getBlsToExecutionChangeSignatureSets(
+  config: BeaconConfig,
+  signedBlock: capella.SignedBeaconBlock
+): ISignatureSet[] {
+  return signedBlock.message.body.blsToExecutionChanges.map((blsToExecutionChange) =>
+    getBlsToExecutionChangeSignatureSet(config, blsToExecutionChange)
+  );
+}

package/src/signatureSets/index.ts

@@ -0,0 +1,73 @@
+import {ForkSeq} from "@lodestar/params";
+import {SignedBeaconBlock, altair, capella} from "@lodestar/types";
+import {getSyncCommitteeSignatureSet} from "../block/processSyncCommittee.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../types.js";
+import {ISignatureSet} from "../util/index.js";
+import {getAttesterSlashingsSignatureSets} from "./attesterSlashings.js";
+import {getBlsToExecutionChangeSignatureSets} from "./blsToExecutionChange.js";
+import {getAttestationsSignatureSets} from "./indexedAttestation.js";
+import {getBlockProposerSignatureSet} from "./proposer.js";
+import {getProposerSlashingsSignatureSets} from "./proposerSlashings.js";
+import {getRandaoRevealSignatureSet} from "./randao.js";
+import {getVoluntaryExitsSignatureSets} from "./voluntaryExits.js";
+
+export * from "./attesterSlashings.js";
+export * from "./blsToExecutionChange.js";
+export * from "./indexedAttestation.js";
+export * from "./proposer.js";
+export * from "./proposerSlashings.js";
+export * from "./randao.js";
+export * from "./voluntaryExits.js";
+
+/**
+ * Includes all signatures on the block (except the deposit signatures) for verification.
+ * Deposits are not included because they can legally have invalid signatures.
+ */
+export function getBlockSignatureSets(
+  state: CachedBeaconStateAllForks,
+  signedBlock: SignedBeaconBlock,
+  opts?: {
+    /** Useful since block proposer signature is verified beforehand on gossip validation */
+    skipProposerSignature?: boolean;
+  }
+): ISignatureSet[] {
+  // fork based validations
+  const fork = state.config.getForkSeq(signedBlock.message.slot);
+
+  const signatureSets = [
+    getRandaoRevealSignatureSet(state, signedBlock.message),
+    ...getProposerSlashingsSignatureSets(state, signedBlock),
+    ...getAttesterSlashingsSignatureSets(state, signedBlock),
+    ...getAttestationsSignatureSets(state, signedBlock),
+    ...getVoluntaryExitsSignatureSets(state, signedBlock),
+  ];
+
+  if (!opts?.skipProposerSignature) {
+    signatureSets.push(getBlockProposerSignatureSet(state, signedBlock));
+  }
+
+  // Only after altair fork, validate tSyncCommitteeSignature
+  if (fork >= ForkSeq.altair) {
+    const syncCommitteeSignatureSet = getSyncCommitteeSignatureSet(
+      state as CachedBeaconStateAltair,
+      (signedBlock as altair.SignedBeaconBlock).message
+    );
+    // There may be no participants in this syncCommitteeSignature, so it must not be validated
+    if (syncCommitteeSignatureSet) {
+      signatureSets.push(syncCommitteeSignatureSet);
+    }
+  }
+
+  // only after capella fork
+  if (fork >= ForkSeq.capella) {
+    const blsToExecutionChangeSignatureSets = getBlsToExecutionChangeSignatureSets(
+      state.config,
+      signedBlock as capella.SignedBeaconBlock
+    );
+    if (blsToExecutionChangeSignatureSets.length > 0) {
+      signatureSets.push(...blsToExecutionChangeSignatureSets);
+    }
+  }
+
+  return signatureSets;
+}

package/src/signatureSets/indexedAttestation.ts

@@ -0,0 +1,51 @@
+import {DOMAIN_BEACON_ATTESTER} from "@lodestar/params";
+import {IndexedAttestation, SignedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {CachedBeaconStateAllForks} from "../types.js";
+import {
+  ISignatureSet,
+  computeSigningRoot,
+  computeStartSlotAtEpoch,
+  createAggregateSignatureSetFromComponents,
+} from "../util/index.js";
+
+export function getAttestationDataSigningRoot(
+  state: CachedBeaconStateAllForks,
+  data: phase0.AttestationData
+): Uint8Array {
+  const slot = computeStartSlotAtEpoch(data.target.epoch);
+  const domain = state.config.getDomain(state.slot, DOMAIN_BEACON_ATTESTER, slot);
+
+  return computeSigningRoot(ssz.phase0.AttestationData, data, domain);
+}
+
+export function getAttestationWithIndicesSignatureSet(
+  state: CachedBeaconStateAllForks,
+  attestation: Pick<phase0.Attestation, "data" | "signature">,
+  attestingIndices: number[]
+): ISignatureSet {
+  return createAggregateSignatureSetFromComponents(
+    attestingIndices.map((i) => state.epochCtx.index2pubkey[i]),
+    getAttestationDataSigningRoot(state, attestation.data),
+    attestation.signature
+  );
+}
+
+export function getIndexedAttestationSignatureSet(
+  state: CachedBeaconStateAllForks,
+  indexedAttestation: IndexedAttestation
+): ISignatureSet {
+  return getAttestationWithIndicesSignatureSet(state, indexedAttestation, indexedAttestation.attestingIndices);
+}
+
+export function getAttestationsSignatureSets(
+  state: CachedBeaconStateAllForks,
+  signedBlock: SignedBeaconBlock
+): ISignatureSet[] {
+  // TODO: figure how to get attesting indices of an attestation once per block processing
+  return signedBlock.message.body.attestations.map((attestation) =>
+    getIndexedAttestationSignatureSet(
+      state,
+      state.epochCtx.getIndexedAttestation(state.config.getForkSeq(signedBlock.message.slot), attestation)
+    )
+  );
+}

package/src/signatureSets/proposer.ts

@@ -0,0 +1,47 @@
+import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
+import {SignedBeaconBlock, SignedBlindedBeaconBlock, isBlindedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {CachedBeaconStateAllForks} from "../types.js";
+import {computeSigningRoot} from "../util/index.js";
+import {ISignatureSet, SignatureSetType, verifySignatureSet} from "../util/signatureSets.js";
+
+export function verifyProposerSignature(
+  state: CachedBeaconStateAllForks,
+  signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
+): boolean {
+  const signatureSet = getBlockProposerSignatureSet(state, signedBlock);
+  return verifySignatureSet(signatureSet);
+}
+
+export function getBlockProposerSignatureSet(
+  state: CachedBeaconStateAllForks,
+  signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
+): ISignatureSet {
+  const {config, epochCtx} = state;
+  const domain = config.getDomain(state.slot, DOMAIN_BEACON_PROPOSER, signedBlock.message.slot);
+
+  const blockType = isBlindedBeaconBlock(signedBlock.message)
+    ? config.getPostBellatrixForkTypes(signedBlock.message.slot).BlindedBeaconBlock
+    : config.getForkTypes(signedBlock.message.slot).BeaconBlock;
+
+  return {
+    type: SignatureSetType.single,
+    pubkey: epochCtx.index2pubkey[signedBlock.message.proposerIndex],
+    signingRoot: computeSigningRoot(blockType, signedBlock.message, domain),
+    signature: signedBlock.signature,
+  };
+}
+
+export function getBlockHeaderProposerSignatureSet(
+  state: CachedBeaconStateAllForks,
+  signedBlockHeader: phase0.SignedBeaconBlockHeader
+): ISignatureSet {
+  const {config, epochCtx} = state;
+  const domain = config.getDomain(state.slot, DOMAIN_BEACON_PROPOSER, signedBlockHeader.message.slot);
+
+  return {
+    type: SignatureSetType.single,
+    pubkey: epochCtx.index2pubkey[signedBlockHeader.message.proposerIndex],
+    signingRoot: computeSigningRoot(ssz.phase0.BeaconBlockHeader, signedBlockHeader.message, domain),
+    signature: signedBlockHeader.signature,
+  };
+}

package/src/signatureSets/proposerSlashings.ts

@@ -0,0 +1,41 @@
+import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
+import {SignedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {CachedBeaconStateAllForks} from "../types.js";
+import {ISignatureSet, SignatureSetType, computeSigningRoot} from "../util/index.js";
+
+/**
+ * Extract signatures to allow validating all block signatures at once
+ */
+export function getProposerSlashingSignatureSets(
+  state: CachedBeaconStateAllForks,
+  proposerSlashing: phase0.ProposerSlashing
+): ISignatureSet[] {
+  const {epochCtx} = state;
+  const pubkey = epochCtx.index2pubkey[proposerSlashing.signedHeader1.message.proposerIndex];
+
+  // In state transition, ProposerSlashing headers are only partially validated. Their slot could be higher than the
+  // clock and the slashing would still be valid. Must use bigint variants to hash correctly to all possible values
+  return [proposerSlashing.signedHeader1, proposerSlashing.signedHeader2].map((signedHeader): ISignatureSet => {
+    const domain = state.config.getDomain(
+      state.slot,
+      DOMAIN_BEACON_PROPOSER,
+      Number(signedHeader.message.slot as bigint)
+    );
+
+    return {
+      type: SignatureSetType.single,
+      pubkey,
+      signingRoot: computeSigningRoot(ssz.phase0.BeaconBlockHeaderBigint, signedHeader.message, domain),
+      signature: signedHeader.signature,
+    };
+  });
+}
+
+export function getProposerSlashingsSignatureSets(
+  state: CachedBeaconStateAllForks,
+  signedBlock: SignedBeaconBlock
+): ISignatureSet[] {
+  return signedBlock.message.body.proposerSlashings.flatMap((proposerSlashing) =>
+    getProposerSlashingSignatureSets(state, proposerSlashing)
+  );
+}

package/src/signatureSets/randao.ts

@@ -0,0 +1,31 @@
+import {DOMAIN_RANDAO} from "@lodestar/params";
+import {BeaconBlock, ssz} from "@lodestar/types";
+import {CachedBeaconStateAllForks} from "../types.js";
+import {
+  ISignatureSet,
+  SignatureSetType,
+  computeEpochAtSlot,
+  computeSigningRoot,
+  verifySignatureSet,
+} from "../util/index.js";
+
+export function verifyRandaoSignature(state: CachedBeaconStateAllForks, block: BeaconBlock): boolean {
+  return verifySignatureSet(getRandaoRevealSignatureSet(state, block));
+}
+
+/**
+ * Extract signatures to allow validating all block signatures at once
+ */
+export function getRandaoRevealSignatureSet(state: CachedBeaconStateAllForks, block: BeaconBlock): ISignatureSet {
+  const {epochCtx} = state;
+  // should not get epoch from epochCtx
+  const epoch = computeEpochAtSlot(block.slot);
+  const domain = state.config.getDomain(state.slot, DOMAIN_RANDAO, block.slot);
+
+  return {
+    type: SignatureSetType.single,
+    pubkey: epochCtx.index2pubkey[block.proposerIndex],
+    signingRoot: computeSigningRoot(ssz.Epoch, epoch, domain),
+    signature: block.body.randaoReveal,
+  };
+}

package/src/signatureSets/voluntaryExits.ts

@@ -0,0 +1,44 @@
+import {SignedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {CachedBeaconStateAllForks} from "../types.js";
+import {
+  ISignatureSet,
+  SignatureSetType,
+  computeSigningRoot,
+  computeStartSlotAtEpoch,
+  verifySignatureSet,
+} from "../util/index.js";
+
+export function verifyVoluntaryExitSignature(
+  state: CachedBeaconStateAllForks,
+  signedVoluntaryExit: phase0.SignedVoluntaryExit
+): boolean {
+  return verifySignatureSet(getVoluntaryExitSignatureSet(state, signedVoluntaryExit));
+}
+
+/**
+ * Extract signatures to allow validating all block signatures at once
+ */
+export function getVoluntaryExitSignatureSet(
+  state: CachedBeaconStateAllForks,
+  signedVoluntaryExit: phase0.SignedVoluntaryExit
+): ISignatureSet {
+  const {epochCtx} = state;
+  const slot = computeStartSlotAtEpoch(signedVoluntaryExit.message.epoch);
+  const domain = state.config.getDomainForVoluntaryExit(state.slot, slot);
+
+  return {
+    type: SignatureSetType.single,
+    pubkey: epochCtx.index2pubkey[signedVoluntaryExit.message.validatorIndex],
+    signingRoot: computeSigningRoot(ssz.phase0.VoluntaryExit, signedVoluntaryExit.message, domain),
+    signature: signedVoluntaryExit.signature,
+  };
+}
+
+export function getVoluntaryExitsSignatureSets(
+  state: CachedBeaconStateAllForks,
+  signedBlock: SignedBeaconBlock
+): ISignatureSet[] {
+  return signedBlock.message.body.voluntaryExits.map((voluntaryExit) =>
+    getVoluntaryExitSignatureSet(state, voluntaryExit)
+  );
+}

package/src/slot/index.ts

@@ -0,0 +1,32 @@
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
+import {ZERO_HASH} from "../constants/index.js";
+import {CachedBeaconStateAllForks} from "../types.js";
+
+export {upgradeStateToAltair} from "./upgradeStateToAltair.js";
+export {upgradeStateToBellatrix} from "./upgradeStateToBellatrix.js";
+export {upgradeStateToCapella} from "./upgradeStateToCapella.js";
+export {upgradeStateToDeneb} from "./upgradeStateToDeneb.js";
+export {upgradeStateToElectra} from "./upgradeStateToElectra.js";
+export {upgradeStateToFulu} from "./upgradeStateToFulu.js";
+export {upgradeStateToGloas} from "./upgradeStateToGloas.js";
+
+/**
+ * Dial state to next slot. Common for all forks
+ */
+export function processSlot(state: CachedBeaconStateAllForks): void {
+  // Cache state root
+  // Note: .hashTreeRoot() automatically commits() pending changes
+  const previousStateRoot = state.hashTreeRoot();
+  state.stateRoots.set(state.slot % SLOTS_PER_HISTORICAL_ROOT, previousStateRoot);
+
+  // Cache latest block header state root
+  if (byteArrayEquals(state.latestBlockHeader.stateRoot, ZERO_HASH)) {
+    state.latestBlockHeader.stateRoot = previousStateRoot;
+  }
+
+  // Cache block root
+  // Note: .hashTreeRoot() automatically commits() pending changes
+  const previousBlockRoot = state.latestBlockHeader.hashTreeRoot();
+  state.blockRoots.set(state.slot % SLOTS_PER_HISTORICAL_ROOT, previousBlockRoot);
+}