@lodestar/state-transition 1.43.0-dev.ade910fc78 → 1.43.0-dev.b741495bdc

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.43.0-dev.ade910fc78",
+  "version": "1.43.0-dev.b741495bdc",
   "type": "module",
   "exports": {
     ".": {
@@ -65,16 +65,16 @@
     "@chainsafe/persistent-merkle-tree": "^1.2.1",
     "@chainsafe/persistent-ts": "^1.0.0",
     "@chainsafe/pubkey-index-map": "^3.0.0",
-    "@chainsafe/ssz": "^1.2.2",
+    "@chainsafe/ssz": "^1.4.0",
     "@chainsafe/swap-or-not-shuffle": "^1.2.1",
-    "@lodestar/config": "^1.43.0-dev.ade910fc78",
-    "@lodestar/params": "^1.43.0-dev.ade910fc78",
-    "@lodestar/types": "^1.43.0-dev.ade910fc78",
-    "@lodestar/utils": "^1.43.0-dev.ade910fc78",
+    "@lodestar/config": "^1.43.0-dev.b741495bdc",
+    "@lodestar/params": "^1.43.0-dev.b741495bdc",
+    "@lodestar/types": "^1.43.0-dev.b741495bdc",
+    "@lodestar/utils": "^1.43.0-dev.b741495bdc",
     "@vekexasia/bigint-buffer2": "^1.1.1"
   },
   "devDependencies": {
-    "@lodestar/api": "^1.43.0-dev.ade910fc78"
+    "@lodestar/api": "^1.43.0-dev.b741495bdc"
   },
   "keywords": [
     "ethereum",
@@ -82,5 +82,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "28e20b48ea4cedefb77526a12286bb0b042a08bb"
+  "gitHead": "30fc761b43215b6e1b51e1d847af5c76f7447a4a"
 }

package/src/block/index.ts

@@ -14,8 +14,8 @@ import {processBlockHeader} from "./processBlockHeader.js";
 import {processEth1Data} from "./processEth1Data.js";
 import {processExecutionPayload} from "./processExecutionPayload.js";
 import {processExecutionPayloadBid} from "./processExecutionPayloadBid.js";
-import {processExecutionPayloadEnvelope} from "./processExecutionPayloadEnvelope.js";
 import {processOperations} from "./processOperations.js";
+import {processParentExecutionPayload} from "./processParentExecutionPayload.js";
 import {processPayloadAttestation} from "./processPayloadAttestation.js";
 import {processRandao} from "./processRandao.js";
 import {processSyncAggregate} from "./processSyncCommittee.js";
@@ -32,7 +32,7 @@ export {
   processWithdrawals,
   processExecutionPayloadBid,
   processPayloadAttestation,
-  processExecutionPayloadEnvelope,
+  processParentExecutionPayload,
 };
 
 export * from "./externalData.js";
@@ -51,10 +51,16 @@ export function processBlock(
 ): void {
   const {verifySignatures = true} = opts ?? {};
 
+  // Apply the parent's deferred payload effects before everything else. Must run before
+  // processBlockHeader and processExecutionPayloadBid so subsequent steps see the updated state.
+  if (fork >= ForkSeq.gloas) {
+    processParentExecutionPayload(state as CachedBeaconStateGloas, block as BeaconBlock<ForkPostGloas>);
+  }
+
   processBlockHeader(state, block);
 
   if (fork >= ForkSeq.gloas) {
-    // After gloas, processWithdrawals does not take a payload parameter
+    // Parent payload's execution requests were already applied by processParentExecutionPayload above
     processWithdrawals(fork, state as CachedBeaconStateGloas);
   } else if (fork >= ForkSeq.capella) {
     const fullOrBlindedPayload = getFullOrBlindedPayload(block);
@@ -67,7 +73,9 @@ export function processBlock(
 
   // The call to the process_execution_payload must happen before the call to the process_randao as the former depends
   // on the randao_mix computed with the reveal of the previous block.
-  // TODO GLOAS: We call processExecutionPayload somewhere else post-gloas
+  // Post-gloas: process_execution_payload is not part of block processing. The parent's payload
+  // effects are applied earlier via processParentExecutionPayload, and each execution payload is
+  // verified out-of-band via verifyExecutionPayloadEnvelope when it arrives.
   if (
     fork < ForkSeq.gloas &&
     fork >= ForkSeq.bellatrix &&

package/src/block/processParentExecutionPayload.ts

@@ -0,0 +1,116 @@
+import {ForkPostGloas, SLOTS_PER_EPOCH, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
+import {BeaconBlock, electra, ssz} from "@lodestar/types";
+import {byteArrayEquals, toRootHex} from "@lodestar/utils";
+import {CachedBeaconStateGloas} from "../types.js";
+import {computeEpochAtSlot} from "../util/epoch.js";
+import {processConsolidationRequest} from "./processConsolidationRequest.js";
+import {getPendingValidatorPubkeys, processDepositRequest} from "./processDepositRequest.js";
+import {processWithdrawalRequest} from "./processWithdrawalRequest.js";
+
+/**
+ * Process parent execution payload effects as the first step of processBlock.
+ *
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.5/specs/gloas/beacon-chain.md#new-process_parent_execution_payload
+ */
+export function processParentExecutionPayload(state: CachedBeaconStateGloas, block: BeaconBlock<ForkPostGloas>): void {
+  const bid = block.body.signedExecutionPayloadBid.message;
+  const parentBid = state.latestExecutionPayloadBid;
+  const requests = block.body.parentExecutionRequests;
+
+  const isParentBlockFull = byteArrayEquals(bid.parentBlockHash, parentBid.blockHash);
+  if (!isParentBlockFull) {
+    // Parent was EMPTY -- no execution requests expected
+    assertEmptyExecutionRequests(requests);
+    return;
+  }
+
+  // Parent was FULL -- verify the bid commitment and apply the payload
+  const requestsRoot = ssz.electra.ExecutionRequests.hashTreeRoot(requests);
+  if (!byteArrayEquals(requestsRoot, parentBid.executionRequestsRoot)) {
+    throw new Error(
+      `Parent execution requests root mismatch actual=${toRootHex(requestsRoot)} expected=${toRootHex(parentBid.executionRequestsRoot)}`
+    );
+  }
+
+  applyParentExecutionPayload(state, requests);
+}
+
+/**
+ * Process the parent's execution requests, queue the builder payment, update payload availability,
+ * and update the latest block hash.
+ *
+ * Called from processParentExecutionPayload during block processing, and from the validator during
+ * block production before computing withdrawals.
+ *
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.5/specs/gloas/beacon-chain.md#new-apply_parent_execution_payload
+ */
+export function applyParentExecutionPayload(state: CachedBeaconStateGloas, requests: electra.ExecutionRequests): void {
+  const fork = state.config.getForkSeq(state.slot);
+  const parentBid = state.latestExecutionPayloadBid;
+  const parentSlot = parentBid.slot;
+  const parentEpoch = computeEpochAtSlot(parentSlot);
+  const currentEpoch = computeEpochAtSlot(state.slot);
+
+  // Process execution requests from parent's payload. The execution
+  // requests are processed at state.slot (child's slot), not the parent's slot.
+  if (requests.deposits.length > 0) {
+    const pendingValidatorPubkeys = getPendingValidatorPubkeys(state.config, state);
+    for (const deposit of requests.deposits) {
+      processDepositRequest(fork, state, deposit, pendingValidatorPubkeys);
+    }
+  }
+
+  for (const withdrawal of requests.withdrawals) {
+    processWithdrawalRequest(fork, state, withdrawal);
+  }
+
+  for (const consolidation of requests.consolidations) {
+    processConsolidationRequest(state, consolidation);
+  }
+
+  // Settle the builder payment
+  if (parentEpoch === currentEpoch) {
+    settleBuilderPayment(state, SLOTS_PER_EPOCH + (parentSlot % SLOTS_PER_EPOCH));
+  } else if (parentEpoch === currentEpoch - 1) {
+    settleBuilderPayment(state, parentSlot % SLOTS_PER_EPOCH);
+  } else if (parentBid.value > 0) {
+    // Parent is older than the previous epoch, its payment entry has been evicted from
+    // builder_pending_payments. Append the withdrawal directly.
+    state.builderPendingWithdrawals.push(
+      ssz.gloas.BuilderPendingWithdrawal.toViewDU({
+        feeRecipient: parentBid.feeRecipient,
+        amount: parentBid.value,
+        builderIndex: parentBid.builderIndex,
+      })
+    );
+  }
+
+  // Update parent payload availability and latest block hash
+  state.executionPayloadAvailability.set(parentSlot % SLOTS_PER_HISTORICAL_ROOT, true);
+  state.latestBlockHash = parentBid.blockHash;
+}
+
+/**
+ * Settle a builder payment at the given index: move its withdrawal (if any) to the
+ * pending withdrawals list and clear the payment slot.
+ *
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.5/specs/gloas/beacon-chain.md#new-settle_builder_payment
+ */
+function settleBuilderPayment(state: CachedBeaconStateGloas, paymentIndex: number): void {
+  if (paymentIndex >= state.builderPendingPayments.length) {
+    throw new Error(
+      `Invalid builder payment index paymentIndex=${paymentIndex} limit=${state.builderPendingPayments.length}`
+    );
+  }
+  const payment = state.builderPendingPayments.get(paymentIndex).clone();
+  if (payment.withdrawal.amount > 0) {
+    state.builderPendingWithdrawals.push(payment.withdrawal);
+  }
+  state.builderPendingPayments.set(paymentIndex, ssz.gloas.BuilderPendingPayment.defaultViewDU());
+}
+
+function assertEmptyExecutionRequests(requests: electra.ExecutionRequests): void {
+  if (requests.deposits.length !== 0 || requests.withdrawals.length !== 0 || requests.consolidations.length !== 0) {
+    throw new Error("Parent execution requests must be empty when parent block is EMPTY");
+  }
+}

package/src/block/processWithdrawals.ts

@@ -10,6 +10,7 @@ import {
 } from "@lodestar/params";
 import {BuilderIndex, ValidatorIndex, capella, ssz} from "@lodestar/types";
 import {byteArrayEquals, toRootHex} from "@lodestar/utils";
+import {ZERO_HASH} from "../constants/index.js";
 import {CachedBeaconStateCapella, CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 import {
   convertBuilderIndexToValidatorIndex,
@@ -31,9 +32,14 @@ export function processWithdrawals(
   state: CachedBeaconStateCapella | CachedBeaconStateElectra | CachedBeaconStateGloas,
   payload?: capella.FullOrBlindedExecutionPayload
 ): void {
-  // Return early if the parent block is empty
-  if (fork >= ForkSeq.gloas && !isParentBlockFull(state as CachedBeaconStateGloas)) {
-    return;
+  // Return early if this is genesis block or the parent block is empty
+  if (fork >= ForkSeq.gloas) {
+    const stateGloas = state as CachedBeaconStateGloas;
+    const isGenesisBlock = byteArrayEquals(stateGloas.latestBlockHash, ZERO_HASH);
+    const isParentBlockEmpty = !isParentBlockFull(stateGloas);
+    if (isGenesisBlock || isParentBlockEmpty) {
+      return;
+    }
   }
 
   // processedBuilderWithdrawalsCount is withdrawals coming from builder payment since gloas (EIP-7732)
@@ -48,7 +54,9 @@ export function processWithdrawals(
   } = getExpectedWithdrawals(fork, state);
   const numWithdrawals = expectedWithdrawals.length;
 
-  // After gloas, withdrawals are verified later in processExecutionPayloadEnvelope
+  // Pre-gloas verifies the payload's withdrawals against expectedWithdrawals here.
+  // Post-gloas, the payload arrives later as an envelope and that consistency check
+  // happens in verifyExecutionPayloadEnvelope against state.payloadExpectedWithdrawals.
   if (fork < ForkSeq.gloas) {
     if (payload === undefined) {
       throw Error("payload is required for pre-gloas processWithdrawals");

package/src/cache/epochCache.ts

@@ -32,10 +32,10 @@ import {
   calculateShufflingDecisionRoot,
   computeEpochShuffling,
 } from "../util/epochShuffling.js";
+import {getPtcWindowEpochCacheData} from "../util/gloas.js";
 import {
   computeActivationExitEpoch,
   computeEpochAtSlot,
-  computePayloadTimelinessCommitteesForEpoch,
   computeProposers,
   computeSyncPeriodAtEpoch,
   getActivationChurnLimit,
@@ -56,7 +56,7 @@ import {sumTargetUnslashedBalanceIncrements} from "../util/targetUnslashedBalanc
 import {EffectiveBalanceIncrements, getEffectiveBalanceIncrementsWithLen} from "./effectiveBalanceIncrements.js";
 import {EpochTransitionCache} from "./epochTransitionCache.js";
 import {PubkeyCache, createPubkeyCache, syncPubkeys} from "./pubkeyCache.js";
-import {CachedBeaconStateAllForks, CachedBeaconStateFulu} from "./stateCache.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateFulu, CachedBeaconStateGloas} from "./stateCache.js";
 import {
   SyncCommitteeCache,
   SyncCommitteeCacheEmpty,
@@ -226,11 +226,12 @@ export class EpochCache {
   /** TODO: Indexed SyncCommitteeCache */
   nextSyncCommitteeIndexed: SyncCommitteeCache;
 
-  // TODO GLOAS: See if we need to cache PTC for next epoch
   // PTC for previous epoch, required for slot N block validating slot N-1 attestations
   previousPayloadTimelinessCommittees: Uint32Array[];
   // PTC for current epoch, computed eagerly at epoch transition
   payloadTimelinessCommittees: Uint32Array[];
+  // PTC for next epoch, precomputed from the ptc window for future duty serving
+  nextPayloadTimelinessCommittees: Uint32Array[];
 
   // TODO: Helper stats
   syncPeriod: SyncPeriod;
@@ -270,6 +271,7 @@ export class EpochCache {
     nextSyncCommitteeIndexed: SyncCommitteeCache;
     previousPayloadTimelinessCommittees: Uint32Array[];
     payloadTimelinessCommittees: Uint32Array[];
+    nextPayloadTimelinessCommittees: Uint32Array[];
     epoch: Epoch;
     syncPeriod: SyncPeriod;
   }) {
@@ -301,6 +303,7 @@ export class EpochCache {
     this.nextSyncCommitteeIndexed = data.nextSyncCommitteeIndexed;
     this.previousPayloadTimelinessCommittees = data.previousPayloadTimelinessCommittees;
     this.payloadTimelinessCommittees = data.payloadTimelinessCommittees;
+    this.nextPayloadTimelinessCommittees = data.nextPayloadTimelinessCommittees;
     this.epoch = data.epoch;
     this.syncPeriod = data.syncPeriod;
   }
@@ -451,25 +454,13 @@ export class EpochCache {
       nextSyncCommitteeIndexed = new SyncCommitteeCacheEmpty();
     }
 
-    // Compute PTC for all slots in the prev/current epoch
+    // Copy previous/current epoch PTC slices from state.ptcWindow once, then serve hot-path lookups from epochCtx.
     let previousPayloadTimelinessCommittees: Uint32Array[] = [];
     let payloadTimelinessCommittees: Uint32Array[] = [];
+    let nextPayloadTimelinessCommittees: Uint32Array[] = [];
     if (currentEpoch >= config.GLOAS_FORK_EPOCH) {
-      payloadTimelinessCommittees = computePayloadTimelinessCommitteesForEpoch(
-        state,
-        currentEpoch,
-        currentShuffling.committees,
-        effectiveBalanceIncrements
-      );
-
-      if (!isGenesis && previousEpoch >= config.GLOAS_FORK_EPOCH) {
-        previousPayloadTimelinessCommittees = computePayloadTimelinessCommitteesForEpoch(
-          state,
-          previousEpoch,
-          previousShuffling.committees,
-          effectiveBalanceIncrements
-        );
-      }
+      ({previousPayloadTimelinessCommittees, payloadTimelinessCommittees, nextPayloadTimelinessCommittees} =
+        getPtcWindowEpochCacheData(state as CachedBeaconStateGloas));
     }
 
     // Precompute churnLimit for efficient initiateValidatorExit() during block proposing MUST be recompute everytime the
@@ -546,6 +537,7 @@ export class EpochCache {
       nextSyncCommitteeIndexed,
       previousPayloadTimelinessCommittees,
       payloadTimelinessCommittees,
+      nextPayloadTimelinessCommittees,
       epoch: currentEpoch,
       syncPeriod: computeSyncPeriodAtEpoch(currentEpoch),
     });
@@ -592,6 +584,7 @@ export class EpochCache {
       nextSyncCommitteeIndexed: this.nextSyncCommitteeIndexed,
       previousPayloadTimelinessCommittees: this.previousPayloadTimelinessCommittees,
       payloadTimelinessCommittees: this.payloadTimelinessCommittees,
+      nextPayloadTimelinessCommittees: this.nextPayloadTimelinessCommittees,
       epoch: this.epoch,
       syncPeriod: this.syncPeriod,
     });
@@ -695,21 +688,26 @@ export class EpochCache {
   /**
    * At fork boundary, this runs post-fork logic and it happens after `upgradeState*` is called.
    */
-  finalProcessEpoch(state: CachedBeaconStateAllForks): void {
+  finalProcessEpoch(state: CachedBeaconStateAllForks, epochTransitionCache: EpochTransitionCache): void {
     // this.epoch was updated at the end of afterProcessEpoch()
     const upcomingEpoch = this.epoch;
     const epochAfterUpcoming = upcomingEpoch + 1;
 
     this.proposersPrevEpoch = this.proposers;
     if (upcomingEpoch >= this.config.GLOAS_FORK_EPOCH) {
-      // Shift and compute current epoch PTC eagerly for all slots
-      this.previousPayloadTimelinessCommittees = this.payloadTimelinessCommittees;
-      this.payloadTimelinessCommittees = computePayloadTimelinessCommitteesForEpoch(
-        state,
-        upcomingEpoch,
-        this.currentShuffling.committees,
-        this.effectiveBalanceIncrements
-      );
+      if (epochTransitionCache.nextEpochPayloadTimelinessCommittees) {
+        // shift arrays from transition cache
+        this.previousPayloadTimelinessCommittees = this.payloadTimelinessCommittees;
+        this.payloadTimelinessCommittees = this.nextPayloadTimelinessCommittees;
+        this.nextPayloadTimelinessCommittees = epochTransitionCache.nextEpochPayloadTimelinessCommittees;
+      } else {
+        // Fork boundary: processPtcWindow didn't run, read from freshly initialized state.ptcWindow
+        ({
+          previousPayloadTimelinessCommittees: this.previousPayloadTimelinessCommittees,
+          payloadTimelinessCommittees: this.payloadTimelinessCommittees,
+          nextPayloadTimelinessCommittees: this.nextPayloadTimelinessCommittees,
+        } = getPtcWindowEpochCacheData(state as CachedBeaconStateGloas));
+      }
     }
     if (upcomingEpoch >= this.config.FULU_FORK_EPOCH) {
       // Populate proposer cache with lookahead from state
@@ -1034,12 +1032,16 @@ export class EpochCache {
       throw new Error("Payload Timeliness Committee is not available before gloas fork");
     }
 
+    if (epoch === this.epoch - 1) {
+      return this.previousPayloadTimelinessCommittees[slot % SLOTS_PER_EPOCH];
+    }
+
     if (epoch === this.epoch) {
       return this.payloadTimelinessCommittees[slot % SLOTS_PER_EPOCH];
     }
 
-    if (epoch === this.epoch - 1 && this.previousPayloadTimelinessCommittees.length > 0) {
-      return this.previousPayloadTimelinessCommittees[slot % SLOTS_PER_EPOCH];
+    if (epoch === this.epoch + 1) {
+      return this.nextPayloadTimelinessCommittees[slot % SLOTS_PER_EPOCH];
     }
 
     throw new Error(`Payload Timeliness Committee is not available for slot=${slot}`);

package/src/cache/epochTransitionCache.ts

@@ -158,6 +158,12 @@ export interface EpochTransitionCache {
    */
   nextShuffling: EpochShuffling | null;
 
+  /**
+   * Pre-computed PTC for epoch N + MIN_SEED_LOOKAHEAD + 1, populated by processPtcWindow (Gloas+).
+   * Used by finalProcessEpoch to shift PTC arrays in epoch cache without reading from state.
+   */
+  nextEpochPayloadTimelinessCommittees: Uint32Array[] | null;
+
   /**
    * Altair specific, this is total active balances for the next epoch.
    * This is only used in `afterProcessEpoch` to compute base reward and sync participant reward.
@@ -502,6 +508,7 @@ export function beforeProcessEpoch(
     indicesToEject,
     nextShufflingActiveIndices,
     nextShuffling: null,
+    nextEpochPayloadTimelinessCommittees: null,
     // to be updated in processEffectiveBalanceUpdates
     nextEpochTotalActiveBalanceByIncrement: 0,
     isActivePrevEpoch,

package/src/epoch/index.ts

@@ -28,6 +28,7 @@ import {processParticipationRecordUpdates} from "./processParticipationRecordUpd
 import {processPendingConsolidations} from "./processPendingConsolidations.js";
 import {processPendingDeposits} from "./processPendingDeposits.js";
 import {processProposerLookahead} from "./processProposerLookahead.js";
+import {processPtcWindow} from "./processPtcWindow.js";
 import {processRandaoMixesReset} from "./processRandaoMixesReset.js";
 import {processRegistryUpdates} from "./processRegistryUpdates.js";
 import {processRewardsAndPenalties} from "./processRewardsAndPenalties.js";
@@ -55,6 +56,7 @@ export {
   processPendingDeposits,
   processPendingConsolidations,
   processProposerLookahead,
+  processPtcWindow,
   processBuilderPendingPayments,
 };
 
@@ -81,6 +83,7 @@ export enum EpochTransitionStep {
   processPendingDeposits = "processPendingDeposits",
   processPendingConsolidations = "processPendingConsolidations",
   processProposerLookahead = "processProposerLookahead",
+  processPtcWindow = "processPtcWindow",
   processBuilderPendingPayments = "processBuilderPendingPayments",
 }
 
@@ -211,4 +214,10 @@ export function processEpoch(
     processProposerLookahead(fork, state as CachedBeaconStateFulu, cache);
     timer?.();
   }
+
+  if (fork >= ForkSeq.gloas) {
+    const timer = metrics?.epochTransitionStepTime.startTimer({step: EpochTransitionStep.processPtcWindow});
+    processPtcWindow(state as CachedBeaconStateGloas, cache);
+    timer?.();
+  }
 }

package/src/epoch/processPtcWindow.ts

@@ -0,0 +1,38 @@
+import {MIN_SEED_LOOKAHEAD} from "@lodestar/params";
+import {ssz} from "@lodestar/types";
+import {CachedBeaconStateGloas, EpochTransitionCache} from "../types.js";
+import {computeEpochShuffling} from "../util/epochShuffling.js";
+import {computePayloadTimelinessCommitteesForEpoch} from "../util/seed.js";
+
+/**
+ * Update the `ptc_window` field in the beacon state by shifting out the oldest epoch's
+ * PTC entries and appending newly computed entries for the next lookahead epoch.
+ * Stashes the computed PTCs in the transition cache for finalProcessEpoch to shift
+ * into the epoch cache without reading from state.
+ *
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.4/specs/gloas/beacon-chain.md#new-process_ptc_window
+ */
+export function processPtcWindow(state: CachedBeaconStateGloas, cache: EpochTransitionCache): void {
+  const nextEpoch = state.epochCtx.epoch + MIN_SEED_LOOKAHEAD + 1;
+  const nextEpochShuffling =
+    cache.nextShuffling ?? computeEpochShuffling(state, cache.nextShufflingActiveIndices, nextEpoch);
+  cache.nextShuffling = nextEpochShuffling;
+
+  const newNextPayloadTimelinessCommittees = computePayloadTimelinessCommitteesForEpoch(
+    state,
+    nextEpoch,
+    nextEpochShuffling.committees,
+    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,
+  ]);
+}

package/src/signatureSets/executionPayloadEnvelope.ts

@@ -11,7 +11,7 @@ export function getExecutionPayloadEnvelopeSigningRoot(
   config: BeaconConfig,
   envelope: gloas.ExecutionPayloadEnvelope
 ): Uint8Array {
-  const domain = config.getDomain(envelope.slot, DOMAIN_BEACON_BUILDER);
+  const domain = config.getDomain(envelope.payload.slotNumber, DOMAIN_BEACON_BUILDER);
 
   return computeSigningRoot(ssz.gloas.ExecutionPayloadEnvelope, envelope, domain);
 }

package/src/slot/upgradeStateToGloas.ts

@@ -5,7 +5,7 @@ import {isValidDepositSignature} from "../block/processDeposit.js";
 import {applyDepositForBuilder} from "../block/processDepositRequest.js";
 import {getCachedBeaconState} from "../cache/stateCache.js";
 import {CachedBeaconStateFulu, CachedBeaconStateGloas} from "../types.js";
-import {isBuilderWithdrawalCredential} from "../util/gloas.js";
+import {initializePtcWindow, isBuilderWithdrawalCredential} from "../util/gloas.js";
 import {isValidatorKnown} from "../util/index.js";
 
 /**
@@ -48,6 +48,9 @@ export function upgradeStateToGloas(stateFulu: CachedBeaconStateFulu): CachedBea
   stateGloasView.currentSyncCommittee = stateGloasCloned.currentSyncCommittee;
   stateGloasView.nextSyncCommittee = stateGloasCloned.nextSyncCommittee;
   stateGloasView.latestExecutionPayloadBid.blockHash = stateFulu.latestExecutionPayloadHeader.blockHash;
+  stateGloasView.latestExecutionPayloadBid.executionRequestsRoot = ssz.electra.ExecutionRequests.hashTreeRoot(
+    ssz.electra.ExecutionRequests.defaultValue()
+  );
   stateGloasView.nextWithdrawalIndex = stateGloasCloned.nextWithdrawalIndex;
   stateGloasView.nextWithdrawalValidatorIndex = stateGloasCloned.nextWithdrawalValidatorIndex;
   stateGloasView.historicalSummaries = stateGloasCloned.historicalSummaries;
@@ -61,6 +64,7 @@ export function upgradeStateToGloas(stateFulu: CachedBeaconStateFulu): CachedBea
   stateGloasView.pendingPartialWithdrawals = stateGloasCloned.pendingPartialWithdrawals;
   stateGloasView.pendingConsolidations = stateGloasCloned.pendingConsolidations;
   stateGloasView.proposerLookahead = stateGloasCloned.proposerLookahead;
+  stateGloasView.ptcWindow = ssz.gloas.PtcWindow.toViewDU(initializePtcWindow(stateFulu));
 
   for (let i = 0; i < SLOTS_PER_HISTORICAL_ROOT; i++) {
     stateGloasView.executionPayloadAvailability.set(i, true);

package/src/stateTransition.ts

@@ -76,7 +76,6 @@ export enum StateHashTreeRootSource {
   prepareNextEpoch = "prepare_next_epoch",
   regenState = "regen_state",
   computeNewStateRoot = "compute_new_state_root",
-  computePayloadEnvelopeStateRoot = "compute_payload_envelope_state_root",
 }
 
 /**
@@ -283,7 +282,7 @@ function processSlotsWithTransientCache(
       {
         const timer = metrics?.epochTransitionStepTime.startTimer({step: EpochTransitionStep.finalProcessEpoch});
         // last step to prepare epoch data that depends on the upgraded state, for example proposerLookahead of BeaconStateFulu
-        postState.epochCtx.finalProcessEpoch(postState);
+        postState.epochCtx.finalProcessEpoch(postState, epochTransitionCache);
         timer?.();
       }