@lodestar/state-transition 1.45.0 → 1.46.0-dev.4191d8e353

package/lib/util/ssz.js

@@ -0,0 +1,39 @@
+import { BranchNode, LeafNode, zeroNode } from "@chainsafe/persistent-merkle-tree";
+import { progressiveSubtreeFillToContents } from "@chainsafe/ssz";
+// TODO: move these utils to @chainsafe/ssz (progressive.ts, next to progressiveSubtreeFillToContents)
+/** Root node (chunks + length mix-in) of a zero-filled ProgressiveListBasicType of `length` items */
+export function zeroProgressiveListBasicRootNode(itemsPerChunk, length) {
+    const chunkCount = Math.ceil(length / itemsPerChunk);
+    // mirrors ssz's progressiveSubtreeCount (subtree capacities 1, 4, 16, ...)
+    let numSubtrees = 0;
+    for (let remaining = chunkCount, subtreeLength = 1; remaining > 0; subtreeLength *= 4) {
+        remaining -= Math.min(remaining, subtreeLength);
+        numSubtrees++;
+    }
+    return new BranchNode(zeroProgressiveNode(numSubtrees), LeafNode.fromUint32(length));
+}
+/**
+ * Root node of a progressive list from its chunk/element nodes + length mix-in.
+ * `nodes` are packed 32-byte chunk leaves for basic lists, or element root nodes for composite lists.
+ */
+export function progressiveListRootNode(nodes, length) {
+    return new BranchNode(progressiveSubtreeFillToContents(nodes), LeafNode.fromUint32(length));
+}
+/**
+ * Return the chunks node of a zero-filled progressive merkle list spanning `numSubtrees`
+ * balanced subtrees (chunk capacities 1, 4, 16, ... = 4^i; depths 0, 2, 4, ... = 2i).
+ *
+ * Not memoized: the zero data is already fully shared via the cached zeroNode(2i) subtrees;
+ * only the O(numSubtrees) spine BranchNodes (~10 at 2M validators) are allocated per call.
+ */
+function zeroProgressiveNode(numSubtrees) {
+    // chain(k) = B(zeroNode(0), B(zeroNode(2), ... B(zeroNode(2(k-1)), zeroNode(0))))
+    let node = zeroNode(0); // terminator
+    for (let i = numSubtrees - 1; i >= 0; i--) {
+        // BranchNode(left: balanced subtree i, right: rest of chain) — chain grows to the right,
+        // same as ssz progressiveSubtreeFillToContents: `root = new BranchNode(subtreeRoots[i], root)`
+        node = new BranchNode(zeroNode(2 * i), node);
+    }
+    return node;
+}
+//# sourceMappingURL=ssz.js.map

package/lib/util/ssz.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssz.js","sourceRoot":"","sources":["../../src/util/ssz.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,QAAQ,EAAQ,QAAQ,EAAC,MAAM,mCAAmC,CAAC;AACvF,OAAO,EAAC,gCAAgC,EAAC,MAAM,gBAAgB,CAAC;AAEhE,sGAAsG;AAEtG,qGAAqG;AACrG,MAAM,UAAU,gCAAgC,CAAC,aAAqB,EAAE,MAAc,EAAQ;IAC5F,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,aAAa,CAAC,CAAC;IACrD,2EAA2E;IAC3E,IAAI,WAAW,GAAG,CAAC,CAAC;IACpB,KAAK,IAAI,SAAS,GAAG,UAAU,EAAE,aAAa,GAAG,CAAC,EAAE,SAAS,GAAG,CAAC,EAAE,aAAa,IAAI,CAAC,EAAE,CAAC;QACtF,SAAS,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;QAChD,WAAW,EAAE,CAAC;IAChB,CAAC;IACD,OAAO,IAAI,UAAU,CAAC,mBAAmB,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;AAAA,CACtF;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CAAC,KAAa,EAAE,MAAc,EAAQ;IAC3E,OAAO,IAAI,UAAU,CAAC,gCAAgC,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;AAAA,CAC7F;AAED;;;;;;GAMG;AACH,SAAS,mBAAmB,CAAC,WAAmB,EAAQ;IACtD,kFAAkF;IAClF,IAAI,IAAI,GAAS,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,aAAa;IAC3C,KAAK,IAAI,CAAC,GAAG,WAAW,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC1C,yFAAyF;QACzF,+FAA+F;QAC/F,IAAI,GAAG,IAAI,UAAU,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;IAC/C,CAAC;IACD,OAAO,IAAI,CAAC;AAAA,CACb"}

package/package.json

@@ -11,36 +11,36 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.45.0",
+  "version": "1.46.0-dev.4191d8e353",
   "type": "module",
   "exports": {
     ".": {
-      "bun": "./src/index.ts",
+      "typescript": "./src/index.ts",
       "types": "./lib/index.d.ts",
       "import": "./lib/index.js"
     },
     "./block": {
-      "bun": "./src/block/index.ts",
+      "typescript": "./src/block/index.ts",
       "types": "./lib/block/index.d.ts",
       "import": "./lib/block/index.js"
     },
     "./epoch": {
-      "bun": "./src/epoch/index.ts",
+      "typescript": "./src/epoch/index.ts",
       "types": "./lib/epoch/index.d.ts",
       "import": "./lib/epoch/index.js"
     },
     "./slot": {
-      "bun": "./src/slot/index.ts",
+      "typescript": "./src/slot/index.ts",
       "types": "./lib/slot/index.d.ts",
       "import": "./lib/slot/index.js"
     },
     "./light-client": {
-      "bun": "./src/lightClient/spec/index.ts",
+      "typescript": "./src/lightClient/spec/index.ts",
       "types": "./lib/lightClient/spec/index.d.ts",
       "import": "./lib/lightClient/spec/index.js"
     },
     "./test-utils": {
-      "bun": "./src/testUtils/index.ts",
+      "typescript": "./src/testUtils/index.ts",
       "types": "./lib/testUtils/index.d.ts",
       "import": "./lib/testUtils/index.js"
     }
@@ -61,7 +61,7 @@
     "lint:fix": "pnpm run lint --write",
     "test": "pnpm test:unit",
     "test:unit": "vitest run --project unit --project unit-minimal",
-    "check-readme": "pnpm exec ts-node ../../scripts/check_readme.ts"
+    "check-readme": "pnpm exec tsx ../../scripts/check_readme.ts"
   },
   "types": "lib/index.d.ts",
   "dependencies": {
@@ -71,14 +71,14 @@
     "@chainsafe/pubkey-index-map": "^3.0.0",
     "@chainsafe/ssz": "^1.6.2",
     "@chainsafe/swap-or-not-shuffle": "^1.2.1",
-    "@lodestar/config": "^1.45.0",
-    "@lodestar/params": "^1.45.0",
-    "@lodestar/types": "^1.45.0",
-    "@lodestar/utils": "^1.45.0",
+    "@lodestar/config": "^1.46.0-dev.4191d8e353",
+    "@lodestar/params": "^1.46.0-dev.4191d8e353",
+    "@lodestar/types": "^1.46.0-dev.4191d8e353",
+    "@lodestar/utils": "^1.46.0-dev.4191d8e353",
     "@vekexasia/bigint-buffer2": "^1.1.1"
   },
   "devDependencies": {
-    "@lodestar/api": "^1.45.0"
+    "@lodestar/api": "^1.46.0-dev.4191d8e353"
   },
   "keywords": [
     "ethereum",
@@ -86,5 +86,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "6051fa3335c3dadf3f99292a8fe345ccd69121f7"
+  "gitHead": "b89fa86b332f17a1669788af878fbd0d4a1cdbfe"
 }

package/src/block/processAttestationsAltair.ts

@@ -20,7 +20,7 @@ import {BeaconStateTransitionMetrics} from "../metrics.js";
 import {getAttestationWithIndicesSignatureSet} from "../signatureSets/indexedAttestation.js";
 import {BeaconStateView} from "../stateView/beaconStateView.js";
 import {CachedBeaconStateAltair, CachedBeaconStateGloas} from "../types.js";
-import {isAttestationSameSlot, isAttestationSameSlotRootCache} from "../util/gloas.js";
+import {isAttestationSameSlotRootCache} from "../util/gloas.js";
 import {increaseBalance, verifySignatureSet} from "../util/index.js";
 import {RootCache} from "../util/rootCache.js";
 import {checkpointToStr, isTimelyTarget, validateAttestation} from "./processAttestationPhase0.js";
@@ -76,7 +76,7 @@ export function processAttestationsAltair(
     // Count how much additional weight added to current or previous epoch's builder pending payment (in ETH increment)
     let paymentWeightToAdd = 0;
 
-    const flagsAttestation = getAttestationParticipationStatus(
+    const {flags: flagsAttestation, isSameSlotAttestation} = getAttestationParticipationStatus(
       fork,
       data,
       stateSlot - data.slot,
@@ -132,7 +132,7 @@ export function processAttestationsAltair(
         }
       }
 
-      if (fork >= ForkSeq.gloas && flagsNewSet !== 0 && isAttestationSameSlot(state as CachedBeaconStateGloas, data)) {
+      if (isSameSlotAttestation && flagsNewSet !== 0) {
         paymentWeightToAdd += effectiveBalanceIncrements[validatorIndex];
       }
     }
@@ -180,7 +180,7 @@ export function getAttestationParticipationStatus(
   currentEpoch: Epoch,
   rootCache: RootCache,
   executionPayloadAvailability: BitArray | null
-): number {
+): {flags: number; isSameSlotAttestation: boolean} {
   const justifiedCheckpoint =
     data.target.epoch === currentEpoch ? rootCache.currentJustifiedCheckpoint : rootCache.previousJustifiedCheckpoint;
 
@@ -206,10 +206,13 @@ export function getAttestationParticipationStatus(
   let isMatchingHead =
     isMatchingTarget && byteArrayEquals(data.beaconBlockRoot, rootCache.getBlockRootAtSlot(data.slot));
 
+  let isSameSlotAttestation = false;
+
   if (fork >= ForkSeq.gloas) {
     let isMatchingPayload = false;
+    isSameSlotAttestation = isAttestationSameSlotRootCache(rootCache, data);
 
-    if (isAttestationSameSlotRootCache(rootCache, data)) {
+    if (isSameSlotAttestation) {
       if (data.index !== 0) {
         throw new Error("Attesting same slot must indicate empty payload");
       }
@@ -235,7 +238,7 @@ export function getAttestationParticipationStatus(
   if (isMatchingTarget && isTimelyTarget(fork, inclusionDelay)) flags |= TIMELY_TARGET;
   if (isMatchingHead && inclusionDelay === MIN_ATTESTATION_INCLUSION_DELAY) flags |= TIMELY_HEAD;
 
-  return flags;
+  return {flags, isSameSlotAttestation};
 }
 
 export function checkpointValueEquals(cp1: phase0.Checkpoint, cp2: phase0.Checkpoint): boolean {

package/src/block/processBuilderDepositRequest.ts

@@ -1,8 +1,13 @@
-import {FAR_FUTURE_EPOCH} from "@lodestar/params";
+import {FAR_FUTURE_EPOCH, PAYLOAD_BUILDER_VERSION} from "@lodestar/params";
 import {gloas} from "@lodestar/types";
 import {CachedBeaconStateGloas} from "../types.js";
 import {computeEpochAtSlot} from "../util/epoch.js";
-import {addBuilderToRegistry, findBuilderIndexByPubkey, isValidBuilderDepositSignature} from "../util/gloas.js";
+import {
+  addBuilderToRegistry,
+  findBuilderIndexByPubkey,
+  isBuilderWithdrawalCredential,
+  isValidBuilderDepositSignature,
+} from "../util/gloas.js";
 
 /**
  * Process a builder deposit request from the execution layer: register a new builder
@@ -15,6 +20,12 @@ export function processBuilderDepositRequest(
   request: gloas.BuilderDepositRequest
 ): void {
   const {pubkey, withdrawalCredentials, amount, signature} = request;
+
+  // Ignore deposits with unexpected withdrawal credential prefixes.
+  if (!isBuilderWithdrawalCredential(withdrawalCredentials)) {
+    return;
+  }
+
   const builderIndex = findBuilderIndexByPubkey(state, pubkey);
 
   if (builderIndex === null) {
@@ -22,7 +33,7 @@ export function processBuilderDepositRequest(
       addBuilderToRegistry(
         state,
         pubkey,
-        withdrawalCredentials[0],
+        PAYLOAD_BUILDER_VERSION,
         withdrawalCredentials.subarray(12),
         amount,
         state.slot
@@ -33,11 +44,13 @@ export function processBuilderDepositRequest(
 
   const builder = state.builders.get(builderIndex);
 
-  // Increase balance by deposit amount
-  builder.balance += amount;
-
-  // If exited, reset the withdrawable epoch
-  if (builder.withdrawableEpoch !== FAR_FUTURE_EPOCH) {
+  // If the builder has exited and been fully swept (balance drained to 0), reset the
+  // withdrawable epoch so this top-up becomes withdrawable again. Must run before the
+  // balance increase, since the reset is gated on the current balance being 0.
+  if (builder.withdrawableEpoch !== FAR_FUTURE_EPOCH && builder.balance === 0) {
     builder.withdrawableEpoch = computeEpochAtSlot(state.slot) + state.config.MIN_BUILDER_WITHDRAWABILITY_DELAY;
   }
+
+  // Increase balance by deposit amount
+  builder.balance += amount;
 }

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/epochCache.ts

@@ -408,12 +408,17 @@ export class EpochCache {
 
     const nextShuffling = cachedNextShuffling ?? computeEpochShuffling(state, nextActiveIndices, nextEpoch);
 
-    const currentProposerSeed = getSeed(state, currentEpoch, DOMAIN_BEACON_PROPOSER);
-
-    let proposers: number[];
+    let proposers: ValidatorIndex[];
+    let proposersNextEpoch: ProposersDeferred;
     if (currentEpoch >= config.FULU_FORK_EPOCH) {
-      // Overwrite proposers with state.proposerLookahead
-      proposers = (state as CachedBeaconStateFulu).proposerLookahead.getAll().slice(0, SLOTS_PER_EPOCH);
+      // After fulu, use state.proposerLookahead for current and next epoch proposers.
+      // Computing from the unfiltered active shuffling would include slashed validators in gloas.
+      const proposerLookahead = (state as CachedBeaconStateFulu).proposerLookahead.getAll();
+      proposers = proposerLookahead.slice(0, SLOTS_PER_EPOCH);
+      proposersNextEpoch = {
+        computed: true,
+        indexes: proposerLookahead.slice(SLOTS_PER_EPOCH, SLOTS_PER_EPOCH * 2),
+      };
     } else {
       // We need to calculate Pre-fulu
       // Allow to create CachedBeaconState for empty states, or no active validators
@@ -421,18 +426,17 @@ export class EpochCache {
         currentShuffling.activeIndices.length > 0
           ? computeProposers(
               config.getForkSeqAtEpoch(currentEpoch),
-              currentProposerSeed,
+              getSeed(state, currentEpoch, DOMAIN_BEACON_PROPOSER),
               currentShuffling,
               effectiveBalanceIncrements
             )
           : [];
+      proposersNextEpoch = {
+        computed: false,
+        seed: getSeed(state, nextEpoch, DOMAIN_BEACON_PROPOSER),
+      };
     }
 
-    const proposersNextEpoch: ProposersDeferred = {
-      computed: false,
-      seed: getSeed(state, nextEpoch, DOMAIN_BEACON_PROPOSER),
-    };
-
     // Only after altair, compute the indices of the current sync committee
     const afterAltairFork = currentEpoch >= config.ALTAIR_FORK_EPOCH;
 
@@ -713,17 +717,10 @@ export class EpochCache {
       // Populate proposer cache with lookahead from state
       const proposerLookahead = (state as CachedBeaconStateFulu).proposerLookahead.getAll();
       this.proposers = proposerLookahead.slice(0, SLOTS_PER_EPOCH);
-
-      if (proposerLookahead.length >= SLOTS_PER_EPOCH * 2) {
-        this.proposersNextEpoch = {
-          computed: true,
-          indexes: proposerLookahead.slice(SLOTS_PER_EPOCH, SLOTS_PER_EPOCH * 2),
-        };
-      } else {
-        // This should not happen unless MIN_SEED_LOOKAHEAD is set to 0
-        // this ensures things don't break if the proposer lookahead is not long enough
-        this.proposersNextEpoch = {computed: false, seed: getSeed(state, epochAfterUpcoming, DOMAIN_BEACON_PROPOSER)};
-      }
+      this.proposersNextEpoch = {
+        computed: true,
+        indexes: proposerLookahead.slice(SLOTS_PER_EPOCH, SLOTS_PER_EPOCH * 2),
+      };
     } else {
       // Need to calculate proposers pre-fulu
       const upcomingProposerSeed = getSeed(state, upcomingEpoch, DOMAIN_BEACON_PROPOSER);

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/processLightClientUpdate.ts

@@ -5,7 +5,13 @@ import {pruneSetToMax} from "@lodestar/utils";
 import {computeSyncPeriodAtSlot} from "../../util/epoch.js";
 import {LightClientUpdateSummary, isBetterUpdate, toLightClientUpdateSummary} from "./isBetterUpdate.js";
 import {type ILightClientStore, MAX_SYNC_PERIODS_CACHE, type SyncCommitteeFast} from "./store.js";
-import {deserializeSyncCommittee, getSafetyThreshold, isSyncCommitteeUpdate, sumBits} from "./utils.js";
+import {
+  deserializeSyncCommittee,
+  getSafetyThreshold,
+  isFinalityUpdate,
+  isSyncCommitteeUpdate,
+  sumBits,
+} from "./utils.js";
 import {validateLightClientUpdate} from "./validateLightClientUpdate.js";
 
 export interface ProcessUpdateOpts {
@@ -44,7 +50,13 @@ export function processLightClientUpdate(
   }
 
   // Update finalized header
+  // Defense-in-depth: require isFinalityUpdate(update) so a non-finality update can never
+  // overwrite store.finalizedHeader, regardless of any future loosening of the zeroed-header
+  // checks in validateLightClientUpdate. Spec-faithful behavior also holds without this guard
+  // once update.finalizedHeader is guaranteed fully-zero in the non-finality case, but the
+  // guard makes the invariant local to this write site.
   if (
+    isFinalityUpdate(update) &&
     syncCommitteeTrueBits * 3 >= SYNC_COMMITTEE_SIZE * 2 &&
     update.finalizedHeader.beacon.slot > store.finalizedHeader.beacon.slot
   ) {