@lodestar/state-transition 1.48.0-dev.f22c5ce63e → 1.48.0-rc.0

package/src/block/processOperations.ts

@@ -1,12 +1,4 @@
-import {
-  ForkSeq,
-  MAX_ATTESTATIONS_ELECTRA,
-  MAX_ATTESTER_SLASHINGS_ELECTRA,
-  MAX_BLS_TO_EXECUTION_CHANGES,
-  MAX_PAYLOAD_ATTESTATIONS,
-  MAX_PROPOSER_SLASHINGS,
-  MAX_VOLUNTARY_EXITS,
-} from "@lodestar/params";
+import {ForkSeq} from "@lodestar/params";
 import {BeaconBlockBody, Slot, capella, electra, gloas} from "@lodestar/types";
 import {BeaconStateTransitionMetrics} from "../metrics.js";
 import {
@@ -26,7 +18,7 @@ import {processPayloadAttestation} from "./processPayloadAttestation.js";
 import {processProposerSlashing} from "./processProposerSlashing.js";
 import {processVoluntaryExit} from "./processVoluntaryExit.js";
 import {processWithdrawalRequest} from "./processWithdrawalRequest.js";
-import {ProcessBlockOpts} from "./types.js";
+import {ProcessBlockOpts, ProcessOperationsStep} from "./types.js";
 
 export {
   processProposerSlashing,
@@ -48,10 +40,6 @@ export function processOperations(
   opts: ProcessBlockOpts = {verifySignatures: true},
   metrics?: BeaconStateTransitionMetrics | null
 ): void {
-  if (fork >= ForkSeq.gloas) {
-    assertGloasOperationLimits(body as gloas.BeaconBlockBody);
-  }
-
   // verify that outstanding deposits are processed up to the maximum number of deposits.
   // From Fulu the eth1 bridge deposit mechanism was removed, so blocks must not contain any deposits.
   const maxDeposits = fork >= ForkSeq.fulu ? 0 : getEth1DepositCount(state);
@@ -61,64 +49,94 @@ export function processOperations(
     );
   }
 
-  for (const proposerSlashing of body.proposerSlashings) {
-    processProposerSlashing(fork, state, proposerSlashing, opts.verifySignatures);
+  {
+    const timer = metrics?.processOperationsStepTime.startTimer({step: ProcessOperationsStep.processProposerSlashing});
+    for (const proposerSlashing of body.proposerSlashings) {
+      processProposerSlashing(fork, state, proposerSlashing, opts.verifySignatures);
+    }
+    timer?.();
   }
-  for (const attesterSlashing of body.attesterSlashings) {
-    processAttesterSlashing(fork, state, attesterSlashing, opts.verifySignatures);
+
+  {
+    const timer = metrics?.processOperationsStepTime.startTimer({step: ProcessOperationsStep.processAttesterSlashing});
+    for (const attesterSlashing of body.attesterSlashings) {
+      processAttesterSlashing(fork, state, attesterSlashing, opts.verifySignatures);
+    }
+    timer?.();
   }
 
-  processAttestations(fork, state, body.attestations, parentSlot, opts.verifySignatures, metrics);
+  {
+    const timer = metrics?.processOperationsStepTime.startTimer({step: ProcessOperationsStep.processAttestations});
+    processAttestations(fork, state, body.attestations, parentSlot, opts.verifySignatures, metrics);
+    timer?.();
+  }
 
-  for (const deposit of body.deposits) {
-    processDeposit(fork, state, deposit);
+  {
+    const timer = metrics?.processOperationsStepTime.startTimer({step: ProcessOperationsStep.processDeposit});
+    for (const deposit of body.deposits) {
+      processDeposit(fork, state, deposit);
+    }
+    timer?.();
   }
 
-  for (const voluntaryExit of body.voluntaryExits) {
-    processVoluntaryExit(fork, state, voluntaryExit, opts.verifySignatures);
+  {
+    const timer = metrics?.processOperationsStepTime.startTimer({step: ProcessOperationsStep.processVoluntaryExit});
+    for (const voluntaryExit of body.voluntaryExits) {
+      processVoluntaryExit(fork, state, voluntaryExit, opts.verifySignatures);
+    }
+    timer?.();
   }
 
   if (fork >= ForkSeq.capella) {
+    const timer = metrics?.processOperationsStepTime.startTimer({
+      step: ProcessOperationsStep.processBlsToExecutionChange,
+    });
     for (const blsToExecutionChange of (body as capella.BeaconBlockBody).blsToExecutionChanges) {
       processBlsToExecutionChange(state as CachedBeaconStateCapella, blsToExecutionChange);
     }
+    timer?.();
   }
 
   if (fork >= ForkSeq.electra && fork < ForkSeq.gloas) {
     const stateElectra = state as CachedBeaconStateElectra;
     const bodyElectra = body as electra.BeaconBlockBody;
 
-    for (const depositRequest of bodyElectra.executionRequests.deposits) {
-      processDepositRequest(fork, stateElectra, depositRequest);
+    {
+      const timer = metrics?.processOperationsStepTime.startTimer({step: ProcessOperationsStep.processDepositRequest});
+      for (const depositRequest of bodyElectra.executionRequests.deposits) {
+        processDepositRequest(fork, stateElectra, depositRequest);
+      }
+      timer?.();
     }
 
-    for (const elWithdrawalRequest of bodyElectra.executionRequests.withdrawals) {
-      processWithdrawalRequest(fork, stateElectra, elWithdrawalRequest);
+    {
+      const timer = metrics?.processOperationsStepTime.startTimer({
+        step: ProcessOperationsStep.processWithdrawalRequest,
+      });
+      for (const elWithdrawalRequest of bodyElectra.executionRequests.withdrawals) {
+        processWithdrawalRequest(fork, stateElectra, elWithdrawalRequest);
+      }
+      timer?.();
     }
 
-    for (const elConsolidationRequest of bodyElectra.executionRequests.consolidations) {
-      processConsolidationRequest(stateElectra, elConsolidationRequest);
+    {
+      const timer = metrics?.processOperationsStepTime.startTimer({
+        step: ProcessOperationsStep.processConsolidationRequest,
+      });
+      for (const elConsolidationRequest of bodyElectra.executionRequests.consolidations) {
+        processConsolidationRequest(stateElectra, elConsolidationRequest);
+      }
+      timer?.();
     }
   }
 
   if (fork >= ForkSeq.gloas) {
+    const timer = metrics?.processOperationsStepTime.startTimer({
+      step: ProcessOperationsStep.processPayloadAttestation,
+    });
     for (const payloadAttestation of (body as gloas.BeaconBlockBody).payloadAttestations) {
-      processPayloadAttestation(state as CachedBeaconStateGloas, payloadAttestation);
+      processPayloadAttestation(state as CachedBeaconStateGloas, payloadAttestation, opts.verifySignatures);
     }
-  }
-}
-
-function assertGloasOperationLimits(body: gloas.BeaconBlockBody): void {
-  assertMaxLength("proposerSlashings", body.proposerSlashings.length, MAX_PROPOSER_SLASHINGS);
-  assertMaxLength("attesterSlashings", body.attesterSlashings.length, MAX_ATTESTER_SLASHINGS_ELECTRA);
-  assertMaxLength("attestations", body.attestations.length, MAX_ATTESTATIONS_ELECTRA);
-  assertMaxLength("voluntaryExits", body.voluntaryExits.length, MAX_VOLUNTARY_EXITS);
-  assertMaxLength("blsToExecutionChanges", body.blsToExecutionChanges.length, MAX_BLS_TO_EXECUTION_CHANGES);
-  assertMaxLength("payloadAttestations", body.payloadAttestations.length, MAX_PAYLOAD_ATTESTATIONS);
-}
-
-function assertMaxLength(name: string, length: number, limit: number): void {
-  if (length > limit) {
-    throw new Error(`Block contains too many ${name}: count=${length} limit=${limit}`);
+    timer?.();
   }
 }

package/src/block/processParentExecutionPayload.ts

@@ -1,12 +1,4 @@
-import {
-  ForkPostGloas,
-  MAX_BUILDER_DEPOSIT_REQUESTS_PER_PAYLOAD,
-  MAX_BUILDER_EXIT_REQUESTS_PER_PAYLOAD,
-  MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD,
-  MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD,
-  SLOTS_PER_EPOCH,
-  SLOTS_PER_HISTORICAL_ROOT,
-} from "@lodestar/params";
+import {ForkPostGloas, SLOTS_PER_EPOCH, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
 import {BeaconBlock, gloas, ssz} from "@lodestar/types";
 import {byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {CachedBeaconStateGloas} from "../types.js";
@@ -55,11 +47,9 @@ export function processParentExecutionPayload(state: CachedBeaconStateGloas, blo
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.6/specs/gloas/beacon-chain.md#new-apply_parent_execution_payload
  */
 export function applyParentExecutionPayload(state: CachedBeaconStateGloas, requests: gloas.ExecutionRequests): void {
-  assertExecutionRequestsWithinLimits(requests);
-
   const fork = state.config.getForkSeq(state.slot);
   const parentBid = state.latestExecutionPayloadBid;
-  const parentSlot = parentBid.slot;
+  const parentSlot = state.latestBlockHeader.slot;
   const parentEpoch = computeEpochAtSlot(parentSlot);
   const currentEpoch = computeEpochAtSlot(state.slot);
 
@@ -126,21 +116,6 @@ function settleBuilderPayment(state: CachedBeaconStateGloas, paymentIndex: numbe
   state.builderPendingPayments.set(paymentIndex, ssz.gloas.BuilderPendingPayment.defaultViewDU());
 }
 
-function assertExecutionRequestsWithinLimits(requests: gloas.ExecutionRequests): void {
-  assertMaxLength("withdrawals", requests.withdrawals.length, MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD);
-  assertMaxLength("consolidations", requests.consolidations.length, MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD);
-  // New in GLOAS:EIP8282
-  assertMaxLength("builderDeposits", requests.builderDeposits.length, MAX_BUILDER_DEPOSIT_REQUESTS_PER_PAYLOAD);
-  // New in GLOAS:EIP8282
-  assertMaxLength("builderExits", requests.builderExits.length, MAX_BUILDER_EXIT_REQUESTS_PER_PAYLOAD);
-}
-
-function assertMaxLength(name: string, length: number, limit: number): void {
-  if (length > limit) {
-    throw new Error(`Too many parent execution request ${name} count=${length} limit=${limit}`);
-  }
-}
-
 function assertEmptyExecutionRequests(requests: gloas.ExecutionRequests): void {
   if (
     requests.deposits.length !== 0 ||

package/src/block/processPayloadAttestation.ts

@@ -5,7 +5,8 @@ import {isValidIndexedPayloadAttestation} from "./isValidIndexedPayloadAttestati
 
 export function processPayloadAttestation(
   state: CachedBeaconStateGloas,
-  payloadAttestation: gloas.PayloadAttestation
+  payloadAttestation: gloas.PayloadAttestation,
+  verifySignature = true
 ): void {
   const data = payloadAttestation.data;
 
@@ -19,7 +20,7 @@ export function processPayloadAttestation(
 
   const indexedPayloadAttestation = state.epochCtx.getIndexedPayloadAttestation(data.slot, payloadAttestation);
 
-  if (!isValidIndexedPayloadAttestation(state, indexedPayloadAttestation, true)) {
+  if (!isValidIndexedPayloadAttestation(state, indexedPayloadAttestation, verifySignature)) {
     throw Error("Invalid payload attestation");
   }
 }

package/src/block/processWithdrawals.ts

@@ -212,7 +212,12 @@ function getBuildersSweepWithdrawals(
       break;
     }
 
-    // Get next builder in turn
+    // Get next builder in turn, the spec does not wrap around an out of bounds start index
+    if (n === 0 && state.nextWithdrawalBuilderIndex >= builders.length) {
+      throw Error(
+        `Next withdrawal builder index ${state.nextWithdrawalBuilderIndex} out of bounds, builders count ${builders.length}`
+      );
+    }
     const builderIndex = (state.nextWithdrawalBuilderIndex + n) % builders.length;
     const builder = builders.getReadonly(builderIndex);
 
@@ -340,7 +345,12 @@ function getValidatorsSweepWithdrawals(
       break;
     }
 
-    // Get next validator in turn
+    // Get next validator in turn, the spec does not wrap around an out of bounds start index
+    if (n === 0 && nextWithdrawalValidatorIndex >= validators.length) {
+      throw Error(
+        `Next withdrawal validator index ${nextWithdrawalValidatorIndex} out of bounds, validators count ${validators.length}`
+      );
+    }
     const validatorIndex = (nextWithdrawalValidatorIndex + n) % validators.length;
 
     const validator = validators.getReadonly(validatorIndex);

package/src/block/types.ts

@@ -7,3 +7,35 @@ export enum ProposerRewardType {
   syncAggregate = "sync_aggregate",
   slashing = "slashing",
 }
+
+/**
+ * Steps of `processBlock()` tracked in metrics
+ */
+export enum BlockProcessStep {
+  processParentExecutionPayload = "processParentExecutionPayload",
+  processBlockHeader = "processBlockHeader",
+  processWithdrawals = "processWithdrawals",
+  processExecutionPayload = "processExecutionPayload",
+  processExecutionPayloadBid = "processExecutionPayloadBid",
+  processRandao = "processRandao",
+  processEth1Data = "processEth1Data",
+  processOperations = "processOperations",
+  processSyncAggregate = "processSyncAggregate",
+  processBlobKzgCommitments = "processBlobKzgCommitments",
+}
+
+/**
+ * Steps of `processOperations()` tracked in metrics
+ */
+export enum ProcessOperationsStep {
+  processProposerSlashing = "processProposerSlashing",
+  processAttesterSlashing = "processAttesterSlashing",
+  processAttestations = "processAttestations",
+  processDeposit = "processDeposit",
+  processVoluntaryExit = "processVoluntaryExit",
+  processBlsToExecutionChange = "processBlsToExecutionChange",
+  processDepositRequest = "processDepositRequest",
+  processWithdrawalRequest = "processWithdrawalRequest",
+  processConsolidationRequest = "processConsolidationRequest",
+  processPayloadAttestation = "processPayloadAttestation",
+}

package/src/epoch/processInactivityUpdates.ts

@@ -37,6 +37,7 @@ export function processInactivityUpdates(state: CachedBeaconStateAltair, cache:
 
   inactivityScoresArr.length = state.validators.length;
   inactivityScores.getAll(inactivityScoresArr);
+  let shouldSetInactivityScores = false;
 
   for (let i = 0; i < flags.length; i++) {
     const flag = flags[i];
@@ -53,8 +54,14 @@ export function processInactivityUpdates(state: CachedBeaconStateAltair, cache:
         inactivityScore -= Math.min(INACTIVITY_SCORE_RECOVERY_RATE, inactivityScore);
       }
       if (inactivityScore !== prevInactivityScore) {
-        inactivityScores.set(i, inactivityScore);
+        inactivityScoresArr[i] = inactivityScore;
+        shouldSetInactivityScores = true;
       }
     }
   }
+
+  if (shouldSetInactivityScores) {
+    // Rebuilding the full view is slightly slower than individual sets only when very few scores change.
+    state.inactivityScores = state.type.fields.inactivityScores.toViewDU(inactivityScoresArr);
+  }
 }

package/src/epoch/processPtcWindow.ts

@@ -1,4 +1,4 @@
-import {MIN_SEED_LOOKAHEAD} from "@lodestar/params";
+import {MIN_SEED_LOOKAHEAD, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
 import {CachedBeaconStateGloas, EpochTransitionCache} from "../types.js";
 import {computeEpochShuffling} from "../util/epochShuffling.js";
@@ -22,17 +22,24 @@ export function processPtcWindow(state: CachedBeaconStateGloas, cache: EpochTran
     state,
     nextEpoch,
     nextEpochShuffling.committees,
+    nextEpochShuffling.shuffling,
     state.epochCtx.effectiveBalanceIncrements
   );
 
   // Stash for finalProcessEpoch to shift into epoch cache
   cache.nextEpochPayloadTimelinessCommittees = newNextPayloadTimelinessCommittees;
 
-  // Write shifted window to state: current(N) + next(N+1) + newlyComputed(N+2)
-  // From the perspective of upcoming epoch N+1, this is previous + current + next
-  state.ptcWindow = ssz.gloas.PtcWindow.toViewDU([
-    ...state.epochCtx.payloadTimelinessCommittees,
-    ...state.epochCtx.nextPayloadTimelinessCommittees,
-    ...newNextPayloadTimelinessCommittees,
-  ]);
+  // Shift the current and next epochs forward by reusing their SSZ subtrees and cached hashes.
+  // Only the newly computed epoch needs new subtrees.
+  const ptcWindow = state.ptcWindow;
+  const retainedLength = ptcWindow.length - SLOTS_PER_EPOCH;
+  for (let i = 0; i < retainedLength; i++) {
+    ptcWindow.set(i, ptcWindow.getReadonly(i + SLOTS_PER_EPOCH));
+  }
+  for (let i = 0; i < SLOTS_PER_EPOCH; i++) {
+    ptcWindow.set(
+      retainedLength + i,
+      ssz.gloas.PayloadTimelinessCommittee.toViewDU(newNextPayloadTimelinessCommittees[i])
+    );
+  }
 }

package/src/index.ts

@@ -13,7 +13,7 @@ export {
 } from "./block/processVoluntaryExit.js";
 // Withdrawals for new blocks
 export {getExpectedWithdrawals} from "./block/processWithdrawals.js";
-export {ProposerRewardType} from "./block/types.js";
+export {BlockProcessStep, ProcessOperationsStep, ProposerRewardType} from "./block/types.js";
 export {
   type EffectiveBalanceIncrements,
   getEffectiveBalanceIncrementsWithLen,

package/src/lightClient/spec/index.ts

@@ -32,11 +32,13 @@ export {
   type SyncCommitteeFast,
 } from "./store.js";
 export {
+  getLightClientExecutionRoot,
   getSafetyThreshold,
   isFinalityUpdate,
   isSyncCommitteeUpdate,
   isValidLightClientHeader,
   normalizeMerkleBranch,
+  upgradeLightClientBootstrap,
   upgradeLightClientFinalityUpdate,
   upgradeLightClientHeader,
   upgradeLightClientOptimisticUpdate,

package/src/lightClient/spec/utils.ts

@@ -23,18 +23,18 @@ import {
 } from "@lodestar/params";
 import {
   BeaconBlockHeader,
+  LightClientBootstrap,
   LightClientFinalityUpdate,
   LightClientHeader,
   LightClientOptimisticUpdate,
   LightClientUpdate,
-  Slot,
   SyncCommittee,
   isElectraLightClientUpdate,
   ssz,
 } from "@lodestar/types";
-import {byteArrayEquals, verifyMerkleBranch} from "@lodestar/utils";
-import {computeEpochAtSlot, computeSyncPeriodAtSlot} from "../../util/epoch.js";
-import type {LightClientStore, SyncCommitteeFast} from "./store.js";
+import {byteArrayEquals, hash, verifyMerkleBranch} from "@lodestar/utils";
+import {computeEpochAtSlot} from "../../util/epoch.js";
+import type {ILightClientStore, SyncCommitteeFast} from "./store.js";
 
 export const GENESIS_SLOT = 0;
 export const ZERO_HASH = new Uint8Array(32);
@@ -201,6 +201,76 @@ function getGindexIndex(gindex: number): number {
   return gindex - 2 ** getGindexDepth(gindex);
 }
 
+/**
+ * Returns the execution root represented by a light-client header.
+ *
+ * Gloas headers removed `execution` so Pre-Gloas headers upgraded to the Gloas format
+ * require reconstruction of the original execution payload header root.
+ *
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.14/specs/gloas/light-client/sync-protocol.md#modified-get_lc_execution_root
+ */
+export function getLightClientExecutionRoot(config: ChainForkConfig, header: LightClientHeader): Uint8Array {
+  const epoch = computeEpochAtSlot(header.beacon.slot);
+
+  if (!isGloasLightClientHeader(header)) {
+    if (epoch < config.CAPELLA_FORK_EPOCH) {
+      return ZERO_HASH;
+    }
+
+    return config
+      .getPostBellatrixForkTypes(header.beacon.slot)
+      .ExecutionPayloadHeader.hashTreeRoot((header as LightClientHeader<ForkName.capella>).execution);
+  }
+
+  if (epoch >= config.GLOAS_FORK_EPOCH) {
+    return header.executionBlockHash;
+  }
+
+  // Reconstruct the pre-Gloas execution payload root for a header upgraded to the Gloas format
+  // because the structure is different, `execution` is removed
+  const executionPayloadDepth = getGindexDepth(BLOCK_BODY_EXECUTION_PAYLOAD_GINDEX);
+  const innerBranch = header.executionBranch.slice(0, -executionPayloadDepth);
+
+  if (epoch >= config.DENEB_FORK_EPOCH) {
+    if (header.beacon.slot === GENESIS_SLOT) {
+      return ssz.deneb.ExecutionPayloadHeader.hashTreeRoot(ssz.deneb.ExecutionPayloadHeader.defaultValue());
+    }
+    return computeBranchRoot(
+      header.executionBlockHash,
+      innerBranch,
+      ssz.deneb.ExecutionPayloadHeader.getPathInfo(["blockHash"]).gindex
+    );
+  }
+
+  if (epoch >= config.CAPELLA_FORK_EPOCH) {
+    if (header.beacon.slot === GENESIS_SLOT) {
+      return ssz.capella.ExecutionPayloadHeader.hashTreeRoot(ssz.capella.ExecutionPayloadHeader.defaultValue());
+    }
+    return computeBranchRoot(
+      header.executionBlockHash,
+      innerBranch,
+      ssz.capella.ExecutionPayloadHeader.getPathInfo(["blockHash"]).gindex
+    );
+  }
+
+  return ZERO_HASH;
+}
+
+export function upgradeLightClientBootstrap(
+  config: ChainForkConfig,
+  targetFork: ForkName,
+  bootstrap: LightClientBootstrap
+): LightClientBootstrap {
+  return {
+    ...bootstrap,
+    header: upgradeLightClientHeader(config, targetFork, bootstrap.header),
+    currentSyncCommitteeBranch: normalizeMerkleBranch(
+      bootstrap.currentSyncCommitteeBranch,
+      currentSyncCommitteeGindexAtFork(targetFork)
+    ),
+  };
+}
+
 export function upgradeLightClientHeader(
   config: ChainForkConfig,
   targetFork: ForkName,
@@ -211,9 +281,7 @@ export function upgradeLightClientHeader(
     throw Error(`Invalid upgrade request from headerFork=${headerFork} to targetFork=${targetFork}`);
   }
 
-  // We are modifying the same header object, may be we could create a copy, but its
-  // not required as of now
-  let upgradedHeader = header;
+  let upgradedHeader = {...header} as LightClientHeader;
   const startUpgradeFromFork = Object.values(ForkName)[ForkSeq[headerFork] + 1];
 
   switch (startUpgradeFromFork) {
@@ -231,23 +299,30 @@ export function upgradeLightClientHeader(
 
     // biome-ignore lint/suspicious/noFallthroughSwitchClause: We need fall-through behavior here
     case ForkName.capella:
-      (upgradedHeader as LightClientHeader<ForkName.capella>).execution =
-        ssz.capella.LightClientHeader.fields.execution.defaultValue();
-      (upgradedHeader as LightClientHeader<ForkName.capella>).executionBranch =
-        ssz.capella.LightClientHeader.fields.executionBranch.defaultValue();
+      upgradedHeader = {
+        ...upgradedHeader,
+        execution: ssz.capella.LightClientHeader.fields.execution.defaultValue(),
+        executionBranch: ssz.capella.LightClientHeader.fields.executionBranch.defaultValue(),
+      } as LightClientHeader<ForkName.capella>;
 
       // Break if no further upgradation is required else fall through
       if (ForkSeq[targetFork] <= ForkSeq.capella) break;
 
     // biome-ignore lint/suspicious/noFallthroughSwitchClause: We need fall-through behavior here
-    case ForkName.deneb:
-      (upgradedHeader as LightClientHeader<ForkName.deneb>).execution.blobGasUsed =
-        ssz.deneb.LightClientHeader.fields.execution.fields.blobGasUsed.defaultValue();
-      (upgradedHeader as LightClientHeader<ForkName.deneb>).execution.excessBlobGas =
-        ssz.deneb.LightClientHeader.fields.execution.fields.excessBlobGas.defaultValue();
+    case ForkName.deneb: {
+      const capellaHeader = upgradedHeader as LightClientHeader<ForkName.capella>;
+      upgradedHeader = {
+        ...capellaHeader,
+        execution: {
+          ...capellaHeader.execution,
+          blobGasUsed: ssz.deneb.LightClientHeader.fields.execution.fields.blobGasUsed.defaultValue(),
+          excessBlobGas: ssz.deneb.LightClientHeader.fields.execution.fields.excessBlobGas.defaultValue(),
+        },
+      } as LightClientHeader<ForkName.deneb>;
 
       // Break if no further upgradation is required else fall through
       if (ForkSeq[targetFork] <= ForkSeq.deneb) break;
+    }
 
     // biome-ignore lint/suspicious/noFallthroughSwitchClause: We need fall-through behavior here
     case ForkName.electra:
@@ -361,15 +436,16 @@ export function upgradeLightClientUpdate(
   targetFork: ForkName,
   update: LightClientUpdate
 ): LightClientUpdate {
-  update.attestedHeader = upgradeLightClientHeader(config, targetFork, update.attestedHeader);
-  update.finalizedHeader = upgradeLightClientHeader(config, targetFork, update.finalizedHeader);
-  update.nextSyncCommitteeBranch = normalizeMerkleBranch(
-    update.nextSyncCommitteeBranch,
-    nextSyncCommitteeGindexAtFork(targetFork)
-  );
-  update.finalityBranch = normalizeMerkleBranch(update.finalityBranch, finalizedRootGindexAtFork(targetFork));
-
-  return update;
+  return {
+    ...update,
+    attestedHeader: upgradeLightClientHeader(config, targetFork, update.attestedHeader),
+    finalizedHeader: upgradeLightClientHeader(config, targetFork, update.finalizedHeader),
+    nextSyncCommitteeBranch: normalizeMerkleBranch(
+      update.nextSyncCommitteeBranch,
+      nextSyncCommitteeGindexAtFork(targetFork)
+    ),
+    finalityBranch: normalizeMerkleBranch(update.finalityBranch, finalizedRootGindexAtFork(targetFork)),
+  };
 }
 
 export function upgradeLightClientFinalityUpdate(
@@ -377,14 +453,12 @@ export function upgradeLightClientFinalityUpdate(
   targetFork: ForkName,
   finalityUpdate: LightClientFinalityUpdate
 ): LightClientFinalityUpdate {
-  finalityUpdate.attestedHeader = upgradeLightClientHeader(config, targetFork, finalityUpdate.attestedHeader);
-  finalityUpdate.finalizedHeader = upgradeLightClientHeader(config, targetFork, finalityUpdate.finalizedHeader);
-  finalityUpdate.finalityBranch = normalizeMerkleBranch(
-    finalityUpdate.finalityBranch,
-    finalizedRootGindexAtFork(targetFork)
-  );
-
-  return finalityUpdate;
+  return {
+    ...finalityUpdate,
+    attestedHeader: upgradeLightClientHeader(config, targetFork, finalityUpdate.attestedHeader),
+    finalizedHeader: upgradeLightClientHeader(config, targetFork, finalityUpdate.finalizedHeader),
+    finalityBranch: normalizeMerkleBranch(finalityUpdate.finalityBranch, finalizedRootGindexAtFork(targetFork)),
+  };
 }
 
 export function upgradeLightClientOptimisticUpdate(
@@ -392,9 +466,10 @@ export function upgradeLightClientOptimisticUpdate(
   targetFork: ForkName,
   optimisticUpdate: LightClientOptimisticUpdate
 ): LightClientOptimisticUpdate {
-  optimisticUpdate.attestedHeader = upgradeLightClientHeader(config, targetFork, optimisticUpdate.attestedHeader);
-
-  return optimisticUpdate;
+  return {
+    ...optimisticUpdate,
+    attestedHeader: upgradeLightClientHeader(config, targetFork, optimisticUpdate.attestedHeader),
+  };
 }
 
 /**
@@ -405,25 +480,44 @@ export function upgradeLightClientOptimisticUpdate(
 export function upgradeLightClientStore(
   config: ChainForkConfig,
   targetFork: ForkName,
-  store: LightClientStore,
-  signatureSlot: Slot
-): LightClientStore {
-  const updateSignaturePeriod = computeSyncPeriodAtSlot(signatureSlot);
-  const bestValidUpdate = store.bestValidUpdates.get(updateSignaturePeriod);
-
-  if (bestValidUpdate) {
-    store.bestValidUpdates.set(updateSignaturePeriod, {
-      update: upgradeLightClientUpdate(config, targetFork, bestValidUpdate.update),
-      summary: bestValidUpdate.summary,
+  store: ILightClientStore
+): ILightClientStore {
+  const bestValidUpdates = new Map();
+
+  for (const [period, entry] of store.bestValidUpdates) {
+    bestValidUpdates.set(period, {
+      ...entry,
+      update: upgradeLightClientUpdate(config, targetFork, entry.update),
     });
   }
+  const finalizedHeader = upgradeLightClientHeader(config, targetFork, store.finalizedHeader);
+  const optimisticHeader = upgradeLightClientHeader(config, targetFork, store.optimisticHeader);
 
-  store.finalizedHeader = upgradeLightClientHeader(config, targetFork, store.finalizedHeader);
-  store.optimisticHeader = upgradeLightClientHeader(config, targetFork, store.optimisticHeader);
+  for (const [period, bestValidUpdate] of bestValidUpdates) {
+    store.bestValidUpdates.set(period, bestValidUpdate);
+  }
+  store.finalizedHeader = finalizedHeader;
+  store.optimisticHeader = optimisticHeader;
 
   return store;
 }
 
+function computeBranchRoot(leaf: Uint8Array, branch: Uint8Array[], gindex: bigint): Uint8Array {
+  const depth = getGindexDepth(Number(gindex));
+  if (branch.length < depth) {
+    throw Error(`Invalid Merkle branch length ${branch.length}, expected at least ${depth}`);
+  }
+  const proof = branch.slice(-depth);
+  const index = getGindexIndex(Number(gindex));
+  let root = leaf;
+
+  for (let i = 0; i < depth; i++) {
+    root = Math.floor(index / 2 ** i) % 2 === 1 ? hash(proof[i], root) : hash(root, proof[i]);
+  }
+
+  return root;
+}
+
 function isGloasLightClientHeader(header: LightClientHeader): header is LightClientHeader<ForkName.gloas> {
   return (header as LightClientHeader<ForkName.gloas>).executionBlockHash !== undefined;
 }