@lodestar/beacon-node 1.33.0 → 1.34.0-dev.083b7cce17

package/lib/chain/chain.d.ts

@@ -3,15 +3,17 @@ import { CompositeTypeAny, TreeView, Type } from "@chainsafe/ssz";
 import { BeaconConfig } from "@lodestar/config";
 import { CheckpointWithHex, IForkChoice, ProtoBlock } from "@lodestar/fork-choice";
 import { BeaconStateAllForks, CachedBeaconStateAllForks, EpochShuffling, Index2PubkeyCache } from "@lodestar/state-transition";
-import { BeaconBlock, BlindedBeaconBlock, Epoch, Root, RootHex, SignedBeaconBlock, Slot, UintNum64, ValidatorIndex, Wei, deneb, phase0 } from "@lodestar/types";
+import { BeaconBlock, BlindedBeaconBlock, Epoch, Root, RootHex, SignedBeaconBlock, Slot, Status, UintNum64, ValidatorIndex, Wei } from "@lodestar/types";
 import { Logger } from "@lodestar/utils";
 import { ProcessShutdownCallback } from "@lodestar/validator";
+import { PrivateKey } from "@libp2p/interface";
 import { IBeaconDb } from "../db/index.js";
 import { IEth1ForBlockProduction } from "../eth1/index.js";
 import { IExecutionBuilder, IExecutionEngine } from "../execution/index.js";
 import { Metrics } from "../metrics/index.js";
 import { BufferPool } from "../util/bufferPool.js";
 import { IClock } from "../util/clock.js";
+import { CustodyConfig } from "../util/dataColumns.js";
 import { SerializedCache } from "../util/serializedCache.js";
 import { ArchiveStore } from "./archiveStore/archiveStore.js";
 import { CheckpointBalancesCache } from "./balancesCache.js";
@@ -25,7 +27,7 @@ import { CommonBlockBody, IBeaconChain, ProposerPreparationData, StateGetOpts }
 import { LightClientServer } from "./lightClient/index.js";
 import { AggregatedAttestationPool, AttestationPool, OpPool, SyncCommitteeMessagePool, SyncContributionAndProofPool } from "./opPools/index.js";
 import { IChainOptions } from "./options.js";
-import { AssembledBlockType, BlockType } from "./produceBlock/index.js";
+import { AssembledBlockType, BlockType, ProduceResult } from "./produceBlock/index.js";
 import { BlockAttributes } from "./produceBlock/produceBlockBody.js";
 import { QueuedStateRegenerator, RegenCaller } from "./regen/index.js";
 import { ReprocessController } from "./reprocess.js";
@@ -47,6 +49,7 @@ export declare class BeaconChain implements IBeaconChain {
     readonly executionEngine: IExecutionEngine;
     readonly executionBuilder?: IExecutionBuilder;
     readonly config: BeaconConfig;
+    readonly custodyConfig: CustodyConfig;
     readonly logger: Logger;
     readonly metrics: Metrics | null;
     readonly validatorMonitor: ValidatorMonitor | null;
@@ -80,92 +83,12 @@ export declare class BeaconChain implements IBeaconChain {
     readonly beaconProposerCache: BeaconProposerCache;
     readonly checkpointBalancesCache: CheckpointBalancesCache;
     readonly shufflingCache: ShufflingCache;
-    /** Map keyed by executionPayload.blockHash of the block for those blobs */
-    readonly producedContentsCache: Map<string, deneb.Contents>;
-    readonly producedBlockRoot: Map<string, import("@chainsafe/ssz").ValueOfFields<{
-        transactions: import("@chainsafe/ssz").ListCompositeType<import("@chainsafe/ssz").ByteListType>;
-        parentHash: import("@chainsafe/ssz").ByteVectorType;
-        feeRecipient: import("@lodestar/types/lib/utils/executionAddress.js").ExecutionAddressType;
-        stateRoot: import("@chainsafe/ssz").ByteVectorType;
-        receiptsRoot: import("@chainsafe/ssz").ByteVectorType;
-        logsBloom: import("@chainsafe/ssz").ByteVectorType;
-        prevRandao: import("@chainsafe/ssz").ByteVectorType;
-        blockNumber: import("@chainsafe/ssz").UintNumberType;
-        gasLimit: import("@chainsafe/ssz").UintNumberType;
-        gasUsed: import("@chainsafe/ssz").UintNumberType;
-        timestamp: import("@chainsafe/ssz").UintNumberType;
-        extraData: import("@chainsafe/ssz").ByteListType;
-        baseFeePerGas: import("@chainsafe/ssz").UintBigintType;
-        blockHash: import("@chainsafe/ssz").ByteVectorType;
-    }> | import("@chainsafe/ssz").ValueOfFields<{
-        withdrawals: import("@chainsafe/ssz").ListCompositeType<import("@chainsafe/ssz").ContainerType<{
-            index: import("@chainsafe/ssz").UintNumberType;
-            validatorIndex: import("@chainsafe/ssz").UintNumberType;
-            address: import("@lodestar/types/lib/utils/executionAddress.js").ExecutionAddressType;
-            amount: import("@chainsafe/ssz").UintBigintType;
-        }>>;
-        transactions: import("@chainsafe/ssz").ListCompositeType<import("@chainsafe/ssz").ByteListType>;
-        parentHash: import("@chainsafe/ssz").ByteVectorType;
-        feeRecipient: import("@lodestar/types/lib/utils/executionAddress.js").ExecutionAddressType;
-        stateRoot: import("@chainsafe/ssz").ByteVectorType;
-        receiptsRoot: import("@chainsafe/ssz").ByteVectorType;
-        logsBloom: import("@chainsafe/ssz").ByteVectorType;
-        prevRandao: import("@chainsafe/ssz").ByteVectorType;
-        blockNumber: import("@chainsafe/ssz").UintNumberType;
-        gasLimit: import("@chainsafe/ssz").UintNumberType;
-        gasUsed: import("@chainsafe/ssz").UintNumberType;
-        timestamp: import("@chainsafe/ssz").UintNumberType;
-        extraData: import("@chainsafe/ssz").ByteListType;
-        baseFeePerGas: import("@chainsafe/ssz").UintBigintType;
-        blockHash: import("@chainsafe/ssz").ByteVectorType;
-    }> | import("@chainsafe/ssz").ValueOfFields<{
-        blobGasUsed: import("@chainsafe/ssz").UintBigintType;
-        excessBlobGas: import("@chainsafe/ssz").UintBigintType;
-        withdrawals: import("@chainsafe/ssz").ListCompositeType<import("@chainsafe/ssz").ContainerType<{
-            index: import("@chainsafe/ssz").UintNumberType;
-            validatorIndex: import("@chainsafe/ssz").UintNumberType;
-            address: import("@lodestar/types/lib/utils/executionAddress.js").ExecutionAddressType;
-            amount: import("@chainsafe/ssz").UintBigintType;
-        }>>;
-        transactions: import("@chainsafe/ssz").ListCompositeType<import("@chainsafe/ssz").ByteListType>;
-        parentHash: import("@chainsafe/ssz").ByteVectorType;
-        feeRecipient: import("@lodestar/types/lib/utils/executionAddress.js").ExecutionAddressType;
-        stateRoot: import("@chainsafe/ssz").ByteVectorType;
-        receiptsRoot: import("@chainsafe/ssz").ByteVectorType;
-        logsBloom: import("@chainsafe/ssz").ByteVectorType;
-        prevRandao: import("@chainsafe/ssz").ByteVectorType;
-        blockNumber: import("@chainsafe/ssz").UintNumberType;
-        gasLimit: import("@chainsafe/ssz").UintNumberType;
-        gasUsed: import("@chainsafe/ssz").UintNumberType;
-        timestamp: import("@chainsafe/ssz").UintNumberType;
-        extraData: import("@chainsafe/ssz").ByteListType;
-        baseFeePerGas: import("@chainsafe/ssz").UintBigintType;
-        blockHash: import("@chainsafe/ssz").ByteVectorType;
-    }> | import("@chainsafe/ssz").ValueOfFields<{
-        blobGasUsed: import("@chainsafe/ssz").UintBigintType;
-        excessBlobGas: import("@chainsafe/ssz").UintBigintType;
-        withdrawals: import("@chainsafe/ssz").ListCompositeType<import("@chainsafe/ssz").ContainerType<{
-            index: import("@chainsafe/ssz").UintNumberType;
-            validatorIndex: import("@chainsafe/ssz").UintNumberType;
-            address: import("@lodestar/types/lib/utils/executionAddress.js").ExecutionAddressType;
-            amount: import("@chainsafe/ssz").UintBigintType;
-        }>>;
-        transactions: import("@chainsafe/ssz").ListCompositeType<import("@chainsafe/ssz").ByteListType>;
-        parentHash: import("@chainsafe/ssz").ByteVectorType;
-        feeRecipient: import("@lodestar/types/lib/utils/executionAddress.js").ExecutionAddressType;
-        stateRoot: import("@chainsafe/ssz").ByteVectorType;
-        receiptsRoot: import("@chainsafe/ssz").ByteVectorType;
-        logsBloom: import("@chainsafe/ssz").ByteVectorType;
-        prevRandao: import("@chainsafe/ssz").ByteVectorType;
-        blockNumber: import("@chainsafe/ssz").UintNumberType;
-        gasLimit: import("@chainsafe/ssz").UintNumberType;
-        gasUsed: import("@chainsafe/ssz").UintNumberType;
-        timestamp: import("@chainsafe/ssz").UintNumberType;
-        extraData: import("@chainsafe/ssz").ByteListType;
-        baseFeePerGas: import("@chainsafe/ssz").UintBigintType;
-        blockHash: import("@chainsafe/ssz").ByteVectorType;
-    }> | null>;
-    readonly producedBlindedBlockRoot: Set<string>;
+    /**
+     * Cache produced results (ExecutionPayload, DA Data) from the local execution so that we can send
+     * and get signed/published blinded versions which beacon node can
+     * assemble into full blocks before publishing to the network.
+     */
+    readonly blockProductionCache: Map<string, ProduceResult>;
     readonly blacklistedBlocks: Map<RootHex, Slot | null>;
     readonly serializedCache: SerializedCache;
     readonly opts: IChainOptions;
@@ -173,7 +96,11 @@ export declare class BeaconChain implements IBeaconChain {
     protected readonly db: IBeaconDb;
     private abortController;
     private processShutdownCallback;
-    constructor(opts: IChainOptions, { config, db, dbName, dataDir, logger, processShutdownCallback, clock, metrics, validatorMonitor, anchorState, eth1, executionEngine, executionBuilder, }: {
+    private _earliestAvailableSlot;
+    get earliestAvailableSlot(): Slot;
+    set earliestAvailableSlot(slot: Slot);
+    constructor(opts: IChainOptions, { privateKey, config, db, dbName, dataDir, logger, processShutdownCallback, clock, metrics, validatorMonitor, anchorState, eth1, executionEngine, executionBuilder, }: {
+        privateKey: PrivateKey;
         config: BeaconConfig;
         db: IBeaconDb;
         dbName: string;
@@ -261,20 +188,9 @@ export declare class BeaconChain implements IBeaconChain {
         consensusBlockValue: Wei;
         shouldOverrideBuilder?: boolean;
     }>;
-    /**
-     * https://github.com/ethereum/consensus-specs/blob/dev/specs/eip4844/validator.md#sidecar
-     * def get_blobs_sidecar(block: BeaconBlock, blobs: Sequence[Blob]) -> BlobSidecars:
-     *   return BlobSidecars(
-     *       beacon_block_root=hash_tree_root(block),
-     *       beacon_block_slot=block.slot,
-     *       blobs=blobs,
-     *       kzg_aggregated_proof=compute_proof_from_blobs(blobs),
-     *   )
-     */
-    getContents(beaconBlock: deneb.BeaconBlock): deneb.Contents;
     processBlock(block: BlockInput, opts?: ImportBlockOpts): Promise<void>;
     processChainSegment(blocks: BlockInput[], opts?: ImportBlockOpts): Promise<void>;
-    getStatus(): phase0.Status;
+    getStatus(): Status;
     recomputeForkChoiceHead(caller: ForkchoiceCaller): ProtoBlock;
     predictProposerHead(slot: Slot): ProtoBlock;
     getProposerHead(slot: Slot): ProtoBlock;
@@ -322,6 +238,7 @@ export declare class BeaconChain implements IBeaconChain {
     private onForkChoiceJustified;
     private onForkChoiceFinalized;
     updateBeaconProposerData(epoch: Epoch, proposers: ProposerPreparationData[]): Promise<void>;
+    private updateValidatorsCustodyRequirement;
     updateBuilderStatus(clockSlot: Slot): void;
     getBlockRewards(block: BeaconBlock | BlindedBeaconBlock): Promise<BlockRewards>;
     getAttestationsRewards(epoch: Epoch, validatorIds?: (ValidatorIndex | string)[]): Promise<{

package/lib/chain/chain.js

@@ -1,13 +1,16 @@
 import path from "node:path";
 import { PubkeyIndexMap } from "@chainsafe/pubkey-index-map";
 import { ExecutionStatus, UpdateHeadOpt } from "@lodestar/fork-choice";
-import { ForkSeq, GENESIS_SLOT, SLOTS_PER_EPOCH, isForkPostElectra } from "@lodestar/params";
-import { computeAnchorCheckpoint, computeEndSlotAtEpoch, computeEpochAtSlot, computeStartSlotAtEpoch, createCachedBeaconState, getEffectiveBalanceIncrementsZeroInactive, isCachedBeaconState, processSlots, } from "@lodestar/state-transition";
+import { EFFECTIVE_BALANCE_INCREMENT, GENESIS_SLOT, SLOTS_PER_EPOCH, isForkPostElectra } from "@lodestar/params";
+import { computeAnchorCheckpoint, computeEndSlotAtEpoch, computeEpochAtSlot, computeStartSlotAtEpoch, createCachedBeaconState, getEffectiveBalanceIncrementsZeroInactive, getEffectiveBalancesFromStateBytes, isCachedBeaconState, processSlots, } from "@lodestar/state-transition";
 import { isBlindedBeaconBlock, } from "@lodestar/types";
 import { fromHex, gweiToWei, isErrorAborted, pruneSetToMax, sleep, toRootHex } from "@lodestar/utils";
 import { GENESIS_EPOCH, ZERO_HASH } from "../constants/index.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 { ensureDir, writeIfNotExist } from "../util/file.js";
 import { isOptimisticBlock } from "../util/forkChoice.js";
 import { SerializedCache } from "../util/serializedCache.js";
@@ -18,12 +21,12 @@ import { BlockProcessor } from "./blocks/index.js";
 import { BlsMultiThreadWorkerPool, BlsSingleThreadVerifier } from "./bls/index.js";
 import { ChainEvent, ChainEventEmitter } from "./emitter.js";
 import { initializeForkChoice } from "./forkChoice/index.js";
-import { FindHeadFnName, } from "./interface.js";
+import { FindHeadFnName } from "./interface.js";
 import { LightClientServer } from "./lightClient/index.js";
 import { AggregatedAttestationPool, AttestationPool, OpPool, SyncCommitteeMessagePool, SyncContributionAndProofPool, } from "./opPools/index.js";
 import { PrepareNextSlotScheduler } from "./prepareNextSlot.js";
 import { computeNewStateRoot } from "./produceBlock/computeNewStateRoot.js";
-import { BlobsResultType, BlockType } from "./produceBlock/index.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";
@@ -44,29 +47,38 @@ import { FIFOBlockStateCache } from "./stateCache/fifoBlockStateCache.js";
 import { InMemoryCheckpointStateCache } from "./stateCache/inMemoryCheckpointsCache.js";
 import { PersistentCheckpointStateCache } from "./stateCache/persistentCheckpointsCache.js";
 /**
- * Arbitrary constants, blobs and payloads should be consumed immediately in the same slot
+ * The maximum number of cached produced results to keep in memory.
+ *
+ * Arbitrary constant. Blobs and payloads should be consumed immediately in the same slot
  * they are produced. A value of 1 would probably be sufficient. However it's sensible to
  * allow some margin if the node overloads.
  */
-const DEFAULT_MAX_CACHED_PRODUCED_ROOTS = 4;
+const DEFAULT_MAX_CACHED_PRODUCED_RESULTS = 4;
 export class BeaconChain {
-    constructor(opts, { config, db, dbName, dataDir, logger, processShutdownCallback, clock, metrics, validatorMonitor, anchorState, eth1, executionEngine, executionBuilder, }) {
+    get earliestAvailableSlot() {
+        return this._earliestAvailableSlot;
+    }
+    set earliestAvailableSlot(slot) {
+        if (this._earliestAvailableSlot !== slot) {
+            this._earliestAvailableSlot = slot;
+            this.emitter.emit(ChainEvent.updateStatus);
+        }
+    }
+    constructor(opts, { privateKey, config, db, dbName, dataDir, logger, processShutdownCallback, clock, metrics, validatorMonitor, anchorState, eth1, executionEngine, executionBuilder, }) {
         this.opPool = new OpPool();
         // Gossip seen cache
         this.seenAttesters = new SeenAttesters();
         this.seenAggregators = new SeenAggregators();
         this.seenBlockProposers = new SeenBlockProposers();
         this.seenSyncCommitteeMessages = new SeenSyncCommitteeMessages();
-        this.seenGossipBlockInput = new SeenGossipBlockInput();
         // Seen cache for liveness checks
         this.seenBlockAttesters = new SeenBlockAttesters();
-        /** Map keyed by executionPayload.blockHash of the block for those blobs */
-        this.producedContentsCache = new Map();
-        // Cache payloads from the local execution so that we can send
-        // and get signed/published blinded versions which beacon node can
-        // assemble into full blocks before publishing to the network.
-        this.producedBlockRoot = new Map();
-        this.producedBlindedBlockRoot = new Set();
+        /**
+         * Cache produced results (ExecutionPayload, DA Data) from the local execution so that we can send
+         * and get signed/published blinded versions which beacon node can
+         * assemble into full blocks before publishing to the network.
+         */
+        this.blockProductionCache = new Map();
         this.abortController = new AbortController();
         this.opts = opts;
         this.config = config;
@@ -98,6 +110,15 @@ export class BeaconChain {
         this.seenAggregatedAttestations = new SeenAggregatedAttestations(metrics);
         this.seenContributionAndProof = new SeenContributionAndProof(metrics);
         this.seenAttestationDatas = new SeenAttestationDatas(metrics, this.opts?.attDataCacheSlotDistance);
+        const nodeId = computeNodeIdFromPrivateKey(privateKey);
+        const initialCustodyGroupCount = opts.initialCustodyGroupCount ?? (opts.supernode ? config.NUMBER_OF_CUSTODY_GROUPS : config.CUSTODY_REQUIREMENT);
+        this.metrics?.peerDas.targetCustodyGroupCount.set(initialCustodyGroupCount);
+        this.custodyConfig = new CustodyConfig({
+            nodeId,
+            config,
+            initialCustodyGroupCount,
+        });
+        this.seenGossipBlockInput = new SeenGossipBlockInput(this.custodyConfig, this.executionEngine, emitter, clock, logger);
         this.beaconProposerCache = new BeaconProposerCache(opts);
         this.checkpointBalancesCache = new CheckpointBalancesCache();
         this.seenBlockInputCache = new SeenBlockInputCache({
@@ -120,6 +141,7 @@ export class BeaconChain {
                 pubkey2index: new PubkeyIndexMap(),
                 index2pubkey: [],
             });
+        this._earliestAvailableSlot = cachedState.slot;
         this.shufflingCache = cachedState.epochCtx.shufflingCache = new ShufflingCache(metrics, logger, this.opts, [
             {
                 shuffling: cachedState.epochCtx.previousShuffling,
@@ -162,7 +184,7 @@ export class BeaconChain {
         blockStateCache.add(cachedState);
         blockStateCache.setHeadState(cachedState);
         checkpointStateCache.add(checkpoint, cachedState);
-        const forkChoice = initializeForkChoice(config, emitter, clock.currentSlot, cachedState, opts, this.justifiedBalancesGetter.bind(this), logger);
+        const forkChoice = initializeForkChoice(config, emitter, clock.currentSlot, cachedState, opts, this.justifiedBalancesGetter.bind(this), metrics, logger);
         const regen = new QueuedStateRegenerator({
             config,
             forkChoice,
@@ -416,7 +438,7 @@ export class BeaconChain {
         const state = await this.regen.getBlockSlotState(toRootHex(parentBlockRoot), slot, { dontTransferCache: true }, RegenCaller.produceBlock);
         const proposerIndex = state.epochCtx.getBeaconProposer(slot);
         const proposerPubKey = state.epochCtx.index2pubkey[proposerIndex].toBytes();
-        const { body, blobs, executionPayloadValue, shouldOverrideBuilder } = await produceBlockBody.call(this, blockType, state, {
+        const { body, produceResult, executionPayloadValue, shouldOverrideBuilder } = await produceBlockBody.call(this, blockType, state, {
             randaoReveal,
             graffiti,
             slot,
@@ -428,7 +450,7 @@ export class BeaconChain {
             commonBlockBodyPromise,
         });
         // The hashtree root computed here for debug log will get cached and hence won't introduce additional delays
-        const bodyRoot = blockType === BlockType.Full
+        const bodyRoot = produceResult.type === BlockType.Full
             ? this.config.getForkTypes(slot).BeaconBlockBody.hashTreeRoot(body)
             : this.config
                 .getPostBellatrixForkTypes(slot)
@@ -447,51 +469,15 @@ export class BeaconChain {
         };
         const { newStateRoot, proposerReward } = computeNewStateRoot(this.metrics, state, block);
         block.stateRoot = newStateRoot;
-        const blockRoot = blockType === BlockType.Full
+        const blockRoot = produceResult.type === BlockType.Full
             ? this.config.getForkTypes(slot).BeaconBlock.hashTreeRoot(block)
             : this.config.getPostBellatrixForkTypes(slot).BlindedBeaconBlock.hashTreeRoot(block);
         const blockRootHex = toRootHex(blockRoot);
-        // track the produced block for consensus broadcast validations
-        if (blockType === BlockType.Full) {
-            this.logger.debug("Setting executionPayload cache for produced block", { blockRootHex, slot, blockType });
-            this.producedBlockRoot.set(blockRootHex, block.body.executionPayload ?? null);
-            this.metrics?.blockProductionCaches.producedBlockRoot.set(this.producedBlockRoot.size);
-        }
-        else {
-            this.logger.debug("Tracking the produced blinded block", { blockRootHex, slot, blockType });
-            this.producedBlindedBlockRoot.add(blockRootHex);
-            this.metrics?.blockProductionCaches.producedBlindedBlockRoot.set(this.producedBlindedBlockRoot.size);
-        }
-        // Cache for latter broadcasting
-        //
-        // blinded blobs will be fetched and added to this cache later before finally
-        // publishing the blinded block's full version
-        if (blobs.type === BlobsResultType.produced) {
-            // body is of full type here
-            const { blockHash, contents } = blobs;
-            this.producedContentsCache.set(blockHash, contents);
-            this.metrics?.blockProductionCaches.producedContentsCache.set(this.producedContentsCache.size);
-        }
+        // Track the produced block for consensus broadcast validations, later validation, etc.
+        this.blockProductionCache.set(blockRootHex, produceResult);
+        this.metrics?.blockProductionCacheSize.set(this.blockProductionCache.size);
         return { block, executionPayloadValue, consensusBlockValue: gweiToWei(proposerReward), shouldOverrideBuilder };
     }
-    /**
-     * https://github.com/ethereum/consensus-specs/blob/dev/specs/eip4844/validator.md#sidecar
-     * def get_blobs_sidecar(block: BeaconBlock, blobs: Sequence[Blob]) -> BlobSidecars:
-     *   return BlobSidecars(
-     *       beacon_block_root=hash_tree_root(block),
-     *       beacon_block_slot=block.slot,
-     *       blobs=blobs,
-     *       kzg_aggregated_proof=compute_proof_from_blobs(blobs),
-     *   )
-     */
-    getContents(beaconBlock) {
-        const blockHash = toRootHex(beaconBlock.body.executionPayload.blockHash);
-        const contents = this.producedContentsCache.get(blockHash);
-        if (!contents) {
-            throw Error(`No contents for executionPayload.blockHash ${blockHash}`);
-        }
-        return contents;
-    }
     async processBlock(block, opts) {
         return this.blockProcessor.processBlocksJob([block], opts);
     }
@@ -514,6 +500,7 @@ export class BeaconChain {
             // TODO: PERFORMANCE: Memoize to prevent re-computing every time
             headRoot: fromHex(head.blockRoot),
             headSlot: head.slot,
+            earliestAvailableSlot: this._earliestAvailableSlot,
         };
     }
     recomputeForkChoiceHead(caller) {
@@ -744,16 +731,10 @@ export class BeaconChain {
         // syncContributionAndProofPool tracks metrics on its own
         metrics.opPool.blsToExecutionChangePoolSize.set(this.opPool.blsToExecutionChangeSize);
         metrics.chain.blacklistedBlocks.set(this.blacklistedBlocks.size);
-        const forkChoiceMetrics = this.forkChoice.getMetrics();
-        metrics.forkChoice.votes.set(forkChoiceMetrics.votes);
-        metrics.forkChoice.queuedAttestations.set(forkChoiceMetrics.queuedAttestations);
-        metrics.forkChoice.validatedAttestationDatas.set(forkChoiceMetrics.validatedAttestationDatas);
-        metrics.forkChoice.balancesLength.set(forkChoiceMetrics.balancesLength);
-        metrics.forkChoice.nodes.set(forkChoiceMetrics.nodes);
-        metrics.forkChoice.indices.set(forkChoiceMetrics.indices);
-        const fork = this.config.getForkName(this.clock.currentSlot);
+        const headState = this.getHeadState();
+        const fork = this.config.getForkName(headState.slot);
         if (isForkPostElectra(fork)) {
-            const headStateElectra = this.getHeadState();
+            const headStateElectra = headState;
             metrics.pendingDeposits.set(headStateElectra.pendingDeposits.length);
             metrics.pendingPartialWithdrawals.set(headStateElectra.pendingPartialWithdrawals.length);
             metrics.pendingConsolidations.set(headStateElectra.pendingConsolidations.length);
@@ -774,14 +755,8 @@ export class BeaconChain {
         this.seenAttestationDatas.onSlot(slot);
         this.reprocessController.onSlot(slot);
         // Prune old cached block production artifacts, those are only useful on their slot
-        pruneSetToMax(this.producedBlockRoot, this.opts.maxCachedProducedRoots ?? DEFAULT_MAX_CACHED_PRODUCED_ROOTS);
-        this.metrics?.blockProductionCaches.producedBlockRoot.set(this.producedBlockRoot.size);
-        pruneSetToMax(this.producedBlindedBlockRoot, this.opts.maxCachedProducedRoots ?? DEFAULT_MAX_CACHED_PRODUCED_ROOTS);
-        this.metrics?.blockProductionCaches.producedBlindedBlockRoot.set(this.producedBlindedBlockRoot.size);
-        if (this.config.getForkSeq(slot) >= ForkSeq.deneb) {
-            pruneSetToMax(this.producedContentsCache, this.opts.maxCachedProducedRoots ?? DEFAULT_MAX_CACHED_PRODUCED_ROOTS);
-            this.metrics?.blockProductionCaches.producedContentsCache.set(this.producedContentsCache.size);
-        }
+        pruneSetToMax(this.blockProductionCache, this.opts.maxCachedProducedRoots ?? DEFAULT_MAX_CACHED_PRODUCED_RESULTS);
+        this.metrics?.blockProductionCacheSize.set(this.blockProductionCache.size);
         const metrics = this.metrics;
         if (metrics && (slot + 1) % SLOTS_PER_EPOCH === 0) {
             // On the last slot of the epoch
@@ -821,6 +796,8 @@ export class BeaconChain {
     async onForkChoiceFinalized(cp) {
         this.logger.verbose("Fork choice finalized", { epoch: cp.epoch, root: cp.rootHex });
         this.seenBlockProposers.prune(computeStartSlotAtEpoch(cp.epoch));
+        // 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);
@@ -836,9 +813,65 @@ export class BeaconChain {
         }
     }
     async updateBeaconProposerData(epoch, proposers) {
+        const previousValidatorCount = this.beaconProposerCache.getValidatorIndices().length;
         for (const proposer of proposers) {
             this.beaconProposerCache.add(epoch, proposer);
         }
+        const newValidatorCount = this.beaconProposerCache.getValidatorIndices().length;
+        // Only update validator custody if we discovered new validators
+        if (newValidatorCount > previousValidatorCount) {
+            const finalizedCheckpoint = this.forkChoice.getFinalizedCheckpoint();
+            await this.updateValidatorsCustodyRequirement(finalizedCheckpoint);
+        }
+    }
+    async updateValidatorsCustodyRequirement(finalizedCheckpoint) {
+        if (this.opts.supernode) {
+            // Disable dynamic custody updates for supernodes since they must maintain custody
+            // of all custody groups regardless of validator effective balances
+            return;
+        }
+        // Validators attached to the node
+        const validatorIndices = this.beaconProposerCache.getValidatorIndices();
+        // Update custody requirement based on finalized state
+        let effectiveBalances;
+        const effectiveBalanceIncrements = this.checkpointBalancesCache.get(finalizedCheckpoint);
+        if (effectiveBalanceIncrements) {
+            effectiveBalances = validatorIndices.map((index) => (effectiveBalanceIncrements[index] ?? 0) * EFFECTIVE_BALANCE_INCREMENT);
+        }
+        else {
+            // If there's no cached effective balances, get the state from disk and parse them out
+            this.logger.debug("No cached finalized effective balances to update target custody group count", {
+                finalizedEpoch: finalizedCheckpoint.epoch,
+                finalizedRoot: finalizedCheckpoint.rootHex,
+            });
+            const stateOrBytes = (await this.getStateOrBytesByCheckpoint(finalizedCheckpoint))?.state;
+            if (!stateOrBytes) {
+                // If even the state is not available, we cannot update the custody group count
+                this.logger.debug("No finalized state or bytes available to update target custody group count", {
+                    finalizedEpoch: finalizedCheckpoint.epoch,
+                    finalizedRoot: finalizedCheckpoint.rootHex,
+                });
+                return;
+            }
+            if (stateOrBytes instanceof Uint8Array) {
+                effectiveBalances = getEffectiveBalancesFromStateBytes(this.config, stateOrBytes, validatorIndices);
+            }
+            else {
+                effectiveBalances = validatorIndices.map((index) => stateOrBytes.validators.get(index).effectiveBalance ?? 0);
+            }
+        }
+        const targetCustodyGroupCount = getValidatorsCustodyRequirement(this.config, effectiveBalances);
+        // Only update if target is increased
+        if (targetCustodyGroupCount > this.custodyConfig.targetCustodyGroupCount) {
+            this.custodyConfig.updateTargetCustodyGroupCount(targetCustodyGroupCount);
+            this.metrics?.peerDas.targetCustodyGroupCount.set(targetCustodyGroupCount);
+            this.logger.verbose("Updated target custody group count", {
+                finalizedEpoch: finalizedCheckpoint.epoch,
+                validatorCount: validatorIndices.length,
+                targetCustodyGroupCount,
+            });
+            this.emitter.emit(ChainEvent.updateTargetCustodyGroupCount, targetCustodyGroupCount);
+        }
     }
     updateBuilderStatus(clockSlot) {
         const executionBuilder = this.executionBuilder;
@@ -847,7 +880,7 @@ export class BeaconChain {
             const slotsPresent = this.forkChoice.getSlotsPresent(clockSlot - faultInspectionWindow);
             const previousStatus = executionBuilder.status;
             const shouldEnable = slotsPresent >= Math.min(faultInspectionWindow - allowedFaults, clockSlot);
-            executionBuilder.updateStatus(shouldEnable);
+            executionBuilder.updateStatus(shouldEnable ? BuilderStatus.enabled : BuilderStatus.circuitBreaker);
             // The status changed we should log
             const status = executionBuilder.status;
             const builderLog = {
@@ -857,10 +890,10 @@ export class BeaconChain {
                 allowedFaults,
             };
             if (status !== previousStatus) {
-                this.logger.info("Execution builder status updated", builderLog);
+                this.logger.info("External builder status updated", builderLog);
             }
             else {
-                this.logger.verbose("Execution builder status", builderLog);
+                this.logger.verbose("External builder status", builderLog);
             }
         }
     }