@lodestar/beacon-node 1.41.0-dev.9fa839a030 → 1.41.0-dev.aeb5a213ee

package/src/api/impl/validator/index.ts

@@ -3,6 +3,7 @@ import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
 import {ExecutionStatus, ProtoBlock} from "@lodestar/fork-choice";
 import {
+  BUILDER_INDEX_SELF_BUILD,
   ForkName,
   ForkPostBellatrix,
   ForkPreGloas,
@@ -14,6 +15,7 @@ import {
   isForkPostBellatrix,
   isForkPostDeneb,
   isForkPostElectra,
+  isForkPostGloas,
 } from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
@@ -45,6 +47,7 @@ import {
   Wei,
   bellatrix,
   getValidatorStatus,
+  gloas,
   phase0,
   ssz,
 } from "@lodestar/types";
@@ -69,7 +72,7 @@ import {
 } from "../../../chain/errors/index.js";
 import {ChainEvent, CommonBlockBody} from "../../../chain/index.js";
 import {PREPARE_NEXT_SLOT_BPS} from "../../../chain/prepareNextSlot.js";
-import {BlockType, ProduceFullDeneb} from "../../../chain/produceBlock/index.js";
+import {BlockType, ProduceFullDeneb, ProduceFullGloas} from "../../../chain/produceBlock/index.js";
 import {RegenCaller} from "../../../chain/regen/index.js";
 import {CheckpointHex} from "../../../chain/stateCache/types.js";
 import {validateApiAggregateAndProof} from "../../../chain/validation/index.js";
@@ -901,6 +904,77 @@ export function getValidatorApi(
       return {data, meta};
     },
 
+    async produceBlockV4({slot, randaoReveal, graffiti, feeRecipient}) {
+      const fork = config.getForkName(slot);
+
+      if (!isForkPostGloas(fork)) {
+        throw new ApiError(400, `produceBlockV4 not supported for pre-gloas fork=${fork}`);
+      }
+
+      notWhileSyncing();
+      await waitForSlot(slot);
+
+      // TODO GLOAS: support producing blocks from builder bids
+      const source = ProducedBlockSource.engine;
+
+      // TODO GLOAS: needs to be updated after fork choice changes are merged
+      const parentBlock = chain.getProposerHead(slot);
+      const {blockRoot: parentBlockRootHex, slot: parentSlot} = parentBlock;
+      const parentBlockRoot = fromHex(parentBlockRootHex);
+      notOnOutOfRangeData(parentBlockRoot);
+      metrics?.blockProductionSlotDelta.set(slot - parentSlot);
+      metrics?.blockProductionRequests.inc({source});
+
+      const graffitiBytes = toGraffitiBytes(
+        graffiti ?? getDefaultGraffiti(getLodestarClientVersion(), chain.executionEngine.clientVersion, {})
+      );
+      const commonBlockBodyPromise = chain.produceCommonBlockBody({
+        slot,
+        parentBlock,
+        randaoReveal,
+        graffiti: graffitiBytes,
+      });
+
+      let timer: undefined | ((opts: {source: ProducedBlockSource}) => number);
+      try {
+        timer = metrics?.blockProductionTime.startTimer();
+        const {block, executionPayloadValue, consensusBlockValue} = await chain.produceBlock({
+          slot,
+          parentBlock,
+          randaoReveal,
+          graffiti: graffitiBytes,
+          feeRecipient,
+          commonBlockBodyPromise,
+        });
+
+        metrics?.blockProductionSuccess.inc({source});
+        metrics?.blockProductionNumAggregated.observe({source}, block.body.attestations.length);
+        metrics?.blockProductionConsensusBlockValue.observe({source}, Number(formatWeiToEth(consensusBlockValue)));
+        metrics?.blockProductionExecutionPayloadValue.observe({source}, Number(formatWeiToEth(executionPayloadValue)));
+
+        const blockRoot = toRootHex(config.getForkTypes(slot).BeaconBlock.hashTreeRoot(block));
+        logger.verbose("Produced block", {
+          slot,
+          executionPayloadValue,
+          consensusBlockValue,
+          root: blockRoot,
+        });
+        if (chain.opts.persistProducedBlocks) {
+          void chain.persistBlock(block, "produced_engine_block");
+        }
+
+        return {
+          data: block as gloas.BeaconBlock,
+          meta: {
+            version: fork,
+            consensusBlockValue,
+          },
+        };
+      } finally {
+        timer?.({source});
+      }
+    },
+
     async produceAttestationData({committeeIndex, slot}) {
       notWhileSyncing();
 
@@ -1532,5 +1606,54 @@ export function getValidatorApi(
         count: filteredRegistrations.length,
       });
     },
+
+    async getExecutionPayloadEnvelope({slot, beaconBlockRoot}) {
+      const fork = config.getForkName(slot);
+
+      if (!isForkPostGloas(fork)) {
+        throw new ApiError(400, `getExecutionPayloadEnvelope not supported for pre-gloas fork=${fork}`);
+      }
+
+      notWhileSyncing();
+      await waitForSlot(slot);
+
+      const blockRootHex = toRootHex(beaconBlockRoot);
+      const produceResult = chain.blockProductionCache.get(blockRootHex);
+
+      if (produceResult === undefined) {
+        throw new ApiError(404, `No cached block production result found for block root ${blockRootHex}`);
+      }
+      if (!isForkPostGloas(produceResult.fork)) {
+        throw Error(`Cached block production result is for pre-gloas fork=${produceResult.fork}`);
+      }
+      if (produceResult.type !== BlockType.Full) {
+        throw Error("Cached block production result is not full block");
+      }
+
+      const {executionPayload, executionRequests, envelopeStateRoot} = produceResult as ProduceFullGloas;
+
+      const envelope: gloas.ExecutionPayloadEnvelope = {
+        payload: executionPayload,
+        executionRequests: executionRequests,
+        builderIndex: BUILDER_INDEX_SELF_BUILD,
+        beaconBlockRoot,
+        slot,
+        stateRoot: envelopeStateRoot,
+      };
+
+      logger.info("Produced execution payload envelope", {
+        slot,
+        blockRoot: blockRootHex,
+        transactions: executionPayload.transactions.length,
+        blockHash: toRootHex(executionPayload.blockHash),
+      });
+
+      return {
+        data: envelope,
+        meta: {
+          version: fork,
+        },
+      };
+    },
   };
 }

package/src/chain/archiveStore/archiveStore.ts

@@ -1,5 +1,6 @@
 import {CheckpointWithHex} from "@lodestar/fork-choice";
 import {LoggerNode} from "@lodestar/logger/node";
+import {ForkSeq} from "@lodestar/params";
 import {Checkpoint} from "@lodestar/types/phase0";
 import {callFnWhenAwait} from "@lodestar/utils";
 import {IBeaconDb} from "../../db/index.js";
@@ -13,6 +14,7 @@ import {HistoricalStateRegen} from "./historicalState/historicalStateRegen.js";
 import {ArchiveMode, ArchiveStoreOpts, StateArchiveStrategy} from "./interface.js";
 import {FrequencyStateArchiveStrategy} from "./strategies/frequencyStateArchiveStrategy.js";
 import {archiveBlocks} from "./utils/archiveBlocks.js";
+import {archiveExecutionPayloadEnvelopes} from "./utils/archivePayloads.js";
 import {pruneHistory} from "./utils/pruneHistory.js";
 import {updateBackfillRange} from "./utils/updateBackfillRange.js";
 
@@ -27,6 +29,7 @@ type ArchiveStoreInitOpts = ArchiveStoreOpts & {dbName: string; anchorState: {fi
 
 export enum ArchiveStoreTask {
   ArchiveBlocks = "archive_blocks",
+  ArchivePayloads = "archive_payloads",
   PruneHistory = "prune_history",
   OnFinalizedCheckpoint = "on_finalized_checkpoint",
   MaybeArchiveState = "maybe_archive_state",
@@ -189,6 +192,7 @@ export class ArchiveStore {
   private processFinalizedCheckpoint = async (finalized: CheckpointWithHex): Promise<void> => {
     try {
       const finalizedEpoch = finalized.epoch;
+      const finalizedFork = this.chain.config.getForkSeqAtEpoch(finalizedEpoch);
       this.logger.verbose("Start processing finalized checkpoint", {epoch: finalizedEpoch, rootHex: finalized.rootHex});
 
       let timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
@@ -206,6 +210,12 @@ export class ArchiveStore {
       );
       timer?.({source: ArchiveStoreTask.ArchiveBlocks});
 
+      if (finalizedFork >= ForkSeq.gloas) {
+        timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
+        await archiveExecutionPayloadEnvelopes(this.chain, finalized);
+        timer?.({source: ArchiveStoreTask.ArchivePayloads});
+      }
+
       if (this.opts.pruneHistory) {
         timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
         await pruneHistory(

package/src/chain/archiveStore/utils/archivePayloads.ts

@@ -0,0 +1,15 @@
+import {CheckpointWithHex} from "@lodestar/fork-choice";
+import {IBeaconChain} from "../../interface.js";
+
+/**
+ * Archives execution payload envelopes from hot DB to archive DB after finalization.
+ */
+export async function archiveExecutionPayloadEnvelopes(
+  chain: IBeaconChain,
+  _finalized: CheckpointWithHex
+): Promise<void> {
+  const finalizedBlock = chain.forkChoice.getFinalizedBlock();
+  if (!finalizedBlock) return;
+
+  // TODO GLOAS: Implement payload envelope archival after epbs fork choice changes are merged
+}

package/src/chain/blocks/importBlock.ts

@@ -101,9 +101,6 @@ export async function importBlock(
     }
   });
 
-  // Without forcefully clearing this cache, we would rely on WeakMap to evict memory which is not reliable
-  this.serializedCache.clear();
-
   // 2. Import block to fork choice
 
   // Should compute checkpoint balances before forkchoice.onBlock

package/src/chain/blocks/index.ts

@@ -1,6 +1,7 @@
 import {SignedBeaconBlock} from "@lodestar/types";
 import {isErrorAborted, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
+import {nextEventLoop} from "../../util/eventLoop.js";
 import {JobItemQueue, isQueueErrorAborted} from "../../util/queue/index.js";
 import type {BeaconChain} from "../chain.js";
 import {BlockError, BlockErrorCode, isBlockErrorAborted} from "../errors/index.js";
@@ -100,9 +101,9 @@ export async function processBlocks(
     );
 
     for (const fullyVerifiedBlock of fullyVerifiedBlocks) {
-      // No need to sleep(0) here since `importBlock` includes a disk write
       // TODO: Consider batching importBlock too if it takes significant time
       await importBlock.call(this, fullyVerifiedBlock, opts);
+      await nextEventLoop();
     }
   } catch (e) {
     if (isErrorAborted(e) || isQueueErrorAborted(e) || isBlockErrorAborted(e)) {

package/src/chain/blocks/writeBlockInputToDb.ts

@@ -125,6 +125,9 @@ export async function persistBlockInputs(this: BeaconChain, blockInputs: IBlockI
       for (const blockInput of blockInputs) {
         this.seenBlockInputCache.prune(blockInput.blockRootHex);
       }
+      // Without forcefully clearing this cache, we would rely on WeakMap to evict memory which is not reliable.
+      // Clear here (after the DB write) so that writeBlockInputToDb can still use the cached serialized bytes.
+      this.serializedCache.clear();
       if (blockInputs.length === 1) {
         this.logger.debug("Pruned block input", {
           slot: blockInputs[0].slot,

package/src/chain/chain.ts

@@ -5,11 +5,20 @@ import {CompositeTypeAny, TreeView, Type} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
 import {CheckpointWithHex, IForkChoice, ProtoBlock, UpdateHeadOpt} from "@lodestar/fork-choice";
 import {LoggerNode} from "@lodestar/logger/node";
-import {EFFECTIVE_BALANCE_INCREMENT, GENESIS_SLOT, SLOTS_PER_EPOCH, isForkPostElectra} from "@lodestar/params";
+import {
+  BUILDER_INDEX_SELF_BUILD,
+  EFFECTIVE_BALANCE_INCREMENT,
+  ForkPostFulu,
+  GENESIS_SLOT,
+  SLOTS_PER_EPOCH,
+  isForkPostElectra,
+  isForkPostGloas,
+} from "@lodestar/params";
 import {
   BeaconStateAllForks,
   BeaconStateElectra,
   CachedBeaconStateAllForks,
+  CachedBeaconStateGloas,
   EffectiveBalanceIncrements,
   EpochShuffling,
   Index2PubkeyCache,
@@ -28,6 +37,7 @@ import {
   BeaconBlock,
   BlindedBeaconBlock,
   BlindedBeaconBlockBody,
+  DataColumnSidecars,
   Epoch,
   Root,
   RootHex,
@@ -38,7 +48,7 @@ import {
   ValidatorIndex,
   Wei,
   deneb,
-  fulu,
+  gloas,
   isBlindedBeaconBlock,
   phase0,
   rewards,
@@ -87,8 +97,8 @@ import {
 } from "./opPools/index.js";
 import {IChainOptions} from "./options.js";
 import {PrepareNextSlotScheduler} from "./prepareNextSlot.js";
-import {computeNewStateRoot} from "./produceBlock/computeNewStateRoot.js";
-import {AssembledBlockType, BlockType, ProduceResult} from "./produceBlock/index.js";
+import {computeEnvelopeStateRoot, computeNewStateRoot} from "./produceBlock/computeNewStateRoot.js";
+import {AssembledBlockType, BlockType, ProduceFullGloas, ProduceResult} from "./produceBlock/index.js";
 import {BlockAttributes, produceBlockBody, produceCommonBlockBody} from "./produceBlock/produceBlockBody.js";
 import {QueuedStateRegenerator, RegenCaller} from "./regen/index.js";
 import {ReprocessController} from "./reprocess.js";
@@ -808,7 +818,7 @@ export class BeaconChain implements IBeaconChain {
     return null;
   }
 
-  async getDataColumnSidecars(blockSlot: Slot, blockRootHex: string): Promise<fulu.DataColumnSidecars> {
+  async getDataColumnSidecars(blockSlot: Slot, blockRootHex: string): Promise<DataColumnSidecars> {
     const blockInput = this.seenBlockInputCache.get(blockRootHex);
     if (blockInput) {
       if (!isBlockInputColumns(blockInput)) {
@@ -818,10 +828,10 @@ export class BeaconChain implements IBeaconChain {
     }
     const sidecarsUnfinalized = await this.db.dataColumnSidecar.values(fromHex(blockRootHex));
     if (sidecarsUnfinalized.length > 0) {
-      return sidecarsUnfinalized;
+      return sidecarsUnfinalized as DataColumnSidecars;
     }
     const sidecarsFinalized = await this.db.dataColumnSidecarArchive.values(blockSlot);
-    return sidecarsFinalized;
+    return sidecarsFinalized as DataColumnSidecars;
   }
 
   async getSerializedDataColumnSidecars(
@@ -843,7 +853,7 @@ export class BeaconChain implements IBeaconChain {
         if (serialized) {
           return serialized;
         }
-        return ssz.fulu.DataColumnSidecar.serialize(sidecar);
+        return sszTypesFor(blockInput.forkName as ForkPostFulu).DataColumnSidecar.serialize(sidecar);
       });
     }
     const sidecarsUnfinalized = await this.db.dataColumnSidecar.getManyBinary(fromHex(blockRootHex), indices);
@@ -902,6 +912,7 @@ export class BeaconChain implements IBeaconChain {
     consensusBlockValue: Wei;
     shouldOverrideBuilder?: boolean;
   }> {
+    const fork = this.config.getForkName(slot);
     const state = await this.regen.getBlockSlotState(
       parentBlock,
       slot,
@@ -930,7 +941,7 @@ export class BeaconChain implements IBeaconChain {
     // The hashtree root computed here for debug log will get cached and hence won't introduce additional delays
     const bodyRoot =
       produceResult.type === BlockType.Full
-        ? this.config.getForkTypes(slot).BeaconBlockBody.hashTreeRoot(body)
+        ? sszTypesFor(fork).BeaconBlockBody.hashTreeRoot(body)
         : this.config
             .getPostBellatrixForkTypes(slot)
             .BlindedBeaconBlockBody.hashTreeRoot(body as BlindedBeaconBlockBody);
@@ -948,14 +959,33 @@ export class BeaconChain implements IBeaconChain {
       body,
     } as AssembledBlockType<T>;
 
-    const {newStateRoot, proposerReward} = computeNewStateRoot(this.metrics, state, block);
+    const {newStateRoot, proposerReward, postState} = computeNewStateRoot(this.metrics, state, block);
     block.stateRoot = newStateRoot;
     const blockRoot =
       produceResult.type === BlockType.Full
-        ? this.config.getForkTypes(slot).BeaconBlock.hashTreeRoot(block)
+        ? sszTypesFor(fork).BeaconBlock.hashTreeRoot(block)
         : this.config.getPostBellatrixForkTypes(slot).BlindedBeaconBlock.hashTreeRoot(block as BlindedBeaconBlock);
     const blockRootHex = toRootHex(blockRoot);
 
+    if (isForkPostGloas(fork)) {
+      // TODO GLOAS: we should retire BlockType post-gloas, may need a new enum for self vs non-self built
+      if (produceResult.type !== BlockType.Full) {
+        throw Error(`Unexpected block type=${produceResult.type} for post-gloas fork=${fork}`);
+      }
+
+      const gloasResult = produceResult as ProduceFullGloas;
+      const envelope: gloas.ExecutionPayloadEnvelope = {
+        payload: gloasResult.executionPayload,
+        executionRequests: gloasResult.executionRequests,
+        builderIndex: BUILDER_INDEX_SELF_BUILD,
+        beaconBlockRoot: blockRoot,
+        slot,
+        stateRoot: ZERO_HASH,
+      };
+      const envelopeStateRoot = computeEnvelopeStateRoot(this.metrics, postState as CachedBeaconStateGloas, envelope);
+      gloasResult.envelopeStateRoot = envelopeStateRoot;
+    }
+
     // Track the produced block for consensus broadcast validations, later validation, etc.
     this.blockProductionCache.set(blockRootHex, produceResult);
     this.metrics?.blockProductionCacheSize.set(this.blockProductionCache.size);

package/src/chain/emitter.ts

@@ -3,7 +3,7 @@ import {StrictEventEmitter} from "strict-event-emitter-types";
 import {routes} from "@lodestar/api";
 import {CheckpointWithHex} from "@lodestar/fork-choice";
 import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {RootHex, deneb, fulu, phase0} from "@lodestar/types";
+import {DataColumnSidecars, RootHex, deneb, phase0} from "@lodestar/types";
 import {PeerIdStr} from "../util/peerId.js";
 import {BlockInputSource, IBlockInput} from "./blocks/blockInput/types.js";
 
@@ -88,7 +88,7 @@ export type IChainEvents = ApiEvents & {
 
   [ChainEvent.updateTargetCustodyGroupCount]: (targetGroupCount: number) => void;
 
-  [ChainEvent.publishDataColumns]: (sidecars: fulu.DataColumnSidecar[]) => void;
+  [ChainEvent.publishDataColumns]: (sidecars: DataColumnSidecars) => void;
 
   [ChainEvent.publishBlobSidecars]: (sidecars: deneb.BlobSidecar[]) => void;
 

package/src/chain/interface.ts

@@ -11,6 +11,7 @@ import {
 import {
   BeaconBlock,
   BlindedBeaconBlock,
+  DataColumnSidecars,
   Epoch,
   Root,
   RootHex,
@@ -23,7 +24,6 @@ import {
   altair,
   capella,
   deneb,
-  fulu,
   phase0,
   rewards,
 } from "@lodestar/types";
@@ -224,7 +224,7 @@ export interface IBeaconChain {
   ): Promise<{block: SignedBeaconBlock; executionOptimistic: boolean; finalized: boolean} | null>;
   getBlobSidecars(blockSlot: Slot, blockRootHex: string): Promise<deneb.BlobSidecars | null>;
   getSerializedBlobSidecars(blockSlot: Slot, blockRootHex: string): Promise<Uint8Array | null>;
-  getDataColumnSidecars(blockSlot: Slot, blockRootHex: string): Promise<fulu.DataColumnSidecars>;
+  getDataColumnSidecars(blockSlot: Slot, blockRootHex: string): Promise<DataColumnSidecars>;
   getSerializedDataColumnSidecars(
     blockSlot: Slot,
     blockRootHex: string,

package/src/chain/lightClient/index.ts

@@ -355,7 +355,10 @@ export class LightClientServer {
     // Signature data
     const update = await this.db.bestLightClientUpdate.get(period);
     if (!update) {
-      throw Error(`No partialUpdate available for period ${period}`);
+      throw new LightClientServerError(
+        {code: LightClientServerErrorCode.RESOURCE_UNAVAILABLE},
+        `No partialUpdate available for period ${period}`
+      );
     }
     return update;
   }

package/src/chain/options.ts

@@ -27,6 +27,7 @@ export type IChainOptions = BlockProcessOpts &
     blsVerifyAllMainThread?: boolean;
     blsVerifyAllMultiThread?: boolean;
     blacklistedBlocks?: string[];
+    // TODO GLOAS: add similar option for execution payload envelopes?
     persistProducedBlocks?: boolean;
     persistInvalidSszObjects?: boolean;
     persistInvalidSszObjectsDir?: string;

package/src/chain/prepareNextSlot.ts

@@ -1,14 +1,14 @@
 import {routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
 import {getSafeExecutionBlockHash} from "@lodestar/fork-choice";
-import {ForkPostBellatrix, ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {ForkPostBellatrix, ForkSeq, SLOTS_PER_EPOCH, isForkPostBellatrix} from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
   CachedBeaconStateExecutions,
+  CachedBeaconStateGloas,
   StateHashTreeRootSource,
   computeEpochAtSlot,
   computeTimeAtSlot,
-  isExecutionStateType,
 } from "@lodestar/state-transition";
 import {Slot} from "@lodestar/types";
 import {Logger, fromHex, isErrorAborted, sleep} from "@lodestar/utils";
@@ -120,10 +120,10 @@ export class PrepareNextSlotScheduler {
         RegenCaller.precomputeEpoch
       );
 
-      if (isExecutionStateType(prepareState)) {
+      if (isForkPostBellatrix(fork)) {
         const proposerIndex = prepareState.epochCtx.getBeaconProposer(prepareSlot);
         const feeRecipient = this.chain.beaconProposerCache.get(proposerIndex);
-        let updatedPrepareState = prepareState;
+        let updatedPrepareState = prepareState as CachedBeaconStateExecutions | CachedBeaconStateGloas;
         let updatedHeadRoot = headRoot;
 
         if (feeRecipient) {
@@ -146,7 +146,7 @@ export class PrepareNextSlotScheduler {
               // only transfer cache if epoch transition because that's the state we will use to stateTransition() the 1st block of epoch
               {dontTransferCache: !isEpochTransition},
               RegenCaller.predictProposerHead
-            )) as CachedBeaconStateExecutions;
+            )) as CachedBeaconStateExecutions | CachedBeaconStateGloas;
             updatedHeadRoot = proposerHeadRoot;
           }
 

package/src/chain/produceBlock/computeNewStateRoot.ts

@@ -1,11 +1,14 @@
 import {
   CachedBeaconStateAllForks,
+  CachedBeaconStateGloas,
   DataAvailabilityStatus,
   ExecutionPayloadStatus,
+  G2_POINT_AT_INFINITY,
   StateHashTreeRootSource,
   stateTransition,
 } from "@lodestar/state-transition";
-import {BeaconBlock, BlindedBeaconBlock, Gwei, Root} from "@lodestar/types";
+import {processExecutionPayloadEnvelope} from "@lodestar/state-transition/block";
+import {BeaconBlock, BlindedBeaconBlock, Gwei, Root, gloas} from "@lodestar/types";
 import {ZERO_HASH} from "../../constants/index.js";
 import {Metrics} from "../../metrics/index.js";
 
@@ -18,7 +21,7 @@ export function computeNewStateRoot(
   metrics: Metrics | null,
   state: CachedBeaconStateAllForks,
   block: BeaconBlock | BlindedBeaconBlock
-): {newStateRoot: Root; proposerReward: Gwei} {
+): {newStateRoot: Root; proposerReward: Gwei; postState: CachedBeaconStateAllForks} {
   // Set signature to zero to re-use stateTransition() function which requires the SignedBeaconBlock type
   const blockEmptySig = {message: block, signature: ZERO_HASH};
 
@@ -51,5 +54,34 @@ export function computeNewStateRoot(
   const newStateRoot = postState.hashTreeRoot();
   hashTreeRootTimer?.();
 
-  return {newStateRoot, proposerReward};
+  return {newStateRoot, proposerReward, postState};
+}
+
+/**
+ * Compute the state root after processing an execution payload envelope.
+ * Similar to `computeNewStateRoot` but for payload envelope processing.
+ *
+ * The `postBlockState` is mutated in place, callers must ensure it is not needed afterward.
+ */
+export function computeEnvelopeStateRoot(
+  metrics: Metrics | null,
+  postBlockState: CachedBeaconStateGloas,
+  envelope: gloas.ExecutionPayloadEnvelope
+): Root {
+  const signedEnvelope: gloas.SignedExecutionPayloadEnvelope = {
+    message: envelope,
+    signature: G2_POINT_AT_INFINITY,
+  };
+
+  const processEnvelopeTimer = metrics?.blockPayload.executionPayloadEnvelopeProcessingTime.startTimer();
+  processExecutionPayloadEnvelope(postBlockState, signedEnvelope, false);
+  processEnvelopeTimer?.();
+
+  const hashTreeRootTimer = metrics?.stateHashTreeRootTime.startTimer({
+    source: StateHashTreeRootSource.computeEnvelopeStateRoot,
+  });
+  const stateRoot = postBlockState.hashTreeRoot();
+  hashTreeRootTimer?.();
+
+  return stateRoot;
 }