@lodestar/beacon-node 1.49.0-dev.fa4ae94ccc → 1.49.0-rc.0

package/lib/util/headerEnvelope.js

@@ -0,0 +1,43 @@
+import { ssz } from "@lodestar/types";
+import { toRootHex } from "@lodestar/utils";
+import { EnvelopeReconstructionError, EnvelopeReconstructionErrorCode, } from "../chain/errors/envelopeReconstructionError.js";
+const { transactions, withdrawals, blockAccessList } = ssz.gloas.ExecutionPayload.fields;
+/** Replace the three body lists by their roots; hashes to the same root as the full envelope */
+export function toHeaderEnvelope(envelope) {
+    const { payload, ...envelopeFields } = envelope;
+    const { transactions: txs, withdrawals: wds, blockAccessList: bal, ...scalars } = payload;
+    return {
+        ...envelopeFields,
+        payloadHeader: {
+            ...scalars,
+            transactionsRoot: transactions.hashTreeRoot(txs),
+            withdrawalsRoot: withdrawals.hashTreeRoot(wds),
+            blockAccessListRoot: blockAccessList.hashTreeRoot(bal),
+        },
+    };
+}
+export function toSignedHeaderEnvelope(envelope) {
+    return { message: toHeaderEnvelope(envelope.message), signature: envelope.signature };
+}
+/**
+ * Rebuild the full signed envelope from header envelope + EL bodies, each body verified against its stored
+ * root. Throws {@link EnvelopeReconstructionError} BODY_ROOT_MISMATCH naming the first body that differs.
+ */
+export function signedHeaderEnvelopeToFull(headerEnvelope, bodies) {
+    const { payloadHeader, ...envelopeFields } = headerEnvelope.message;
+    const { transactionsRoot, withdrawalsRoot, blockAccessListRoot, ...scalars } = payloadHeader;
+    const slot = scalars.slotNumber;
+    assertBodyRoot("transactions", slot, transactionsRoot, transactions.hashTreeRoot(bodies.transactions));
+    assertBodyRoot("withdrawals", slot, withdrawalsRoot, withdrawals.hashTreeRoot(bodies.withdrawals));
+    assertBodyRoot("blockAccessList", slot, blockAccessListRoot, blockAccessList.hashTreeRoot(bodies.blockAccessList));
+    return {
+        message: { ...envelopeFields, payload: { ...scalars, ...bodies } },
+        signature: headerEnvelope.signature,
+    };
+}
+function assertBodyRoot(field, slot, stored, rebuilt) {
+    if (!ssz.Root.equals(stored, rebuilt)) {
+        throw new EnvelopeReconstructionError({ code: EnvelopeReconstructionErrorCode.BODY_ROOT_MISMATCH, slot, field }, `reconstructed ${field} root mismatch slot=${slot} stored=${toRootHex(stored)} rebuilt=${toRootHex(rebuilt)}`);
+    }
+}
+//# sourceMappingURL=headerEnvelope.js.map

package/lib/util/headerEnvelope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"headerEnvelope.js","sourceRoot":"","sources":["../../src/util/headerEnvelope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAC,MAAM,iBAAiB,CAAC;AAUpC,OAAO,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EACL,2BAA2B,EAC3B,+BAA+B,GAChC,MAAM,gDAAgD,CAAC;AAWxD,MAAM,EAAC,YAAY,EAAE,WAAW,EAAE,eAAe,EAAC,GAAG,GAAG,CAAC,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC;AAEvF,gGAAgG;AAChG,MAAM,UAAU,gBAAgB,CAAC,QAAkC;IACjE,MAAM,EAAC,OAAO,EAAE,GAAG,cAAc,EAAC,GAAG,QAAQ,CAAC;IAC9C,MAAM,EAAC,YAAY,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,GAAG,OAAO,EAAC,GAAG,OAAO,CAAC;IACxF,OAAO;QACL,GAAG,cAAc;QACjB,aAAa,EAAE;YACb,GAAG,OAAO;YACV,gBAAgB,EAAE,YAAY,CAAC,YAAY,CAAC,GAAG,CAAC;YAChD,eAAe,EAAE,WAAW,CAAC,YAAY,CAAC,GAAG,CAAC;YAC9C,mBAAmB,EAAE,eAAe,CAAC,YAAY,CAAC,GAAG,CAAC;SACvD;KACF,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,QAAwC;IAC7E,OAAO,EAAC,OAAO,EAAE,gBAAgB,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,EAAE,QAAQ,CAAC,SAAS,EAAC,CAAC;AACtF,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,0BAA0B,CACxC,cAAoD,EACpD,MAA8B;IAE9B,MAAM,EAAC,aAAa,EAAE,GAAG,cAAc,EAAC,GAAG,cAAc,CAAC,OAAO,CAAC;IAClE,MAAM,EAAC,gBAAgB,EAAE,eAAe,EAAE,mBAAmB,EAAE,GAAG,OAAO,EAAC,GAAG,aAAa,CAAC;IAC3F,MAAM,IAAI,GAAG,OAAO,CAAC,UAAU,CAAC;IAEhC,cAAc,CAAC,cAAc,EAAE,IAAI,EAAE,gBAAgB,EAAE,YAAY,CAAC,YAAY,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;IACvG,cAAc,CAAC,aAAa,EAAE,IAAI,EAAE,eAAe,EAAE,WAAW,CAAC,YAAY,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC;IACnG,cAAc,CAAC,iBAAiB,EAAE,IAAI,EAAE,mBAAmB,EAAE,eAAe,CAAC,YAAY,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC;IAEnH,OAAO;QACL,OAAO,EAAE,EAAC,GAAG,cAAc,EAAE,OAAO,EAAE,EAAC,GAAG,OAAO,EAAE,GAAG,MAAM,EAAC,EAAC;QAC9D,SAAS,EAAE,cAAc,CAAC,SAAS;KACpC,CAAC;AACJ,CAAC;AAED,SAAS,cAAc,CAAC,KAAgC,EAAE,IAAY,EAAE,MAAkB,EAAE,OAAmB;IAC7G,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,2BAA2B,CACnC,EAAC,IAAI,EAAE,+BAA+B,CAAC,kBAAkB,EAAE,IAAI,EAAE,KAAK,EAAC,EACvE,iBAAiB,KAAK,uBAAuB,IAAI,WAAW,SAAS,CAAC,MAAM,CAAC,YAAY,SAAS,CAAC,OAAO,CAAC,EAAE,CAC9G,CAAC;IACJ,CAAC;AACH,CAAC"}

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.49.0-dev.fa4ae94ccc",
+  "version": "1.49.0-rc.0",
   "type": "module",
   "exports": {
     ".": {
@@ -118,7 +118,7 @@
     "@fastify/swagger-ui": "^5.0.1",
     "@libp2p/bootstrap": "^12.0.30",
     "@libp2p/crypto": "^5.1.23",
-    "@libp2p/gossipsub": "^17.1.0",
+    "@libp2p/gossipsub": "^17.1.2",
     "@libp2p/identify": "^4.1.13",
     "@libp2p/interface": "^3.3.0",
     "@libp2p/mdns": "^12.0.30",
@@ -127,17 +127,17 @@
     "@libp2p/prometheus-metrics": "^5.0.28",
     "@libp2p/tcp": "^11.0.27",
     "@libp2p/utils": "^7.4.0",
-    "@lodestar/api": "^1.49.0-dev.fa4ae94ccc",
-    "@lodestar/config": "^1.49.0-dev.fa4ae94ccc",
-    "@lodestar/db": "^1.49.0-dev.fa4ae94ccc",
-    "@lodestar/fork-choice": "^1.49.0-dev.fa4ae94ccc",
-    "@lodestar/logger": "^1.49.0-dev.fa4ae94ccc",
-    "@lodestar/params": "^1.49.0-dev.fa4ae94ccc",
-    "@lodestar/reqresp": "^1.49.0-dev.fa4ae94ccc",
-    "@lodestar/state-transition": "^1.49.0-dev.fa4ae94ccc",
-    "@lodestar/types": "^1.49.0-dev.fa4ae94ccc",
-    "@lodestar/utils": "^1.49.0-dev.fa4ae94ccc",
-    "@lodestar/validator": "^1.49.0-dev.fa4ae94ccc",
+    "@lodestar/api": "^1.49.0-rc.0",
+    "@lodestar/config": "^1.49.0-rc.0",
+    "@lodestar/db": "^1.49.0-rc.0",
+    "@lodestar/fork-choice": "^1.49.0-rc.0",
+    "@lodestar/logger": "^1.49.0-rc.0",
+    "@lodestar/params": "^1.49.0-rc.0",
+    "@lodestar/reqresp": "^1.49.0-rc.0",
+    "@lodestar/state-transition": "^1.49.0-rc.0",
+    "@lodestar/types": "^1.49.0-rc.0",
+    "@lodestar/utils": "^1.49.0-rc.0",
+    "@lodestar/validator": "^1.49.0-rc.0",
     "@multiformats/multiaddr": "^13.0.1",
     "datastore-core": "^12.0.1",
     "datastore-level": "^13.0.1",
@@ -156,10 +156,10 @@
     "xxhash-wasm": "1.0.2"
   },
   "devDependencies": {
-    "@chainsafe/swap-or-not-shuffle": "^1.2.1",
     "@libp2p/interface-internal": "^3.1.12",
     "@libp2p/logger": "^6.2.13",
-    "@lodestar/spec-test-util": "^1.49.0-dev.fa4ae94ccc",
+    "@lodestar/spec-test-util": "^1.49.0-rc.0",
+    "@lodestar/test-utils": "^1.49.0-rc.0",
     "@types/js-yaml": "^4.0.5",
     "@types/qs": "^6.9.7",
     "@types/tmp": "^0.2.3",
@@ -174,5 +174,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "e10255395ab353d2988995cd2db9b08ca0eecc4c"
+  "gitHead": "72d434162a8e245786d7ff64b86289a29e2a4769"
 }

package/src/api/impl/beacon/blocks/index.ts

@@ -47,6 +47,8 @@ import {
   BlockError,
   BlockErrorCode,
   BlockGossipError,
+  EnvelopeReconstructionError,
+  EnvelopeReconstructionErrorCode,
   ExecutionPayloadEnvelopeError,
   ExecutionPayloadEnvelopeErrorCode,
 } from "../../../../chain/errors/index.js";
@@ -1109,9 +1111,20 @@ export function getBeaconBlockApi({
       const blockRoot = config.getForkTypes(slot).BeaconBlock.hashTreeRoot(block.message);
       const blockRootHex = toRootHex(blockRoot);
 
-      const data = context?.returnBytes
-        ? await chain.getSerializedExecutionPayloadEnvelope(slot, blockRootHex)
-        : await chain.getExecutionPayloadEnvelope(slot, blockRootHex);
+      let data: Uint8Array | gloas.SignedExecutionPayloadEnvelope | null;
+      try {
+        data = context?.returnBytes
+          ? await chain.getSerializedExecutionPayloadEnvelope(slot, blockRootHex)
+          : await chain.getExecutionPayloadEnvelope(slot, blockRootHex);
+      } catch (e) {
+        if (e instanceof EnvelopeReconstructionError) {
+          throw new ApiError(
+            e.type.code === EnvelopeReconstructionErrorCode.ENGINE_UNAVAILABLE ? 503 : 500,
+            `Failed to reconstruct execution payload envelope: ${e.message}`
+          );
+        }
+        throw e;
+      }
 
       if (!data) {
         throw new ApiError(404, `Execution payload envelope not found for slot=${slot}, blockRoot=${blockRootHex}`);

package/src/chain/archiveStore/archiveStore.ts

@@ -103,7 +103,7 @@ export class ArchiveStore {
     if (this.opts.pruneHistory) {
       // prune ALL stale data before starting
       this.logger.info("Pruning historical data");
-      await callFnWhenAwait(
+      const blockCutoffSlot = await callFnWhenAwait(
         pruneHistory(
           this.chain.config,
           this.db,
@@ -116,6 +116,7 @@ export class ArchiveStore {
         30_000,
         this.signal
       );
+      this.chain.earliestAvailableSlot = Math.max(this.chain.earliestAvailableSlot, blockCutoffSlot);
     }
 
     if (this.opts.serveHistoricalState) {
@@ -228,13 +229,14 @@ export class ArchiveStore {
         isNodeSynced,
         this.archiveDataEpochs,
         this.chain.opts.persistOrphanedBlocks,
-        this.chain.opts.persistOrphanedBlocksDir
+        this.chain.opts.persistOrphanedBlocksDir,
+        this.chain.opts.dedupePayloads
       );
       timer?.({source: ArchiveStoreTask.ArchiveBlocks});
 
       if (this.opts.pruneHistory) {
         timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
-        await pruneHistory(
+        const blockCutoffSlot = await pruneHistory(
           this.chain.config,
           this.db,
           this.logger,
@@ -242,6 +244,7 @@ export class ArchiveStore {
           finalizedEpoch,
           this.chain.clock.currentEpoch
         );
+        this.chain.earliestAvailableSlot = Math.max(this.chain.earliestAvailableSlot, blockCutoffSlot);
         timer?.({source: ArchiveStoreTask.PruneHistory});
       }
 

package/src/chain/archiveStore/historicalState/metrics.ts

@@ -156,9 +156,10 @@ export function createHistoricalStateTransitionMetrics(
       name: "lodestar_historical_state_stfn_attestations_per_block_total",
       help: "Count of attestations per block",
     }),
-    progressiveBalancesMismatches: metricsRegister.counter({
+    progressiveBalancesMismatches: metricsRegister.counter<{target: "current" | "previous"}>({
       name: "lodestar_historical_state_stfn_progressive_balances_mismatches_total",
-      help: "Total count of progressive balance cache mismatches",
+      help: "Total count of progressive balance cache mismatches by target balance",
+      labelNames: ["target"],
     }),
     proposerRewards: metricsRegister.gauge<{type: ProposerRewardType}>({
       name: "lodestar_historical_state_stfn_proposer_rewards_total",

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

@@ -1,15 +1,16 @@
 import path from "node:path";
 import {ChainForkConfig} from "@lodestar/config";
 import {KeyValue} from "@lodestar/db";
-import {CheckpointWithHex, IForkChoice, PayloadStatus, ProtoBlock} from "@lodestar/fork-choice";
+import {CheckpointWithHex, ExecutionStatus, IForkChoice, PayloadStatus, ProtoBlock} from "@lodestar/fork-choice";
 import {ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {computeEpochAtSlot, computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {Epoch, Slot} from "@lodestar/types";
 import {Logger, fromAsync, fromHex, prettyPrintIndices, toRootHex} from "@lodestar/utils";
 import {IBeaconDb} from "../../../db/index.js";
-import {BlockArchiveBatchPutBinaryItem} from "../../../db/repositories/index.js";
+import {BlockArchiveBatchPutBinaryItem, encodeArchivedHeaderEnvelope} from "../../../db/repositories/index.js";
 import {Metrics} from "../../../metrics/metrics.js";
 import {ensureDir, writeIfNotExist} from "../../../util/file.js";
+import {toSignedHeaderEnvelope} from "../../../util/headerEnvelope.js";
 import {BlockRootHex} from "../../../util/sszBytes.js";
 import {LightClientServer} from "../../lightClient/index.js";
 
@@ -69,7 +70,8 @@ export async function archiveBlocks(
   isNodeSynced: boolean,
   archiveDataEpochs?: number,
   persistOrphanedBlocks?: boolean,
-  persistOrphanedBlocksDir?: string
+  persistOrphanedBlocksDir?: string,
+  dedupePayloads = true
 ): Promise<void> {
   // Use fork choice to determine the blocks to archive and delete.
   // `ancestors` is the canonical walk back from the finalized root, including the previous finalized
@@ -156,7 +158,8 @@ export async function archiveBlocks(
         config,
         db,
         logger,
-        finalizedCanonicalBlocks
+        finalizedCanonicalBlocks,
+        dedupePayloads
       );
       logger.verbose("Migrated executionPayloadEnvelopes from hot DB to cold DB", {
         ...logCtx,
@@ -475,49 +478,68 @@ async function migrateDataColumnSidecarsFromHotToColdDb(
 /**
  * Post-gloas given a finalized checkpoint at a block root, payload of that block root
  * is not considered finalized, hence they are archived in the next run.
+ *
+ * With `dedupePayloads` (default), execution-valid envelopes are archived as header envelopes. Envelopes of
+ * still-optimistic blocks are archived in full, since the EL may not serve their bodies, and are not
+ * converted later. Archive put + hot delete are one atomic db batch.
  */
-async function migrateExecutionPayloadEnvelopesFromHotToColdDb(
+export async function migrateExecutionPayloadEnvelopesFromHotToColdDb(
   config: ChainForkConfig,
   db: IBeaconDb,
   logger: Logger,
-  canonicalBlocks: ProtoBlock[]
+  canonicalBlocks: ProtoBlock[],
+  dedupePayloads: boolean
 ): Promise<Slot[]> {
   const payloadBlocks = canonicalBlocks.filter(
-    (block) => config.getForkSeq(block.slot) < ForkSeq.gloas || block.payloadStatus === PayloadStatus.FULL
+    (block) => config.getForkSeq(block.slot) >= ForkSeq.gloas && block.payloadStatus === PayloadStatus.FULL
   );
   if (payloadBlocks.length === 0) return [];
-  const blocks = payloadBlocks.map((block) => ({slot: block.slot, root: fromHex(block.blockRoot)}));
 
-  const envelopeEntries: KeyValue<Slot, Uint8Array>[] = [];
-  const migratedRoots: Uint8Array[] = [];
+  const migratedSlots: Slot[] = [];
 
-  const envelopeBytesArray = await Promise.all(
-    blocks.map((block) => db.executionPayloadEnvelope.getBinary(block.root))
-  );
+  // Process in chunks to bound memory: after a long non-finality period the ancestor walk can span
+  // thousands of blocks, and each full envelope is a few hundred KB when deserialized.
+  for (let i = 0; i < payloadBlocks.length; i += BLOCK_BATCH_SIZE) {
+    const batch = payloadBlocks.slice(i, i + BLOCK_BATCH_SIZE);
+    // Only header envelopes need deserializing; full ones are copied as bytes
+    const archivedBytesArray = await Promise.all(
+      batch.map(async (block) => {
+        const root = fromHex(block.blockRoot);
+        if (dedupePayloads && block.executionStatus === ExecutionStatus.Valid) {
+          const envelope = await db.executionPayloadEnvelope.get(root);
+          return envelope === null ? null : encodeArchivedHeaderEnvelope(toSignedHeaderEnvelope(envelope));
+        }
+        return db.executionPayloadEnvelope.getBinary(root);
+      })
+    );
+
+    const entries: {slot: Slot; archivedBytes: Uint8Array; hotKey: Uint8Array}[] = [];
+    for (let j = 0; j < batch.length; j++) {
+      const block = batch[j];
+      const archivedBytes = archivedBytesArray[j];
+      if (archivedBytes === null) {
+        logger.debug("ExecutionPayloadEnvelope in forkchoice but missing in hot db, could be already archived", {
+          slot: block.slot,
+          root: block.blockRoot,
+        });
+        continue;
+      }
 
-  for (let i = 0; i < blocks.length; i++) {
-    const bytes = envelopeBytesArray[i];
-    if (bytes !== null) {
-      envelopeEntries.push({key: blocks[i].slot, value: bytes});
-      migratedRoots.push(blocks[i].root);
-    } else {
-      logger.debug("ExecutionPayloadEnvelope in forkchoice but missing in hot db, could be already archived", {
-        slot: blocks[i].slot,
-        root: toRootHex(blocks[i].root),
+      entries.push({
+        slot: block.slot,
+        archivedBytes,
+        hotKey: db.executionPayloadEnvelope.encodeKey(fromHex(block.blockRoot)),
       });
+      migratedSlots.push(block.slot);
     }
-  }
 
-  if (envelopeEntries.length === 0) return [];
-
-  await Promise.all([
-    db.executionPayloadEnvelopeArchive.batchPutBinary(envelopeEntries),
-    db.executionPayloadEnvelope.batchDelete(migratedRoots),
-  ]);
+    if (entries.length > 0) {
+      await db.executionPayloadEnvelopeArchive.batchArchiveAndDeleteHot(entries);
+    }
+  }
 
-  // Slots are ascending in hot-db key order — sort to guarantee `prettyPrintIndices` output is clean
-  // regardless of ancestor-walk order (newest to oldest).
-  return envelopeEntries.map((entry) => entry.key).sort((a, b) => a - b);
+  // Ancestor walk is newest to oldest; sort ascending so `prettyPrintIndices` renders cleanly.
+  return migratedSlots.sort((a, b) => a - b);
 }
 
 /**

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

@@ -1,6 +1,6 @@
 import {ChainConfig} from "@lodestar/config";
 import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {Epoch} from "@lodestar/types";
+import {Epoch, Slot} from "@lodestar/types";
 import {Logger, prettyPrintIndices} from "@lodestar/utils";
 import {IBeaconDb} from "../../../db/interface.js";
 import {Metrics} from "../../../metrics/index.js";
@@ -12,7 +12,7 @@ export async function pruneHistory(
   metrics: Metrics | null | undefined,
   finalizedEpoch: Epoch,
   currentEpoch: Epoch
-): Promise<void> {
+): Promise<Slot> {
   const blockCutoffEpoch = Math.min(
     // set by config, with underflow protection
     Math.max(currentEpoch - config.MIN_EPOCHS_FOR_BLOCK_REQUESTS, 0),
@@ -63,4 +63,6 @@ export async function pruneHistory(
   });
 
   metrics?.pruneHistory.pruneCount.inc();
+
+  return blockCutoffSlot;
 }

package/src/chain/blocks/importExecutionPayload.ts

@@ -12,6 +12,7 @@ import {isQueueErrorAborted} from "../../util/queue/index.js";
 import {BeaconChain} from "../chain.js";
 import {RegenCaller} from "../regen/interface.js";
 import {PayloadEnvelopeInput} from "../seenCache/seenPayloadEnvelopeInput.js";
+import {PayloadEnvelopeInputSource} from "./payloadEnvelopeInput/index.js";
 import {ImportPayloadOpts} from "./types.js";
 import {
   verifyExecutionPayloadEnvelope,
@@ -172,6 +173,9 @@ export async function importExecutionPayload(
   }
 
   // 4a. Run EL and signature verification in parallel
+  const logCtx = {slot, root: blockRootHex, executionBlock: envelope.payload.blockNumber};
+  this.logger.debug("Call engine api newPayload", logCtx);
+  const verifyStartSec = Date.now() / 1000;
   const [execResult, signatureValid] = await Promise.all([
     this.executionEngine.notifyNewPayload(
       fork,
@@ -191,6 +195,8 @@ export async function importExecutionPayload(
           this.bls
         ),
   ]);
+  this.logger.debug("Receive engine api newPayload result", {...logCtx, status: execResult.status});
+  this.metrics?.engineNotifyNewPayloadResult.inc({result: execResult.status});
 
   // 4b. Check signature verification result
   if (!signatureValid) {
@@ -223,6 +229,14 @@ export async function importExecutionPayload(
       });
   }
 
+  const {source, seenTimestampSec} = payloadInput.getPayloadEnvelopeSource();
+  if (execResult.status === ExecutionPayloadStatus.VALID && source === PayloadEnvelopeInputSource.gossip) {
+    const nowSec = Date.now() / 1000;
+    this.metrics?.gossipExecutionPayloadEnvelope.executionPayload.recvToValidation.observe(nowSec - seenTimestampSec);
+    // same metric as pre-gloas, it tracks EL verification time regardless of fork
+    this.metrics?.gossipBlock.executionPayload.validationTime.observe(nowSec - verifyStartSec);
+  }
+
   // 5. Persist payload envelope to hot DB. Wait for write-queue space here to apply backpressure
   // on the import pipeline during sync, then perform the write asynchronously to avoid blocking.
   await this.unfinalizedPayloadEnvelopeWrites.waitForSpace();

package/src/chain/chain.ts

@@ -61,6 +61,7 @@ import {ProcessShutdownCallback} from "@lodestar/validator";
 import {GENESIS_EPOCH, ZERO_HASH} from "../constants/index.js";
 import {IBeaconDb} from "../db/index.js";
 import {BLOB_SIDECARS_IN_WRAPPER_INDEX} from "../db/repositories/blobSidecars.js";
+import {decodeArchivedEnvelope} from "../db/repositories/index.js";
 import {BuilderApiClient, BuilderApiClientOpts} from "../execution/builder/apiClient.js";
 import {BuilderStatus} from "../execution/builder/http.js";
 import {IExecutionBuilder, IExecutionEngine} from "../execution/index.js";
@@ -70,6 +71,7 @@ import {BufferPool} from "../util/bufferPool.js";
 import {Clock, ClockEvent, IClock} from "../util/clock.js";
 import {CustodyConfig, getValidatorsCustodyRequirement} from "../util/dataColumns.js";
 import {callInNextEventLoop} from "../util/eventLoop.js";
+import {ReconstructMismatchPolicy, isRebuildMiss, reconstructExecutionPayloadEnvelopes} from "../util/execution.js";
 import {ensureDir, writeIfNotExist} from "../util/file.js";
 import {isOptimisticBlock} from "../util/forkChoice.js";
 import {JobItemQueue} from "../util/queue/itemQueue.js";
@@ -926,21 +928,71 @@ export class BeaconChain implements IBeaconChain {
   }
 
   async getSerializedExecutionPayloadEnvelope(blockSlot: Slot, blockRootHex: string): Promise<Uint8Array | null> {
-    const payloadInput = this.seenPayloadEnvelopeInputCache.get(blockRootHex);
-    if (payloadInput?.hasPayloadEnvelope()) {
-      const envelope = payloadInput.getPayloadEnvelope();
-      const serialized = this.serializedCache.get(envelope);
-      if (serialized) {
-        return serialized;
+    const [bytes] = await this.getSerializedExecutionPayloadEnvelopes([{blockSlot, blockRootHex}]);
+    return bytes;
+  }
+
+  /**
+   * Batch variant: archived header envelopes are rebuilt 32 per EL round-trip. Aligned with `requests`.
+   * A body root mismatch is a local inconsistency: `"throw"` surfaces it, `"omit"` logs it and
+   * returns null for that entry, for peer-facing paths where the spec allows omission.
+   */
+  async getSerializedExecutionPayloadEnvelopes(
+    requests: {blockSlot: Slot; blockRootHex: RootHex}[],
+    onMismatch: ReconstructMismatchPolicy = "throw"
+  ): Promise<(Uint8Array | null)[]> {
+    const out: (Uint8Array | null)[] = new Array(requests.length).fill(null);
+    const headerEnvelopes: gloas.SignedExecutionPayloadHeaderEnvelope[] = [];
+    const headerEnvelopeIdxs: number[] = [];
+
+    for (let i = 0; i < requests.length; i++) {
+      const {blockSlot, blockRootHex} = requests[i];
+
+      const payloadInput = this.seenPayloadEnvelopeInputCache.get(blockRootHex);
+      if (payloadInput?.hasPayloadEnvelope()) {
+        const envelope = payloadInput.getPayloadEnvelope();
+        out[i] = this.serializedCache.get(envelope) ?? ssz.gloas.SignedExecutionPayloadEnvelope.serialize(envelope);
+        continue;
+      }
+
+      const hot = await this.db.executionPayloadEnvelope.getBinary(fromHex(blockRootHex));
+      if (hot !== null) {
+        out[i] = hot;
+        continue;
+      }
+
+      const archivedBytes = await this.db.executionPayloadEnvelopeArchive.getBinary(blockSlot);
+      if (archivedBytes === null) continue;
+
+      const archived = decodeArchivedEnvelope(archivedBytes);
+      if (archived.envelopeBytes !== undefined) {
+        out[i] = archived.envelopeBytes;
+        continue;
+      }
+      headerEnvelopes.push(archived.headerEnvelope);
+      headerEnvelopeIdxs.push(i);
+    }
+
+    if (headerEnvelopes.length > 0) {
+      const rebuilt = await reconstructExecutionPayloadEnvelopes(this.executionEngine, this.metrics, headerEnvelopes);
+      for (let j = 0; j < rebuilt.length; j++) {
+        const result = rebuilt[j];
+        if (isRebuildMiss(result)) {
+          if (result.reason === "mismatch") {
+            if (onMismatch === "throw") throw result.error;
+            this.logger.debug(
+              "Archived envelope failed body root check against EL bodies",
+              {slot: result.slot},
+              result.error
+            );
+          }
+          continue;
+        }
+        out[headerEnvelopeIdxs[j]] = ssz.gloas.SignedExecutionPayloadEnvelope.serialize(result);
       }
-      return ssz.gloas.SignedExecutionPayloadEnvelope.serialize(envelope);
     }
 
-    return (
-      (await this.db.executionPayloadEnvelope.getBinary(fromHex(blockRootHex))) ??
-      (await this.db.executionPayloadEnvelopeArchive.getBinary(blockSlot)) ??
-      null
-    );
+    return out;
   }
 
   async getExecutionPayloadEnvelope(
@@ -952,11 +1004,23 @@ export class BeaconChain implements IBeaconChain {
       return payloadInput.getPayloadEnvelope();
     }
 
-    return (
-      (await this.db.executionPayloadEnvelope.get(fromHex(blockRootHex))) ??
-      (await this.db.executionPayloadEnvelopeArchive.get(blockSlot)) ??
-      null
-    );
+    const hot = await this.db.executionPayloadEnvelope.get(fromHex(blockRootHex));
+    if (hot !== null) return hot;
+
+    const archivedBytes = await this.db.executionPayloadEnvelopeArchive.getBinary(blockSlot);
+    if (archivedBytes === null) return null;
+    const archived = decodeArchivedEnvelope(archivedBytes);
+    if (archived.envelopeBytes !== undefined) {
+      return ssz.gloas.SignedExecutionPayloadEnvelope.deserialize(archived.envelopeBytes);
+    }
+    const [result] = await reconstructExecutionPayloadEnvelopes(this.executionEngine, this.metrics, [
+      archived.headerEnvelope,
+    ]);
+    if (isRebuildMiss(result)) {
+      if (result.reason === "mismatch") throw result.error;
+      return null;
+    }
+    return result;
   }
 
   async getParentExecutionRequests(
@@ -967,11 +1031,23 @@ export class BeaconChain implements IBeaconChain {
     if (!isForkPostGloas(this.config.getForkName(parentBlockSlot))) {
       return ssz.gloas.ExecutionRequests.defaultValue();
     }
-    const envelope = await this.getExecutionPayloadEnvelope(parentBlockSlot, parentBlockRootHex);
-    if (envelope === null) {
+    // executionRequests is kept in the header envelope, so read it without reconstructing
+    const payloadInput = this.seenPayloadEnvelopeInputCache.get(parentBlockRootHex);
+    if (payloadInput?.hasPayloadEnvelope()) {
+      return payloadInput.getPayloadEnvelope().message.executionRequests;
+    }
+
+    const hot = await this.db.executionPayloadEnvelope.get(fromHex(parentBlockRootHex));
+    if (hot !== null) return hot.message.executionRequests;
+
+    const archivedBytes = await this.db.executionPayloadEnvelopeArchive.getBinary(parentBlockSlot);
+    if (archivedBytes === null) {
       throw Error(`Parent execution payload envelope not found slot=${parentBlockSlot}, root=${parentBlockRootHex}`);
     }
-    return envelope.message.executionRequests;
+    const archived = decodeArchivedEnvelope(archivedBytes);
+    return archived.envelopeBytes !== undefined
+      ? ssz.gloas.SignedExecutionPayloadEnvelope.deserialize(archived.envelopeBytes).message.executionRequests
+      : archived.headerEnvelope.message.executionRequests;
   }
 
   async getDataColumnSidecars(blockSlot: Slot, blockRootHex: string): Promise<DataColumnSidecar[]> {

package/src/chain/errors/envelopeReconstructionError.ts

@@ -0,0 +1,22 @@
+import {Slot} from "@lodestar/types";
+import {LodestarError} from "@lodestar/utils";
+
+export enum EnvelopeReconstructionErrorCode {
+  /** The EL failed to answer engine_getPayloadBodiesByHashV2 (transport / EL down). Transient. */
+  ENGINE_UNAVAILABLE = "ENVELOPE_RECONSTRUCTION_ERROR_ENGINE_UNAVAILABLE",
+  /** A body returned by the EL does not hash to the root stored in the header envelope. Local DB/EL inconsistency. */
+  BODY_ROOT_MISMATCH = "ENVELOPE_RECONSTRUCTION_ERROR_BODY_ROOT_MISMATCH",
+  /** A by-range stream stopped short at a slot that cannot be served; the response so far is still valid */
+  RANGE_UNSERVABLE = "ENVELOPE_RECONSTRUCTION_ERROR_RANGE_UNSERVABLE",
+}
+
+export type EnvelopeReconstructionErrorType =
+  | {code: EnvelopeReconstructionErrorCode.ENGINE_UNAVAILABLE}
+  | {
+      code: EnvelopeReconstructionErrorCode.BODY_ROOT_MISMATCH;
+      slot: Slot;
+      field: "transactions" | "withdrawals" | "blockAccessList";
+    }
+  | {code: EnvelopeReconstructionErrorCode.RANGE_UNSERVABLE; slot: Slot};
+
+export class EnvelopeReconstructionError extends LodestarError<EnvelopeReconstructionErrorType> {}

package/src/chain/errors/index.ts

@@ -4,6 +4,7 @@ export * from "./blobSidecarError.js";
 export * from "./blockError.js";
 export * from "./blsToExecutionChangeError.js";
 export * from "./dataColumnSidecarError.js";
+export * from "./envelopeReconstructionError.js";
 export * from "./executionPayloadBid.js";
 export * from "./executionPayloadEnvelope.js";
 export * from "./gossipValidation.js";

package/src/chain/interface.ts

@@ -30,6 +30,7 @@ import {Metrics} from "../metrics/metrics.js";
 import {BufferPool} from "../util/bufferPool.js";
 import {IClock} from "../util/clock.js";
 import {CustodyConfig} from "../util/dataColumns.js";
+import {ReconstructMismatchPolicy} from "../util/execution.js";
 import {SerializedCache} from "../util/serializedCache.js";
 import {IArchiveStore} from "./archiveStore/interface.js";
 import {CheckpointBalancesCache} from "./balancesCache.js";
@@ -96,7 +97,7 @@ export enum FindHeadFnName {
 export interface IBeaconChain {
   readonly genesisTime: UintNum64;
   readonly genesisValidatorsRoot: Root;
-  readonly earliestAvailableSlot: Slot;
+  earliestAvailableSlot: Slot;
   readonly executionEngine: IExecutionEngine;
   readonly executionBuilder?: IExecutionBuilder;
   readonly builderCircuitBreaker: BuilderCircuitBreaker;
@@ -236,6 +237,10 @@ export interface IBeaconChain {
     indices: number[]
   ): Promise<(Uint8Array | undefined)[]>;
   getSerializedExecutionPayloadEnvelope(blockSlot: Slot, blockRootHex: string): Promise<Uint8Array | null>;
+  getSerializedExecutionPayloadEnvelopes(
+    requests: {blockSlot: Slot; blockRootHex: RootHex}[],
+    onMismatch?: ReconstructMismatchPolicy
+  ): Promise<(Uint8Array | null)[]>;
   getExecutionPayloadEnvelope(
     blockSlot: Slot,
     blockRootHex: string

package/src/chain/options.ts

@@ -29,6 +29,8 @@ export type IChainOptions = BlockProcessOpts &
     blacklistedBlocks?: string[];
     // TODO GLOAS: add similar option for execution payload envelopes?
     persistProducedBlocks?: boolean;
+    /** Archive finalized Gloas payload envelopes as headers (bodies reconstructed from the EL on read) */
+    dedupePayloads?: boolean;
     persistInvalidSszObjects?: boolean;
     persistInvalidSszObjectsDir?: string;
     persistOrphanedBlocks?: boolean;
@@ -105,6 +107,7 @@ export const defaultChainOptions: IChainOptions = {
   disableBlsBatchVerify: false,
   proposerBoost: true,
   proposerBoostReorg: true,
+  dedupePayloads: true,
   computeUnrealized: true,
   fastConfirmation: false,
   suggestedFeeRecipient: defaultValidatorOptions.suggestedFeeRecipient,

package/src/db/buckets.ts

@@ -71,7 +71,7 @@ export enum Bucket {
   allForks_dataColumnSidecarsArchive = 58, // BeaconBlockSlot -> DataColumnSidecars
 
   gloas_executionPayloadEnvelope = 59, // GLOAS BeaconBlockRoot -> SignedExecutionPayloadEnvelope
-  gloas_executionPayloadEnvelopeArchive = 60, // GLOAS Slot -> SignedExecutionPayloadEnvelope
+  gloas_executionPayloadEnvelopeArchive = 60, // GLOAS Slot -> SignedExecutionPayloadEnvelope, or 0x00 + SignedExecutionPayloadHeaderEnvelope
 }
 
 export function getBucketNameByValue<T extends Bucket>(enumValue: T): keyof typeof Bucket {