@lodestar/beacon-node 1.39.1 → 1.40.0-dev.059f489b0f

package/lib/chain/chain.js

@@ -2,21 +2,27 @@ import path from "node:path";
 import { UpdateHeadOpt } from "@lodestar/fork-choice";
 import { EFFECTIVE_BALANCE_INCREMENT, GENESIS_SLOT, SLOTS_PER_EPOCH, isForkPostElectra } from "@lodestar/params";
 import { computeAnchorCheckpoint, computeAttestationsRewards, computeBlockRewards, computeEndSlotAtEpoch, computeEpochAtSlot, computeStartSlotAtEpoch, computeSyncCommitteeRewards, getEffectiveBalanceIncrementsZeroInactive, getEffectiveBalancesFromStateBytes, processSlots, } from "@lodestar/state-transition";
-import { isBlindedBeaconBlock, } from "@lodestar/types";
+import { isBlindedBeaconBlock, ssz, sszTypesFor, } from "@lodestar/types";
 import { fromHex, gweiToWei, isErrorAborted, pruneSetToMax, sleep, toRootHex } from "@lodestar/utils";
 import { GENESIS_EPOCH, ZERO_HASH } from "../constants/index.js";
+import { BLOB_SIDECARS_IN_WRAPPER_INDEX } from "../db/repositories/blobSidecars.js";
 import { BuilderStatus } from "../execution/builder/http.js";
 import { computeNodeIdFromPrivateKey } from "../network/subnets/interface.js";
 import { BufferPool } from "../util/bufferPool.js";
 import { Clock, ClockEvent } from "../util/clock.js";
 import { CustodyConfig, getValidatorsCustodyRequirement } from "../util/dataColumns.js";
+import { callInNextEventLoop } from "../util/eventLoop.js";
 import { ensureDir, writeIfNotExist } from "../util/file.js";
 import { isOptimisticBlock } from "../util/forkChoice.js";
+import { JobItemQueue } from "../util/queue/itemQueue.js";
 import { SerializedCache } from "../util/serializedCache.js";
+import { getSlotFromSignedBeaconBlockSerialized } from "../util/sszBytes.js";
 import { ArchiveStore } from "./archiveStore/archiveStore.js";
 import { CheckpointBalancesCache } from "./balancesCache.js";
 import { BeaconProposerCache } from "./beaconProposerCache.js";
+import { isBlockInputBlobs, isBlockInputColumns } from "./blocks/blockInput/index.js";
 import { BlockProcessor } from "./blocks/index.js";
+import { persistBlockInputs } from "./blocks/writeBlockInputToDb.js";
 import { BlsMultiThreadWorkerPool, BlsSingleThreadVerifier } from "./bls/index.js";
 import { ColumnReconstructionTracker } from "./ColumnReconstructionTracker.js";
 import { ChainEvent, ChainEventEmitter } from "./emitter.js";
@@ -24,24 +30,22 @@ import { initializeForkChoice } from "./forkChoice/index.js";
 import { GetBlobsTracker } from "./GetBlobsTracker.js";
 import { FindHeadFnName } from "./interface.js";
 import { LightClientServer } from "./lightClient/index.js";
-import { AggregatedAttestationPool, AttestationPool, OpPool, SyncCommitteeMessagePool, SyncContributionAndProofPool, } from "./opPools/index.js";
+import { AggregatedAttestationPool, AttestationPool, ExecutionPayloadBidPool, OpPool, PayloadAttestationPool, SyncCommitteeMessagePool, SyncContributionAndProofPool, } from "./opPools/index.js";
 import { PrepareNextSlotScheduler } from "./prepareNextSlot.js";
 import { computeNewStateRoot } from "./produceBlock/computeNewStateRoot.js";
 import { BlockType } from "./produceBlock/index.js";
 import { produceBlockBody, produceCommonBlockBody } from "./produceBlock/produceBlockBody.js";
 import { QueuedStateRegenerator, RegenCaller } from "./regen/index.js";
 import { ReprocessController } from "./reprocess.js";
-import { SeenAggregators, SeenAttesters, SeenBlockProposers, SeenContributionAndProof, SeenSyncCommitteeMessages, } from "./seenCache/index.js";
+import { SeenAggregators, SeenAttesters, SeenBlockProposers, SeenContributionAndProof, SeenExecutionPayloadBids, SeenExecutionPayloadEnvelopes, SeenPayloadAttesters, SeenSyncCommitteeMessages, } from "./seenCache/index.js";
 import { SeenAggregatedAttestations } from "./seenCache/seenAggregateAndProof.js";
 import { SeenAttestationDatas } from "./seenCache/seenAttestationData.js";
 import { SeenBlockAttesters } from "./seenCache/seenBlockAttesters.js";
 import { SeenBlockInput } from "./seenCache/seenGossipBlockInput.js";
 import { ShufflingCache } from "./shufflingCache.js";
-import { BlockStateCacheImpl } from "./stateCache/blockStateCacheImpl.js";
 import { DbCPStateDatastore, checkpointToDatastoreKey } from "./stateCache/datastore/db.js";
 import { FileCPStateDatastore } from "./stateCache/datastore/file.js";
 import { FIFOBlockStateCache } from "./stateCache/fifoBlockStateCache.js";
-import { InMemoryCheckpointStateCache } from "./stateCache/inMemoryCheckpointsCache.js";
 import { PersistentCheckpointStateCache } from "./stateCache/persistentCheckpointsCache.js";
 /**
  * The maximum number of cached produced results to keep in memory.
@@ -51,6 +55,10 @@ import { PersistentCheckpointStateCache } from "./stateCache/persistentCheckpoin
  * allow some margin if the node overloads.
  */
 const DEFAULT_MAX_CACHED_PRODUCED_RESULTS = 4;
+/**
+ * The maximum number of pending unfinalized block writes to the database before backpressure is applied.
+ */
+const DEFAULT_MAX_PENDING_UNFINALIZED_BLOCK_WRITES = 32;
 export class BeaconChain {
     genesisTime;
     genesisValidatorsRoot;
@@ -72,16 +80,22 @@ export class BeaconChain {
     lightClientServer;
     reprocessController;
     archiveStore;
+    unfinalizedBlockWrites;
     // Ops pool
     attestationPool;
     aggregatedAttestationPool;
     syncCommitteeMessagePool;
     syncContributionAndProofPool;
+    executionPayloadBidPool;
+    payloadAttestationPool;
     opPool;
     // Gossip seen cache
     seenAttesters = new SeenAttesters();
     seenAggregators = new SeenAggregators();
+    seenPayloadAttesters = new SeenPayloadAttesters();
     seenAggregatedAttestations;
+    seenExecutionPayloadEnvelopes = new SeenExecutionPayloadEnvelopes();
+    seenExecutionPayloadBids = new SeenExecutionPayloadBids();
     seenBlockProposers = new SeenBlockProposers();
     seenSyncCommitteeMessages = new SeenSyncCommitteeMessages();
     seenContributionAndProof;
@@ -139,8 +153,8 @@ export class BeaconChain {
         const emitter = new ChainEventEmitter();
         // by default, verify signatures on both main threads and worker threads
         const bls = opts.blsVerifyAllMainThread
-            ? new BlsSingleThreadVerifier({ metrics })
-            : new BlsMultiThreadWorkerPool(opts, { logger, metrics });
+            ? new BlsSingleThreadVerifier({ metrics, index2pubkey })
+            : new BlsMultiThreadWorkerPool(opts, { logger, metrics, index2pubkey });
         if (!clock)
             clock = new Clock({ config, genesisTime: this.genesisTime, signal });
         this.blacklistedBlocks = new Map((opts.blacklistedBlocks ?? []).map((hex) => [hex, null]));
@@ -148,6 +162,8 @@ export class BeaconChain {
         this.aggregatedAttestationPool = new AggregatedAttestationPool(this.config, metrics);
         this.syncCommitteeMessagePool = new SyncCommitteeMessagePool(config, clock, this.opts?.preaggregateSlotDistance);
         this.syncContributionAndProofPool = new SyncContributionAndProofPool(config, clock, metrics, logger);
+        this.executionPayloadBidPool = new ExecutionPayloadBidPool();
+        this.payloadAttestationPool = new PayloadAttestationPool(config, clock, metrics);
         this.opPool = new OpPool(config);
         this.seenAggregatedAttestations = new SeenAggregatedAttestations(metrics);
         this.seenContributionAndProof = new SeenContributionAndProof(metrics);
@@ -172,7 +188,7 @@ export class BeaconChain {
             logger,
         });
         this._earliestAvailableSlot = anchorState.slot;
-        this.shufflingCache = anchorState.epochCtx.shufflingCache = new ShufflingCache(metrics, logger, this.opts, [
+        this.shufflingCache = new ShufflingCache(metrics, logger, this.opts, [
             {
                 shuffling: anchorState.epochCtx.previousShuffling,
                 decisionRoot: anchorState.epochCtx.previousDecisionRoot,
@@ -190,29 +206,18 @@ export class BeaconChain {
         this.pubkey2index = pubkey2index;
         this.index2pubkey = index2pubkey;
         const fileDataStore = opts.nHistoricalStatesFileDataStore ?? true;
-        const blockStateCache = this.opts.nHistoricalStates
-            ? new FIFOBlockStateCache(this.opts, { metrics })
-            : new BlockStateCacheImpl({ metrics });
-        this.bufferPool = this.opts.nHistoricalStates
-            ? new BufferPool(anchorState.type.tree_serializedSize(anchorState.node), metrics)
-            : null;
-        let checkpointStateCache;
-        this.cpStateDatastore = undefined;
-        if (this.opts.nHistoricalStates) {
-            this.cpStateDatastore = fileDataStore ? new FileCPStateDatastore(dataDir) : new DbCPStateDatastore(this.db);
-            checkpointStateCache = new PersistentCheckpointStateCache({
-                config,
-                metrics,
-                logger,
-                clock,
-                blockStateCache,
-                bufferPool: this.bufferPool,
-                datastore: this.cpStateDatastore,
-            }, this.opts);
-        }
-        else {
-            checkpointStateCache = new InMemoryCheckpointStateCache({ metrics });
-        }
+        const blockStateCache = new FIFOBlockStateCache(this.opts, { metrics });
+        this.bufferPool = new BufferPool(anchorState.type.tree_serializedSize(anchorState.node), metrics);
+        this.cpStateDatastore = fileDataStore ? new FileCPStateDatastore(dataDir) : new DbCPStateDatastore(this.db);
+        const checkpointStateCache = new PersistentCheckpointStateCache({
+            config,
+            metrics,
+            logger,
+            clock,
+            blockStateCache,
+            bufferPool: this.bufferPool,
+            datastore: this.cpStateDatastore,
+        }, this.opts);
         const { checkpoint } = computeAnchorCheckpoint(config, anchorState);
         blockStateCache.add(anchorState);
         blockStateCache.setHeadState(anchorState);
@@ -223,6 +228,7 @@ export class BeaconChain {
             forkChoice,
             blockStateCache,
             checkpointStateCache,
+            seenBlockInputCache: this.seenBlockInputCache,
             db,
             metrics,
             validatorMonitor,
@@ -255,6 +261,10 @@ export class BeaconChain {
             config,
         });
         this.archiveStore = new ArchiveStore({ db, chain: this, logger: logger, metrics }, { ...opts, dbName, anchorState: { finalizedCheckpoint: anchorState.finalizedCheckpoint } }, signal);
+        this.unfinalizedBlockWrites = new JobItemQueue(persistBlockInputs.bind(this), {
+            maxLength: DEFAULT_MAX_PENDING_UNFINALIZED_BLOCK_WRITES,
+            signal,
+        }, metrics?.unfinalizedBlockWritesQueue);
         // always run PrepareNextSlotScheduler except for fork_choice spec tests
         if (!opts?.disablePrepareNextSlot) {
             new PrepareNextSlotScheduler(this, this.config, metrics, this.logger, signal);
@@ -267,6 +277,7 @@ export class BeaconChain {
         clock.addListener(ClockEvent.epoch, this.onClockEpoch.bind(this));
         emitter.addListener(ChainEvent.forkChoiceFinalized, this.onForkChoiceFinalized.bind(this));
         emitter.addListener(ChainEvent.forkChoiceJustified, this.onForkChoiceJustified.bind(this));
+        emitter.addListener(ChainEvent.checkpoint, this.onCheckpoint.bind(this));
     }
     async init() {
         await this.archiveStore.init();
@@ -275,6 +286,10 @@ export class BeaconChain {
     async close() {
         await this.archiveStore.close();
         await this.bls.close();
+        // Since we don't persist unfinalized fork-choice,
+        // we can abort any ongoing unfinalized block writes.
+        // TODO: persist fork choice to disk and allow unfinalized block writes to complete.
+        this.unfinalizedBlockWrites.dropAllJobs();
         this.abortController.abort();
     }
     seenBlock(blockRoot) {
@@ -299,6 +314,8 @@ export class BeaconChain {
             this.seenAttesters.isKnown(epoch, index) ||
             //   seenAggregators = single aggregator index, not participants of the aggregate
             this.seenAggregators.isKnown(epoch, index) ||
+            //   seenPayloadAttesters = single signer of payload attestation message
+            this.seenPayloadAttesters.isKnown(epoch, index) ||
             //   seenBlockProposers = single block proposer
             this.seenBlockProposers.seenAtEpoch(epoch, index));
     }
@@ -335,7 +352,7 @@ export class BeaconChain {
         // only use regen queue if necessary, it'll cache in checkpointStateCache if regen gets through epoch transition
         const head = this.forkChoice.getHead();
         const startSlot = computeStartSlotAtEpoch(epoch);
-        return this.regen.getBlockSlotState(head.blockRoot, startSlot, { dontTransferCache: true }, regenCaller);
+        return this.regen.getBlockSlotState(head, startSlot, { dontTransferCache: true }, regenCaller);
     }
     async getStateBySlot(slot, opts) {
         const finalizedBlock = this.forkChoice.getFinalizedBlock();
@@ -347,7 +364,7 @@ export class BeaconChain {
         if (opts?.allowRegen) {
             // Find closest canonical block to slot, then trigger regen
             const block = this.forkChoice.getCanonicalBlockClosestLteSlot(slot) ?? finalizedBlock;
-            const state = await this.regen.getBlockSlotState(block.blockRoot, slot, { dontTransferCache: true }, RegenCaller.restApi);
+            const state = await this.regen.getBlockSlotState(block, slot, { dontTransferCache: true }, RegenCaller.restApi);
             return {
                 state,
                 executionOptimistic: isOptimisticBlock(block),
@@ -398,7 +415,8 @@ export class BeaconChain {
                 finalized: cachedStateCtx.epochCtx.epoch <= finalizedEpoch && finalizedEpoch !== GENESIS_EPOCH,
             };
         }
-        const data = await this.db.stateArchive.getByRoot(fromHex(stateRoot));
+        // this is mostly useful for a node with `--chain.archiveStateEpochFrequency 1`
+        const data = await this.db.stateArchive.getBinaryByRoot(fromHex(stateRoot));
         return data && { state: data, executionOptimistic: false, finalized: true };
     }
     async getPersistedCheckpointState(checkpoint) {
@@ -445,6 +463,13 @@ export class BeaconChain {
             // Unfinalized slot, attempt to find in fork-choice
             const block = this.forkChoice.getCanonicalBlockAtSlot(slot);
             if (block) {
+                // Block found in fork-choice.
+                // It may be in the block input cache, awaiting full DA reconstruction, check there first
+                // Otherwise (most likely), check the hot db
+                const blockInput = this.seenBlockInputCache.get(block.blockRoot);
+                if (blockInput?.hasBlock()) {
+                    return { block: blockInput.getBlock(), executionOptimistic: isOptimisticBlock(block), finalized: false };
+                }
                 const data = await this.db.block.get(fromHex(block.blockRoot));
                 if (data) {
                     return { block: data, executionOptimistic: isOptimisticBlock(block), finalized: false };
@@ -460,6 +485,13 @@ export class BeaconChain {
     async getBlockByRoot(root) {
         const block = this.forkChoice.getBlockHex(root);
         if (block) {
+            // Block found in fork-choice.
+            // It may be in the block input cache, awaiting full DA reconstruction, check there first
+            // Otherwise (most likely), check the hot db
+            const blockInput = this.seenBlockInputCache.get(block.blockRoot);
+            if (blockInput?.hasBlock()) {
+                return { block: blockInput.getBlock(), executionOptimistic: isOptimisticBlock(block), finalized: false };
+            }
             const data = await this.db.block.get(fromHex(root));
             if (data) {
                 return { block: data, executionOptimistic: isOptimisticBlock(block), finalized: false };
@@ -470,9 +502,125 @@ export class BeaconChain {
         const data = await this.db.blockArchive.getByRoot(fromHex(root));
         return data && { block: data, executionOptimistic: false, finalized: true };
     }
+    async getSerializedBlockByRoot(root) {
+        const block = this.forkChoice.getBlockHex(root);
+        if (block) {
+            // Block found in fork-choice.
+            // It may be in the block input cache, awaiting full DA reconstruction, check there first
+            // Otherwise (most likely), check the hot db
+            const blockInput = this.seenBlockInputCache.get(block.blockRoot);
+            if (blockInput?.hasBlock()) {
+                const signedBlock = blockInput.getBlock();
+                const serialized = this.serializedCache.get(signedBlock);
+                if (serialized) {
+                    return {
+                        block: serialized,
+                        executionOptimistic: isOptimisticBlock(block),
+                        finalized: false,
+                        slot: blockInput.slot,
+                    };
+                }
+                return {
+                    block: sszTypesFor(blockInput.forkName).SignedBeaconBlock.serialize(signedBlock),
+                    executionOptimistic: isOptimisticBlock(block),
+                    finalized: false,
+                    slot: blockInput.slot,
+                };
+            }
+            const data = await this.db.block.getBinary(fromHex(root));
+            if (data) {
+                const slot = getSlotFromSignedBeaconBlockSerialized(data);
+                if (slot === null)
+                    throw new Error(`Invalid block data stored in DB for root: ${root}`);
+                return { block: data, executionOptimistic: isOptimisticBlock(block), finalized: false, slot };
+            }
+            // If block is not found in hot db, try cold db since there could be an archive cycle happening
+            // TODO: Add a lock to the archiver to have deterministic behavior on where are blocks
+        }
+        const data = await this.db.blockArchive.getBinaryEntryByRoot(fromHex(root));
+        return data && { block: data.value, executionOptimistic: false, finalized: true, slot: data.key };
+    }
+    async getBlobSidecars(blockSlot, blockRootHex) {
+        const blockInput = this.seenBlockInputCache.get(blockRootHex);
+        if (blockInput) {
+            if (!isBlockInputBlobs(blockInput)) {
+                throw new Error(`Expected block input to have blobs: slot=${blockSlot} root=${blockRootHex}`);
+            }
+            if (!blockInput.hasAllData()) {
+                return null;
+            }
+            return blockInput.getBlobs();
+        }
+        const unfinalizedBlobSidecars = (await this.db.blobSidecars.get(fromHex(blockRootHex)))?.blobSidecars ?? null;
+        if (unfinalizedBlobSidecars) {
+            return unfinalizedBlobSidecars;
+        }
+        return (await this.db.blobSidecarsArchive.get(blockSlot))?.blobSidecars ?? null;
+    }
+    async getSerializedBlobSidecars(blockSlot, blockRootHex) {
+        const blockInput = this.seenBlockInputCache.get(blockRootHex);
+        if (blockInput) {
+            if (!isBlockInputBlobs(blockInput)) {
+                throw new Error(`Expected block input to have blobs: slot=${blockSlot} root=${blockRootHex}`);
+            }
+            if (!blockInput.hasAllData()) {
+                return null;
+            }
+            return ssz.deneb.BlobSidecars.serialize(blockInput.getBlobs());
+        }
+        const unfinalizedBlobSidecarsWrapper = await this.db.blobSidecars.getBinary(fromHex(blockRootHex));
+        if (unfinalizedBlobSidecarsWrapper) {
+            return unfinalizedBlobSidecarsWrapper.slice(BLOB_SIDECARS_IN_WRAPPER_INDEX);
+        }
+        const finalizedBlobSidecarsWrapper = await this.db.blobSidecarsArchive.getBinary(blockSlot);
+        if (finalizedBlobSidecarsWrapper) {
+            return finalizedBlobSidecarsWrapper.slice(BLOB_SIDECARS_IN_WRAPPER_INDEX);
+        }
+        return null;
+    }
+    async getDataColumnSidecars(blockSlot, blockRootHex) {
+        const blockInput = this.seenBlockInputCache.get(blockRootHex);
+        if (blockInput) {
+            if (!isBlockInputColumns(blockInput)) {
+                throw new Error(`Expected block input to have columns: slot=${blockSlot} root=${blockRootHex}`);
+            }
+            return blockInput.getAllColumns();
+        }
+        const sidecarsUnfinalized = await this.db.dataColumnSidecar.values(fromHex(blockRootHex));
+        if (sidecarsUnfinalized.length > 0) {
+            return sidecarsUnfinalized;
+        }
+        const sidecarsFinalized = await this.db.dataColumnSidecarArchive.values(blockSlot);
+        return sidecarsFinalized;
+    }
+    async getSerializedDataColumnSidecars(blockSlot, blockRootHex, indices) {
+        const blockInput = this.seenBlockInputCache.get(blockRootHex);
+        if (blockInput) {
+            if (!isBlockInputColumns(blockInput)) {
+                throw new Error(`Expected block input to have columns: slot=${blockSlot} root=${blockRootHex}`);
+            }
+            return indices.map((index) => {
+                const sidecar = blockInput.getColumn(index);
+                if (!sidecar) {
+                    return undefined;
+                }
+                const serialized = this.serializedCache.get(sidecar);
+                if (serialized) {
+                    return serialized;
+                }
+                return ssz.fulu.DataColumnSidecar.serialize(sidecar);
+            });
+        }
+        const sidecarsUnfinalized = await this.db.dataColumnSidecar.getManyBinary(fromHex(blockRootHex), indices);
+        if (sidecarsUnfinalized.some((sidecar) => sidecar != null)) {
+            return sidecarsUnfinalized;
+        }
+        const sidecarsFinalized = await this.db.dataColumnSidecarArchive.getManyBinary(blockSlot, indices);
+        return sidecarsFinalized;
+    }
     async produceCommonBlockBody(blockAttributes) {
-        const { slot, parentBlockRoot } = blockAttributes;
-        const state = await this.regen.getBlockSlotState(toRootHex(parentBlockRoot), slot, { dontTransferCache: true }, RegenCaller.produceBlock);
+        const { slot, parentBlock } = blockAttributes;
+        const state = await this.regen.getBlockSlotState(parentBlock, slot, { dontTransferCache: true }, RegenCaller.produceBlock);
         // TODO: To avoid breaking changes for metric define this attribute
         const blockType = BlockType.Full;
         return produceCommonBlockBody.call(this, blockType, state, blockAttributes);
@@ -483,8 +631,8 @@ export class BeaconChain {
     produceBlindedBlock(blockAttributes) {
         return this.produceBlockWrapper(BlockType.Blinded, blockAttributes);
     }
-    async produceBlockWrapper(blockType, { randaoReveal, graffiti, slot, feeRecipient, commonBlockBodyPromise, parentBlockRoot, }) {
-        const state = await this.regen.getBlockSlotState(toRootHex(parentBlockRoot), slot, { dontTransferCache: true }, RegenCaller.produceBlock);
+    async produceBlockWrapper(blockType, { randaoReveal, graffiti, slot, feeRecipient, commonBlockBodyPromise, parentBlock, }) {
+        const state = await this.regen.getBlockSlotState(parentBlock, slot, { dontTransferCache: true }, RegenCaller.produceBlock);
         const proposerIndex = state.epochCtx.getBeaconProposer(slot);
         const proposerPubKey = this.index2pubkey[proposerIndex].toBytes();
         const { body, produceResult, executionPayloadValue, shouldOverrideBuilder } = await produceBlockBody.call(this, blockType, state, {
@@ -492,7 +640,7 @@ export class BeaconChain {
             graffiti,
             slot,
             feeRecipient,
-            parentBlockRoot,
+            parentBlock,
             proposerIndex,
             proposerPubKey,
             commonBlockBodyPromise,
@@ -511,7 +659,7 @@ export class BeaconChain {
         const block = {
             slot,
             proposerIndex,
-            parentRoot: parentBlockRoot,
+            parentRoot: fromHex(parentBlock.blockRoot),
             stateRoot: ZERO_HASH,
             body,
         };
@@ -668,7 +816,7 @@ export class BeaconChain {
             // thanks to one epoch look ahead, we don't need to dial up to attEpoch
             const targetSlot = computeStartSlotAtEpoch(attEpoch - 1);
             this.metrics?.gossipAttestation.useHeadBlockStateDialedToTargetEpoch.inc({ caller: regenCaller });
-            state = await this.regen.getBlockSlotState(attHeadBlock.blockRoot, targetSlot, { dontTransferCache: true }, regenCaller);
+            state = await this.regen.getBlockSlotState(attHeadBlock, targetSlot, { dontTransferCache: true }, regenCaller);
         }
         else if (blockEpoch > attEpoch) {
             // should not happen, handled inside attestation verification code
@@ -681,7 +829,8 @@ export class BeaconChain {
             this.metrics?.gossipAttestation.useHeadBlockState.inc({ caller: regenCaller });
             state = await this.regen.getState(attHeadBlock.stateRoot, regenCaller);
         }
-        // should always be the current epoch of the active context so no need to await a result from the ShufflingCache
+        // resolve the promise to unblock other calls of the same epoch and dependent root
+        this.shufflingCache.processState(state);
         return state.epochCtx.getShufflingAtEpoch(attEpoch);
     }
     /**
@@ -776,6 +925,8 @@ export class BeaconChain {
         metrics.opPool.proposerSlashingPoolSize.set(this.opPool.proposerSlashingsSize);
         metrics.opPool.voluntaryExitPoolSize.set(this.opPool.voluntaryExitsSize);
         metrics.opPool.syncCommitteeMessagePoolSize.set(this.syncCommitteeMessagePool.size);
+        metrics.opPool.payloadAttestationPool.size.set(this.payloadAttestationPool.size);
+        metrics.opPool.executionPayloadBidPool.size.set(this.executionPayloadBidPool.size);
         // syncContributionAndProofPool tracks metrics on its own
         metrics.opPool.blsToExecutionChangePoolSize.set(this.opPool.blsToExecutionChangeSize);
         metrics.chain.blacklistedBlocks.set(this.blacklistedBlocks.size);
@@ -800,6 +951,9 @@ export class BeaconChain {
         this.aggregatedAttestationPool.prune(slot);
         this.syncCommitteeMessagePool.prune(slot);
         this.seenSyncCommitteeMessages.prune(slot);
+        this.payloadAttestationPool.prune(slot);
+        this.executionPayloadBidPool.prune(slot);
+        this.seenExecutionPayloadBids.prune(slot);
         this.seenAttestationDatas.onSlot(slot);
         this.reprocessController.onSlot(slot);
         // Prune old cached block production artifacts, those are only useful on their slot
@@ -820,6 +974,7 @@ export class BeaconChain {
         this.metrics?.clockEpoch.set(epoch);
         this.seenAttesters.prune(epoch);
         this.seenAggregators.prune(epoch);
+        this.seenPayloadAttesters.prune(epoch);
         this.seenAggregatedAttestations.prune(epoch);
         this.seenBlockAttesters.prune(epoch);
         this.beaconProposerCache.prune(epoch);
@@ -831,20 +986,28 @@ export class BeaconChain {
     onForkChoiceJustified(cp) {
         this.logger.verbose("Fork choice justified", { epoch: cp.epoch, root: cp.rootHex });
     }
+    onCheckpoint(_checkpoint, state) {
+        // Defer to not block other checkpoint event handlers, which can cause lightclient update delays
+        callInNextEventLoop(() => {
+            this.shufflingCache.processState(state);
+        });
+    }
     async onForkChoiceFinalized(cp) {
         this.logger.verbose("Fork choice finalized", { epoch: cp.epoch, root: cp.rootHex });
-        this.seenBlockProposers.prune(computeStartSlotAtEpoch(cp.epoch));
+        const finalizedSlot = computeStartSlotAtEpoch(cp.epoch);
+        this.seenBlockProposers.prune(finalizedSlot);
+        this.seenExecutionPayloadEnvelopes.prune(finalizedSlot);
         // Update validator custody to account for effective balance changes
         await this.updateValidatorsCustodyRequirement(cp);
         // TODO: Improve using regen here
         const { blockRoot, stateRoot, slot } = this.forkChoice.getHead();
         const headState = this.regen.getStateSync(stateRoot);
-        const headBlock = await this.db.block.get(fromHex(blockRoot));
-        if (headBlock == null) {
-            throw Error(`Head block ${slot} ${headBlock} is not available in database`);
+        const blockResult = await this.getBlockByRoot(blockRoot);
+        if (blockResult == null) {
+            throw Error(`Head block for ${slot} is not available in cache or database`);
         }
         if (headState) {
-            this.opPool.pruneAll(headBlock, headState);
+            this.opPool.pruneAll(blockResult.block, headState);
         }
         if (headState === null) {
             this.logger.verbose("Head state is null");
@@ -942,8 +1105,8 @@ export class BeaconChain {
             throw Error(`Pre-state is unavailable given block's parent root ${toRootHex(block.parentRoot)}`);
         }
         preState = processSlots(preState, block.slot); // Dial preState's slot to block.slot
-        const postState = this.regen.getStateSync(toRootHex(block.stateRoot)) ?? undefined;
-        return computeBlockRewards(this.config, block, preState.clone(), postState?.clone());
+        const proposerRewards = this.regen.getStateSync(toRootHex(block.stateRoot))?.proposerRewards ?? undefined;
+        return computeBlockRewards(this.config, block, preState, proposerRewards);
     }
     async getAttestationsRewards(epoch, validatorIds) {
         // We use end slot of (epoch + 1) to ensure we have seen all attestations. On-time or late. Any late attestation beyond this slot is not considered
@@ -967,7 +1130,7 @@ export class BeaconChain {
             throw Error(`Pre-state is unavailable given block's parent root ${toRootHex(block.parentRoot)}`);
         }
         preState = processSlots(preState, block.slot); // Dial preState's slot to block.slot
-        return computeSyncCommitteeRewards(this.config, this.index2pubkey, block, preState.clone(), validatorIds);
+        return computeSyncCommitteeRewards(this.config, this.index2pubkey, block, preState, validatorIds);
     }
 }
 //# sourceMappingURL=chain.js.map