@lodestar/state-transition 1.45.0-dev.0cff4e6916 → 1.45.0-dev.17a48050e6

package/src/block/processOperations.ts

@@ -1,4 +1,12 @@
-import {ForkSeq} from "@lodestar/params";
+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 {BeaconBlockBody, capella, electra, gloas} from "@lodestar/types";
 import {BeaconStateTransitionMetrics} from "../metrics.js";
 import {
@@ -39,6 +47,10 @@ 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);
@@ -94,3 +106,18 @@ export function processOperations(
     }
   }
 }
+
+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}`);
+  }
+}

package/src/block/processParentExecutionPayload.ts

@@ -1,4 +1,12 @@
-import {ForkPostGloas, SLOTS_PER_EPOCH, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
+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 {BeaconBlock, gloas, ssz} from "@lodestar/types";
 import {byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {CachedBeaconStateGloas} from "../types.js";
@@ -47,6 +55,8 @@ 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;
@@ -116,6 +126,21 @@ 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/processWithdrawals.ts

@@ -99,7 +99,7 @@ export function processWithdrawals(
     const stateGloas = state as CachedBeaconStateGloas;
 
     // Store expected withdrawals for verification
-    stateGloas.payloadExpectedWithdrawals = ssz.capella.Withdrawals.toViewDU(expectedWithdrawals);
+    stateGloas.payloadExpectedWithdrawals = ssz.gloas.Withdrawals.toViewDU(expectedWithdrawals);
 
     // Update builder pending withdrawals queue
     stateGloas.builderPendingWithdrawals = stateGloas.builderPendingWithdrawals.sliceFrom(

package/src/cache/stateCache.ts

@@ -254,11 +254,9 @@ export function isCachedBeaconState<T extends BeaconStateAllForks>(
 // 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.
 export function isStateValidatorsNodesPopulated(state: CachedBeaconStateAllForks): boolean {
-  // biome-ignore lint/complexity/useLiteralKeys: It is a private attribute
-  return state.validators["nodesPopulated"] === true;
+  return (state.validators as unknown as {nodesPopulated?: boolean}).nodesPopulated === true;
 }
 
 export function isStateBalancesNodesPopulated(state: CachedBeaconStateAllForks): boolean {
-  // biome-ignore lint/complexity/useLiteralKeys: It is a private attribute
-  return state.balances["nodesPopulated"] === true;
+  return (state.balances as unknown as {nodesPopulated?: boolean}).nodesPopulated === true;
 }

package/src/epoch/processParticipationFlagUpdates.ts

@@ -1,6 +1,8 @@
 import {zeroNode} from "@chainsafe/persistent-merkle-tree";
 import {ssz} from "@lodestar/types";
-import {CachedBeaconStateAltair} from "../types.js";
+import type {BeaconStateAltair, BeaconStateGloas} from "../types.js";
+import {isGloasStateType} from "../util/execution.js";
+import {zeroProgressiveListBasicRootNode} from "../util/ssz.js";
 
 /**
  * Updates `state.previousEpochParticipation` with precalculated epoch participation. Creates a new empty tree for
@@ -9,7 +11,12 @@ import {CachedBeaconStateAltair} from "../types.js";
  * PERF: Cost = 'proportional' $VALIDATOR_COUNT. Since it updates all of them at once, it will always recreate both
  * trees completely.
  */
-export function processParticipationFlagUpdates(state: CachedBeaconStateAltair): void {
+export function processParticipationFlagUpdates(state: BeaconStateAltair | BeaconStateGloas): void {
+  if (isGloasStateType(state)) {
+    processParticipationFlagUpdatesGloas(state);
+    return;
+  }
+
   // Set view and tree from currentEpochParticipation to previousEpochParticipation
   state.previousEpochParticipation = state.currentEpochParticipation;
 
@@ -25,3 +32,14 @@ export function processParticipationFlagUpdates(state: CachedBeaconStateAltair):
 
   state.currentEpochParticipation = ssz.altair.EpochParticipation.getViewDU(currentEpochParticipationNode);
 }
+
+function processParticipationFlagUpdatesGloas(state: BeaconStateGloas): void {
+  state.previousEpochParticipation = state.currentEpochParticipation;
+
+  // Same trick as the altair path above, adapted to the progressive-list tree shape: all chunks
+  // are zero so the chunks tree is a chain of pre-computed zeroNodes, built in O(log n) instead
+  // of re-merkleizing a validator-count-sized array every epoch.
+  state.currentEpochParticipation = ssz.gloas.EpochParticipation.getViewDU(
+    zeroProgressiveListBasicRootNode(ssz.gloas.EpochParticipation.itemsPerChunk, state.currentEpochParticipation.length)
+  );
+}

package/src/epoch/processRewardsAndPenalties.ts

@@ -1,5 +1,4 @@
 import {ForkSeq, GENESIS_EPOCH} from "@lodestar/params";
-import {ssz} from "@lodestar/types";
 import {
   CachedBeaconStateAllForks,
   CachedBeaconStateAltair,
@@ -39,7 +38,7 @@ export function processRewardsAndPenalties(
 
   // important: do not change state one balance at a time. Set them all at once, constructing the tree in one go
   // cache the balances array, too
-  state.balances = ssz.phase0.Balances.toViewDU(balances);
+  state.balances = state.type.fields.balances.toViewDU(balances);
 
   // For processEffectiveBalanceUpdates() to prevent having to re-compute the balances array.
   // For validator metrics

package/src/lightClient/proofs.ts

@@ -1,11 +1,15 @@
 import {Tree} from "@chainsafe/persistent-merkle-tree";
 import {
   BLOCK_BODY_EXECUTION_PAYLOAD_GINDEX,
+  CURRENT_SYNC_COMMITTEE_GINDEX_GLOAS,
   FINALIZED_ROOT_GINDEX,
   FINALIZED_ROOT_GINDEX_ELECTRA,
+  FINALIZED_ROOT_GINDEX_GLOAS,
   ForkName,
   ForkPostBellatrix,
+  NEXT_SYNC_COMMITTEE_GINDEX_GLOAS,
   isForkPostElectra,
+  isForkPostGloas,
 } from "@lodestar/params";
 import {BeaconBlockBody, SSZTypesFor, ssz} from "@lodestar/types";
 import {BeaconStateAllForks, CachedBeaconStateAllForks} from "../types.js";
@@ -17,6 +21,24 @@ export function getSyncCommitteesWitness(fork: ForkName, state: BeaconStateAllFo
   let currentSyncCommitteeRoot: Uint8Array;
   let nextSyncCommitteeRoot: Uint8Array;
 
+  if (isForkPostGloas(fork)) {
+    const tree = new Tree(state.node);
+    const currentSyncCommitteeGindex = BigInt(CURRENT_SYNC_COMMITTEE_GINDEX_GLOAS);
+    const nextSyncCommitteeGindex = BigInt(NEXT_SYNC_COMMITTEE_GINDEX_GLOAS);
+
+    currentSyncCommitteeRoot = tree.getRoot(currentSyncCommitteeGindex);
+    nextSyncCommitteeRoot = tree.getRoot(nextSyncCommitteeGindex);
+    witness = [];
+
+    return {
+      witness,
+      currentSyncCommitteeRoot,
+      nextSyncCommitteeRoot,
+      currentSyncCommitteeBranch: tree.getSingleProof(currentSyncCommitteeGindex),
+      nextSyncCommitteeBranch: tree.getSingleProof(nextSyncCommitteeGindex),
+    };
+  }
+
   if (isForkPostElectra(fork)) {
     const n2 = n1.left;
     const n5 = n2.right;
@@ -60,17 +82,30 @@ export function getSyncCommitteesWitness(fork: ForkName, state: BeaconStateAllFo
 }
 
 export function getNextSyncCommitteeBranch(syncCommitteesWitness: SyncCommitteeWitness): Uint8Array[] {
+  if (syncCommitteesWitness.nextSyncCommitteeBranch) {
+    return syncCommitteesWitness.nextSyncCommitteeBranch;
+  }
+
   // Witness branch is sorted by descending gindex
   return [syncCommitteesWitness.currentSyncCommitteeRoot, ...syncCommitteesWitness.witness];
 }
 
 export function getCurrentSyncCommitteeBranch(syncCommitteesWitness: SyncCommitteeWitness): Uint8Array[] {
+  if (syncCommitteesWitness.currentSyncCommitteeBranch) {
+    return syncCommitteesWitness.currentSyncCommitteeBranch;
+  }
+
   // Witness branch is sorted by descending gindex
   return [syncCommitteesWitness.nextSyncCommitteeRoot, ...syncCommitteesWitness.witness];
 }
 
 export function getFinalizedRootProof(state: CachedBeaconStateAllForks): Uint8Array[] {
-  const finalizedRootGindex = state.epochCtx.isPostElectra() ? FINALIZED_ROOT_GINDEX_ELECTRA : FINALIZED_ROOT_GINDEX;
+  const fork = state.config.getForkName(state.slot);
+  const finalizedRootGindex = isForkPostGloas(fork)
+    ? FINALIZED_ROOT_GINDEX_GLOAS
+    : state.epochCtx.isPostElectra()
+      ? FINALIZED_ROOT_GINDEX_ELECTRA
+      : FINALIZED_ROOT_GINDEX;
   return new Tree(state.node).getSingleProof(BigInt(finalizedRootGindex));
 }
 

package/src/lightClient/spec/index.ts

@@ -14,7 +14,7 @@ import {
   processLightClientUpdate,
 } from "./processLightClientUpdate.js";
 import {type ILightClientStore, LightClientStore, type LightClientStoreEvents} from "./store.js";
-import {ZERO_HEADER, ZERO_SYNC_COMMITTEE, getZeroFinalityBranch, getZeroSyncCommitteeBranch} from "./utils.js";
+import {ZERO_SYNC_COMMITTEE, getZeroFinalityBranch, getZeroSyncCommitteeBranch} from "./utils.js";
 
 export type {LightClientUpdateSummary} from "./isBetterUpdate.js";
 export {isBetterUpdate, toLightClientUpdateSummary} from "./isBetterUpdate.js";
@@ -76,12 +76,16 @@ export class LightclientSpec {
   }
 
   onOptimisticUpdate(currentSlot: Slot, optimisticUpdate: LightClientOptimisticUpdate): void {
+    const fork = this.config.getForkName(optimisticUpdate.signatureSlot);
+
     this.onUpdate(currentSlot, {
       attestedHeader: optimisticUpdate.attestedHeader,
       nextSyncCommittee: ZERO_SYNC_COMMITTEE,
-      nextSyncCommitteeBranch: getZeroSyncCommitteeBranch(this.config.getForkName(optimisticUpdate.signatureSlot)),
-      finalizedHeader: {beacon: ZERO_HEADER},
-      finalityBranch: getZeroFinalityBranch(this.config.getForkName(optimisticUpdate.signatureSlot)),
+      nextSyncCommitteeBranch: getZeroSyncCommitteeBranch(fork),
+      finalizedHeader: this.config
+        .getPostAltairForkTypes(optimisticUpdate.signatureSlot)
+        .LightClientHeader.defaultValue(),
+      finalityBranch: getZeroFinalityBranch(fork),
       syncAggregate: optimisticUpdate.syncAggregate,
       signatureSlot: optimisticUpdate.signatureSlot,
     });

package/src/lightClient/spec/utils.ts

@@ -1,16 +1,25 @@
 import {PublicKey} from "@chainsafe/blst";
+import {Tree} from "@chainsafe/persistent-merkle-tree";
 import {BitArray} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
 import {
-  BLOCK_BODY_EXECUTION_PAYLOAD_DEPTH as EXECUTION_PAYLOAD_DEPTH,
-  BLOCK_BODY_EXECUTION_PAYLOAD_INDEX as EXECUTION_PAYLOAD_INDEX,
-  FINALIZED_ROOT_DEPTH,
-  FINALIZED_ROOT_DEPTH_ELECTRA,
+  BLOCK_BODY_EXECUTION_PAYLOAD_GINDEX,
+  CURRENT_SYNC_COMMITTEE_GINDEX,
+  CURRENT_SYNC_COMMITTEE_GINDEX_ELECTRA,
+  CURRENT_SYNC_COMMITTEE_GINDEX_GLOAS,
+  EXECUTION_BLOCK_HASH_GINDEX,
+  EXECUTION_BLOCK_HASH_GINDEX_DENEB,
+  EXECUTION_BLOCK_HASH_GINDEX_GLOAS,
+  FINALIZED_ROOT_GINDEX,
+  FINALIZED_ROOT_GINDEX_ELECTRA,
+  FINALIZED_ROOT_GINDEX_GLOAS,
   ForkName,
   ForkSeq,
-  NEXT_SYNC_COMMITTEE_DEPTH,
-  NEXT_SYNC_COMMITTEE_DEPTH_ELECTRA,
+  NEXT_SYNC_COMMITTEE_GINDEX,
+  NEXT_SYNC_COMMITTEE_GINDEX_ELECTRA,
+  NEXT_SYNC_COMMITTEE_GINDEX_GLOAS,
   isForkPostElectra,
+  isForkPostGloas,
 } from "@lodestar/params";
 import {
   BeaconBlockHeader,
@@ -74,17 +83,11 @@ export function getSafetyThreshold(maxActiveParticipants: number): number {
 }
 
 export function getZeroSyncCommitteeBranch(fork: ForkName): Uint8Array[] {
-  const nextSyncCommitteeDepth = isForkPostElectra(fork)
-    ? NEXT_SYNC_COMMITTEE_DEPTH_ELECTRA
-    : NEXT_SYNC_COMMITTEE_DEPTH;
-
-  return Array.from({length: nextSyncCommitteeDepth}, () => ZERO_HASH);
+  return Array.from({length: getGindexDepth(nextSyncCommitteeGindexAtFork(fork))}, () => ZERO_HASH);
 }
 
 export function getZeroFinalityBranch(fork: ForkName): Uint8Array[] {
-  const finalizedRootDepth = isForkPostElectra(fork) ? FINALIZED_ROOT_DEPTH_ELECTRA : FINALIZED_ROOT_DEPTH;
-
-  return Array.from({length: finalizedRootDepth}, () => ZERO_HASH);
+  return Array.from({length: getGindexDepth(finalizedRootGindexAtFork(fork))}, () => ZERO_HASH);
 }
 
 export function isSyncCommitteeUpdate(update: LightClientUpdate): boolean {
@@ -129,12 +132,73 @@ export function isValidMerkleBranch(
   return verifyMerkleBranch(leaf, branch, depth, index, root);
 }
 
-export function normalizeMerkleBranch(branch: Uint8Array[], depth: number): Uint8Array[] {
+export function isValidNormalizedMerkleBranch(
+  leaf: Uint8Array,
+  branch: Uint8Array[],
+  gindex: number,
+  root: Uint8Array
+): boolean {
+  const depth = getGindexDepth(gindex);
+  const index = getGindexIndex(gindex);
+  const numExtraDepth = branch.length - depth;
+  if (numExtraDepth < 0) {
+    return false;
+  }
+
+  for (let i = 0; i < numExtraDepth; i++) {
+    if (!byteArrayEquals(branch[i], ZERO_HASH)) {
+      return false;
+    }
+  }
+
+  return isValidMerkleBranch(leaf, branch.slice(numExtraDepth), depth, index, root);
+}
+
+export function normalizeMerkleBranch(branch: Uint8Array[], gindex: number): Uint8Array[] {
+  const depth = getGindexDepth(gindex);
   const numExtraDepth = depth - branch.length;
 
   return [...Array.from({length: numExtraDepth}, () => ZERO_HASH), ...branch];
 }
 
+export function currentSyncCommitteeGindexAtFork(fork: ForkName): number {
+  if (isForkPostGloas(fork)) {
+    return CURRENT_SYNC_COMMITTEE_GINDEX_GLOAS;
+  }
+  if (isForkPostElectra(fork)) {
+    return CURRENT_SYNC_COMMITTEE_GINDEX_ELECTRA;
+  }
+  return CURRENT_SYNC_COMMITTEE_GINDEX;
+}
+
+export function finalizedRootGindexAtFork(fork: ForkName): number {
+  if (isForkPostGloas(fork)) {
+    return FINALIZED_ROOT_GINDEX_GLOAS;
+  }
+  if (isForkPostElectra(fork)) {
+    return FINALIZED_ROOT_GINDEX_ELECTRA;
+  }
+  return FINALIZED_ROOT_GINDEX;
+}
+
+export function nextSyncCommitteeGindexAtFork(fork: ForkName): number {
+  if (isForkPostGloas(fork)) {
+    return NEXT_SYNC_COMMITTEE_GINDEX_GLOAS;
+  }
+  if (isForkPostElectra(fork)) {
+    return NEXT_SYNC_COMMITTEE_GINDEX_ELECTRA;
+  }
+  return NEXT_SYNC_COMMITTEE_GINDEX;
+}
+
+export function getGindexDepth(gindex: number): number {
+  return Math.floor(Math.log2(gindex));
+}
+
+export function getGindexIndex(gindex: number): number {
+  return gindex - 2 ** getGindexDepth(gindex);
+}
+
 export function upgradeLightClientHeader(
   config: ChainForkConfig,
   targetFork: ForkName,
@@ -147,7 +211,7 @@ export function upgradeLightClientHeader(
 
   // We are modifying the same header object, may be we could create a copy, but its
   // not required as of now
-  const upgradedHeader = header;
+  let upgradedHeader = header;
   const startUpgradeFromFork = Object.values(ForkName)[ForkSeq[headerFork] + 1];
 
   switch (startUpgradeFromFork) {
@@ -198,7 +262,11 @@ export function upgradeLightClientHeader(
       if (ForkSeq[targetFork] <= ForkSeq.fulu) break;
 
     case ForkName.gloas:
-      // No changes to LightClientHeader in Gloas
+      if (isGloasLightClientHeader(upgradedHeader)) {
+        break;
+      }
+
+      upgradedHeader = upgradeLightClientHeaderToGloas(config, upgradedHeader as LightClientHeader<ForkName.electra>);
 
       // Break if no further upgrades is required else fall through
       if (ForkSeq[targetFork] <= ForkSeq.gloas) break;
@@ -209,6 +277,40 @@ export function upgradeLightClientHeader(
 export function isValidLightClientHeader(config: ChainForkConfig, header: LightClientHeader): boolean {
   const epoch = computeEpochAtSlot(header.beacon.slot);
 
+  if (isGloasLightClientHeader(header)) {
+    if (epoch >= config.GLOAS_FORK_EPOCH) {
+      return isValidNormalizedMerkleBranch(
+        header.executionBlockHash,
+        header.executionBranch,
+        EXECUTION_BLOCK_HASH_GINDEX_GLOAS,
+        header.beacon.bodyRoot
+      );
+    }
+
+    if (epoch >= config.DENEB_FORK_EPOCH) {
+      return isValidNormalizedMerkleBranch(
+        header.executionBlockHash,
+        header.executionBranch,
+        EXECUTION_BLOCK_HASH_GINDEX_DENEB,
+        header.beacon.bodyRoot
+      );
+    }
+
+    if (epoch >= config.CAPELLA_FORK_EPOCH) {
+      return isValidNormalizedMerkleBranch(
+        header.executionBlockHash,
+        header.executionBranch,
+        EXECUTION_BLOCK_HASH_GINDEX,
+        header.beacon.bodyRoot
+      );
+    }
+
+    return (
+      byteArrayEquals(header.executionBlockHash, ZERO_HASH) &&
+      header.executionBranch.every((node) => byteArrayEquals(node, ZERO_HASH))
+    );
+  }
+
   if (epoch < config.CAPELLA_FORK_EPOCH) {
     return (
       ((header as LightClientHeader<ForkName.capella>).execution === undefined ||
@@ -239,8 +341,8 @@ export function isValidLightClientHeader(config: ChainForkConfig, header: LightC
       .getPostBellatrixForkTypes(header.beacon.slot)
       .ExecutionPayloadHeader.hashTreeRoot((header as LightClientHeader<ForkName.capella>).execution),
     (header as LightClientHeader<ForkName.capella>).executionBranch,
-    EXECUTION_PAYLOAD_DEPTH,
-    EXECUTION_PAYLOAD_INDEX,
+    getGindexDepth(BLOCK_BODY_EXECUTION_PAYLOAD_GINDEX),
+    getGindexIndex(BLOCK_BODY_EXECUTION_PAYLOAD_GINDEX),
     header.beacon.bodyRoot
   );
 }
@@ -254,12 +356,9 @@ export function upgradeLightClientUpdate(
   update.finalizedHeader = upgradeLightClientHeader(config, targetFork, update.finalizedHeader);
   update.nextSyncCommitteeBranch = normalizeMerkleBranch(
     update.nextSyncCommitteeBranch,
-    isForkPostElectra(targetFork) ? NEXT_SYNC_COMMITTEE_DEPTH_ELECTRA : NEXT_SYNC_COMMITTEE_DEPTH
-  );
-  update.finalityBranch = normalizeMerkleBranch(
-    update.finalityBranch,
-    isForkPostElectra(targetFork) ? FINALIZED_ROOT_DEPTH_ELECTRA : FINALIZED_ROOT_DEPTH
+    nextSyncCommitteeGindexAtFork(targetFork)
   );
+  update.finalityBranch = normalizeMerkleBranch(update.finalityBranch, finalizedRootGindexAtFork(targetFork));
 
   return update;
 }
@@ -273,7 +372,7 @@ export function upgradeLightClientFinalityUpdate(
   finalityUpdate.finalizedHeader = upgradeLightClientHeader(config, targetFork, finalityUpdate.finalizedHeader);
   finalityUpdate.finalityBranch = normalizeMerkleBranch(
     finalityUpdate.finalityBranch,
-    isForkPostElectra(targetFork) ? FINALIZED_ROOT_DEPTH_ELECTRA : FINALIZED_ROOT_DEPTH
+    finalizedRootGindexAtFork(targetFork)
   );
 
   return finalityUpdate;
@@ -315,3 +414,72 @@ export function upgradeLightClientStore(
 
   return store;
 }
+
+function isGloasLightClientHeader(header: LightClientHeader): header is LightClientHeader<ForkName.gloas> {
+  return (header as LightClientHeader<ForkName.gloas>).executionBlockHash !== undefined;
+}
+
+function upgradeLightClientHeaderToGloas(
+  config: ChainForkConfig,
+  pre: LightClientHeader<ForkName.electra>
+): LightClientHeader<ForkName.gloas> {
+  if (ssz.electra.LightClientHeader.equals(pre, ssz.electra.LightClientHeader.defaultValue())) {
+    return ssz.gloas.LightClientHeader.defaultValue();
+  }
+
+  const epoch = computeEpochAtSlot(pre.beacon.slot);
+
+  if (epoch >= config.DENEB_FORK_EPOCH) {
+    const blockHashGindex = ssz.deneb.ExecutionPayloadHeader.getPathInfo(["blockHash"]).gindex;
+    const executionBranch = new Tree(ssz.deneb.ExecutionPayloadHeader.toView(pre.execution).node).getSingleProof(
+      blockHashGindex
+    );
+
+    return {
+      beacon: pre.beacon,
+      executionBlockHash: pre.execution.blockHash,
+      executionBranch: normalizeMerkleBranch(
+        [...executionBranch, ...pre.executionBranch],
+        EXECUTION_BLOCK_HASH_GINDEX_GLOAS
+      ),
+    };
+  }
+
+  if (epoch >= config.CAPELLA_FORK_EPOCH) {
+    const executionHeader = {
+      parentHash: pre.execution.parentHash,
+      feeRecipient: pre.execution.feeRecipient,
+      stateRoot: pre.execution.stateRoot,
+      receiptsRoot: pre.execution.receiptsRoot,
+      logsBloom: pre.execution.logsBloom,
+      prevRandao: pre.execution.prevRandao,
+      blockNumber: pre.execution.blockNumber,
+      gasLimit: pre.execution.gasLimit,
+      gasUsed: pre.execution.gasUsed,
+      timestamp: pre.execution.timestamp,
+      extraData: pre.execution.extraData,
+      baseFeePerGas: pre.execution.baseFeePerGas,
+      blockHash: pre.execution.blockHash,
+      transactionsRoot: pre.execution.transactionsRoot,
+      withdrawalsRoot: pre.execution.withdrawalsRoot,
+    };
+    const blockHashGindex = ssz.capella.ExecutionPayloadHeader.getPathInfo(["blockHash"]).gindex;
+    const executionBranch = new Tree(ssz.capella.ExecutionPayloadHeader.toView(executionHeader).node).getSingleProof(
+      blockHashGindex
+    );
+
+    return {
+      beacon: pre.beacon,
+      executionBlockHash: executionHeader.blockHash,
+      executionBranch: normalizeMerkleBranch(
+        [...executionBranch, ...pre.executionBranch],
+        EXECUTION_BLOCK_HASH_GINDEX_GLOAS
+      ),
+    };
+  }
+
+  return {
+    ...ssz.gloas.LightClientHeader.defaultValue(),
+    beacon: pre.beacon,
+  };
+}

package/src/lightClient/spec/validateLightClientBootstrap.ts

@@ -1,13 +1,7 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {isForkPostElectra} from "@lodestar/params";
 import {LightClientBootstrap, Root, ssz} from "@lodestar/types";
 import {byteArrayEquals, toHex} from "@lodestar/utils";
-import {isValidLightClientHeader, isValidMerkleBranch} from "./utils.js";
-
-const CURRENT_SYNC_COMMITTEE_INDEX = 22;
-const CURRENT_SYNC_COMMITTEE_DEPTH = 5;
-const CURRENT_SYNC_COMMITTEE_INDEX_ELECTRA = 22;
-const CURRENT_SYNC_COMMITTEE_DEPTH_ELECTRA = 6;
+import {currentSyncCommitteeGindexAtFork, isValidLightClientHeader, isValidNormalizedMerkleBranch} from "./utils.js";
 
 export function validateLightClientBootstrap(
   config: ChainForkConfig,
@@ -26,11 +20,10 @@ export function validateLightClientBootstrap(
   }
 
   if (
-    !isValidMerkleBranch(
+    !isValidNormalizedMerkleBranch(
       ssz.altair.SyncCommittee.hashTreeRoot(bootstrap.currentSyncCommittee),
       bootstrap.currentSyncCommitteeBranch,
-      isForkPostElectra(fork) ? CURRENT_SYNC_COMMITTEE_DEPTH_ELECTRA : CURRENT_SYNC_COMMITTEE_DEPTH,
-      isForkPostElectra(fork) ? CURRENT_SYNC_COMMITTEE_INDEX_ELECTRA : CURRENT_SYNC_COMMITTEE_INDEX,
+      currentSyncCommitteeGindexAtFork(fork),
       bootstrap.header.beacon.stateRoot
     )
   ) {

package/src/lightClient/spec/validateLightClientUpdate.ts

@@ -1,29 +1,19 @@
 import {PublicKey, Signature, fastAggregateVerify} from "@chainsafe/blst";
 import {ChainForkConfig} from "@lodestar/config";
-import {
-  DOMAIN_SYNC_COMMITTEE,
-  FINALIZED_ROOT_DEPTH,
-  FINALIZED_ROOT_DEPTH_ELECTRA,
-  FINALIZED_ROOT_INDEX,
-  FINALIZED_ROOT_INDEX_ELECTRA,
-  GENESIS_SLOT,
-  MIN_SYNC_COMMITTEE_PARTICIPANTS,
-  NEXT_SYNC_COMMITTEE_DEPTH,
-  NEXT_SYNC_COMMITTEE_DEPTH_ELECTRA,
-  NEXT_SYNC_COMMITTEE_INDEX,
-  NEXT_SYNC_COMMITTEE_INDEX_ELECTRA,
-} from "@lodestar/params";
-import {LightClientUpdate, Root, isElectraLightClientUpdate, ssz} from "@lodestar/types";
+import {DOMAIN_SYNC_COMMITTEE, GENESIS_SLOT, MIN_SYNC_COMMITTEE_PARTICIPANTS} from "@lodestar/params";
+import {LightClientUpdate, Root, ssz} from "@lodestar/types";
 import type {ILightClientStore, SyncCommitteeFast} from "./store.js";
 import {
   ZERO_HASH,
+  finalizedRootGindexAtFork,
   getParticipantPubkeys,
   isFinalityUpdate,
   isSyncCommitteeUpdate,
   isValidLightClientHeader,
-  isValidMerkleBranch,
+  isValidNormalizedMerkleBranch,
   isZeroedHeader,
   isZeroedSyncCommittee,
+  nextSyncCommitteeGindexAtFork,
   sumBits,
 } from "./utils.js";
 
@@ -33,6 +23,8 @@ export function validateLightClientUpdate(
   update: LightClientUpdate,
   syncCommittee: SyncCommitteeFast
 ): void {
+  const attestedFork = config.getForkName(update.attestedHeader.beacon.slot);
+
   // Verify sync committee has sufficient participants
   if (sumBits(update.syncAggregate.syncCommitteeBits) < MIN_SYNC_COMMITTEE_PARTICIPANTS) {
     throw Error("Sync committee has not sufficient participants");
@@ -78,11 +70,10 @@ export function validateLightClientUpdate(
     }
 
     if (
-      !isValidMerkleBranch(
+      !isValidNormalizedMerkleBranch(
         finalizedRoot,
         update.finalityBranch,
-        isElectraLightClientUpdate(update) ? FINALIZED_ROOT_DEPTH_ELECTRA : FINALIZED_ROOT_DEPTH,
-        isElectraLightClientUpdate(update) ? FINALIZED_ROOT_INDEX_ELECTRA : FINALIZED_ROOT_INDEX,
+        finalizedRootGindexAtFork(attestedFork),
         update.attestedHeader.beacon.stateRoot
       )
     ) {
@@ -98,11 +89,10 @@ export function validateLightClientUpdate(
     }
   } else {
     if (
-      !isValidMerkleBranch(
+      !isValidNormalizedMerkleBranch(
         ssz.altair.SyncCommittee.hashTreeRoot(update.nextSyncCommittee),
         update.nextSyncCommitteeBranch,
-        isElectraLightClientUpdate(update) ? NEXT_SYNC_COMMITTEE_DEPTH_ELECTRA : NEXT_SYNC_COMMITTEE_DEPTH,
-        isElectraLightClientUpdate(update) ? NEXT_SYNC_COMMITTEE_INDEX_ELECTRA : NEXT_SYNC_COMMITTEE_INDEX,
+        nextSyncCommitteeGindexAtFork(attestedFork),
         update.attestedHeader.beacon.stateRoot
       )
     ) {

package/src/lightClient/types.ts

@@ -26,8 +26,10 @@
  * ```
  */
 export type SyncCommitteeWitness = {
-  /** Vector[Bytes32, 4] or Vector[Bytes32, 5] depending on the fork */
+  /** Shared witness for pre-Gloas forks where current and next sync committees are siblings. */
   witness: Uint8Array[];
   currentSyncCommitteeRoot: Uint8Array;
   nextSyncCommitteeRoot: Uint8Array;
+  currentSyncCommitteeBranch?: Uint8Array[];
+  nextSyncCommitteeBranch?: Uint8Array[];
 };