feat: enhance importBlock() for gloas

Author: twoeths

packages/beacon-node/src/chain/blocks/importBlock.ts

@@ -84,7 +84,7 @@ export async function importBlock(
   fullyVerifiedBlock: FullyVerifiedBlock,
   opts: ImportBlockOpts
 ): Promise<void> {
-  const {blockInput, postState, parentBlockSlot, executionStatus, dataAvailabilityStatus, indexedAttestations} =
+  const {blockInput, postBlockState, parentBlockSlot, executionStatus, dataAvailabilityStatus, indexedAttestations} =
     fullyVerifiedBlock;
   const block = blockInput.getBlock();
   const source = blockInput.getBlockSource();
@@ -96,7 +96,7 @@ export async function importBlock(
   const blockEpoch = computeEpochAtSlot(blockSlot);
   const prevFinalizedEpoch = this.forkChoice.getFinalizedCheckpoint().epoch;
   const blockDelaySec =
-    fullyVerifiedBlock.seenTimestampSec - computeTimeAtSlot(this.config, blockSlot, postState.genesisTime);
+    fullyVerifiedBlock.seenTimestampSec - computeTimeAtSlot(this.config, blockSlot, postBlockState.genesisTime);
   const recvToValLatency = Date.now() / 1000 - (opts.seenTimestampSec ?? Date.now() / 1000);
   const fork = this.config.getForkSeq(blockSlot);
 
@@ -119,10 +119,10 @@ export async function importBlock(
   // 2. Import block to fork choice
 
   // Should compute checkpoint balances before forkchoice.onBlock
-  this.checkpointBalancesCache.processState(blockRootHex, postState);
+  this.checkpointBalancesCache.processState(blockRootHex, postBlockState);
   const blockSummary = this.forkChoice.onBlock(
     block.message,
-    postState,
+    postBlockState,
     blockDelaySec,
     currentSlot,
     executionStatus,
@@ -135,7 +135,7 @@ export async function importBlock(
   // Post-Gloas: blockSummary.payloadStatus is always PENDING, so payloadPresent = false (block state only, no payload processing yet)
   const payloadPresent = !isGloasBlock(blockSummary);
   // processState manages both block state and payload state variants together for memory/disk management
-  this.regen.processBlockState(blockRootHex, postState);
+  this.regen.processBlockState(blockRootHex, postBlockState);
 
   // For Gloas blocks, create PayloadEnvelopeInput so it's available for later payload import
   if (fork >= ForkSeq.gloas) {
@@ -154,6 +154,23 @@ export async function importBlock(
     });
   }
 
+  // For Gloas blocks whose envelope was pre-verified during state transition (sync/batch path),
+  // immediately transition the block to FULL status in fork choice and cache the payload state.
+  // Mirrors steps 6–7 of importExecutionPayload, but reuses the already-computed postEnvelopeState.
+  if (fullyVerifiedBlock.postEnvelopeState !== null) {
+    // TODO GLOAS: this.unfinalizedPayloadEnvelopeWrites.push(payloadInput)
+    // need a payloadInput in fullyVerifiedBlock
+    const {postEnvelopeState} = fullyVerifiedBlock;
+    this.regen.processPayloadState(postEnvelopeState);
+    this.forkChoice.onExecutionPayload(
+      blockRootHex,
+      toRootHex(postEnvelopeState.latestBlockHash),
+      // TODO GLOAS: this is not right but we don't need to track it as part of consensus spec, lighthouse also does not track it
+      0,
+      toRootHex(postEnvelopeState.hashTreeRoot())
+    );
+  }
+
   this.metrics?.importBlock.bySource.inc({source: source.source});
   this.logger.verbose("Added block to forkchoice and state cache", {slot: blockSlot, root: blockRootHex});
 
@@ -171,7 +188,7 @@ export async function importBlock(
     (opts.importAttestations !== AttestationImportOpt.Skip && blockEpoch >= currentEpoch - FORK_CHOICE_ATT_EPOCH_LIMIT)
   ) {
     const attestations = block.message.body.attestations;
-    const rootCache = new RootCache(postState);
+    const rootCache = new RootCache(postBlockState);
     const invalidAttestationErrorsByCode = new Map<string, {error: Error; count: number}>();
 
     const addAttestation = fork >= ForkSeq.electra ? addAttestationPostElectra : addAttestationPreElectra;
@@ -185,7 +202,7 @@ export async function importBlock(
         const attDataRoot = toRootHex(ssz.phase0.AttestationData.hashTreeRoot(indexedAttestation.data));
         addAttestation.call(
           this,
-          postState,
+          postBlockState,
           target,
           attDataRoot,
           attestation as Attestation<ForkPostElectra>,
@@ -300,7 +317,7 @@ export async function importBlock(
 
   if (newHead.blockRoot !== oldHead.blockRoot) {
     // Set head state as strong reference
-    this.regen.updateHeadState(newHead, postState);
+    this.regen.updateHeadState(newHead, postBlockState);
 
     try {
       this.emitter.emit(routes.events.EventType.head, {
@@ -372,7 +389,7 @@ export async function importBlock(
         try {
           this.lightClientServer?.onImportBlockHead(
             block.message as BeaconBlock<ForkPostAltair>,
-            postState,
+            postBlockState,
             parentBlockSlot
           );
         } catch (e) {
@@ -393,11 +410,11 @@ export async function importBlock(
   // and the block is weak and can potentially be reorged out.
   let shouldOverrideFcu = false;
 
-  if (blockSlot >= currentSlot && postState.isExecutionStateType) {
+  if (blockSlot >= currentSlot && postBlockState.isExecutionStateType) {
     let notOverrideFcuReason = NotReorgedReason.Unknown;
     const proposalSlot = blockSlot + 1;
     try {
-      const proposerIndex = postState.getBeaconProposer(proposalSlot);
+      const proposerIndex = postBlockState.getBeaconProposer(proposalSlot);
       const feeRecipient = this.beaconProposerCache.get(proposerIndex);
 
       if (feeRecipient) {
@@ -477,20 +494,20 @@ export async function importBlock(
     }
   }
 
-  if (!postState.isStateValidatorsNodesPopulated()) {
-    this.logger.verbose("After importBlock caching postState without SSZ cache", {slot: postState.slot});
+  if (!postBlockState.isStateValidatorsNodesPopulated()) {
+    this.logger.verbose("After importBlock caching postBlockState without SSZ cache", {slot: postBlockState.slot});
   }
 
   // Cache shufflings when crossing an epoch boundary
   const parentEpoch = computeEpochAtSlot(parentBlockSlot);
   if (parentEpoch < blockEpoch) {
-    this.shufflingCache.processState(postState);
+    this.shufflingCache.processState(postBlockState);
     this.logger.verbose("Processed shuffling for next epoch", {parentEpoch, blockEpoch, slot: blockSlot});
   }
 
   if (blockSlot % SLOTS_PER_EPOCH === 0) {
     // Cache state to preserve epoch transition work
-    const checkpointState = postState;
+    const checkpointState = postBlockState;
     const cp = getCheckpointFromState(checkpointState);
     this.regen.addCheckpointState(cp, checkpointState, payloadPresent);
     // consumers should not mutate state ever
@@ -584,7 +601,7 @@ export async function importBlock(
     this.validatorMonitor?.registerSyncAggregateInBlock(
       blockEpoch,
       (block as altair.SignedBeaconBlock).message.body.syncAggregate,
-      fullyVerifiedBlock.postState.currentSyncCommitteeIndexed.validatorIndices
+      fullyVerifiedBlock.postBlockState.currentSyncCommitteeIndexed.validatorIndices
     );
   }
 

packages/beacon-node/src/chain/blocks/index.ts

@@ -87,6 +87,7 @@ export async function processBlocks(
       proposerBalanceDeltas,
       segmentExecStatus,
       indexedAttestationsByBlock,
+      postEnvelopeStates,
     } = await verifyBlocksInEpoch.call(this, parentBlock, relevantBlocks, envelopes, opts);
 
     // If segmentExecStatus has lvhForkchoice then, the entire segment should be invalid
@@ -102,7 +103,8 @@ export async function processBlocks(
     const fullyVerifiedBlocks = relevantBlocks.map(
       (block, i): FullyVerifiedBlock => ({
         blockInput: block,
-        postState: postBlockStates[i],
+        postBlockState: postBlockStates[i],
+        postEnvelopeState: postEnvelopeStates.get(block.getBlock().message.slot) ?? null,
         parentBlockSlot: parentSlots[i],
         executionStatus: executionStatuses[i],
         // start supporting optimistic syncing/processing

packages/beacon-node/src/chain/blocks/types.ts

@@ -93,7 +93,8 @@ export type ImportBlockOpts = {
  */
 export type FullyVerifiedBlock = {
   blockInput: IBlockInput;
-  postState: IBeaconStateView;
+  postBlockState: IBeaconStateView;
+  postEnvelopeState: IBeaconStateView | null;
   parentBlockSlot: Slot;
   proposerBalanceDelta: number;
   /**