@lodestar/beacon-node 1.40.0-dev.1cab20c166 → 1.40.0-dev.2a72cee670

package/src/chain/errors/attestationError.ts

@@ -139,6 +139,14 @@ export enum AttestationErrorCode {
    * Electra: Attester not in committee
    */
   ATTESTER_NOT_IN_COMMITTEE = "ATTESTATION_ERROR_ATTESTER_NOT_IN_COMMITTEE",
+  /**
+   * Gloas: Invalid attestationData index: is non-zero and non-one
+   */
+  INVALID_PAYLOAD_STATUS_VALUE = "ATTESTATION_ERROR_INVALID_PAYLOAD_STATUS_VALUE",
+  /**
+   * Gloas: Current slot attestation is marking payload as present
+   */
+  PREMATURELY_INDICATED_PAYLOAD_PRESENT = "ATTESTATION_ERROR_PREMATURELY_INDICATED_PAYLOAD_PRESENT",
 }
 
 export type AttestationErrorType =
@@ -175,7 +183,9 @@ export type AttestationErrorType =
   | {code: AttestationErrorCode.TOO_MANY_SKIPPED_SLOTS; headBlockSlot: Slot; attestationSlot: Slot}
   | {code: AttestationErrorCode.NOT_EXACTLY_ONE_COMMITTEE_BIT_SET}
   | {code: AttestationErrorCode.NON_ZERO_ATTESTATION_DATA_INDEX}
-  | {code: AttestationErrorCode.ATTESTER_NOT_IN_COMMITTEE};
+  | {code: AttestationErrorCode.ATTESTER_NOT_IN_COMMITTEE}
+  | {code: AttestationErrorCode.INVALID_PAYLOAD_STATUS_VALUE; attDataIndex: number}
+  | {code: AttestationErrorCode.PREMATURELY_INDICATED_PAYLOAD_PRESENT};
 
 export class AttestationError extends GossipActionError<AttestationErrorType> {
   getMetadata(): Record<string, string | number | null> {

package/src/chain/errors/executionPayloadBid.ts

@@ -0,0 +1,35 @@
+import {BuilderIndex, RootHex, Slot} from "@lodestar/types";
+import {GossipActionError} from "./gossipValidation.ts";
+
+export enum ExecutionPayloadBidErrorCode {
+  BUILDER_NOT_ELIGIBLE = "EXECUTION_PAYLOAD_BID_ERROR_BUILDER_NOT_ELIGIBLE",
+  NON_ZERO_EXECUTION_PAYMENT = "EXECUTION_PAYLOAD_BID_ERROR_NON_ZERO_EXECUTION_PAYMENT",
+  BID_ALREADY_KNOWN = "EXECUTION_PAYLOAD_BID_ERROR_BID_ALREADY_KNOWN",
+  BID_TOO_LOW = "EXECUTION_PAYLOAD_BID_ERROR_BID_TOO_LOW",
+  BID_TOO_HIGH = "EXECUTION_PAYLOAD_BID_ERROR_BID_TOO_HIGH",
+  UNKNOWN_BLOCK_ROOT = "EXECUTION_PAYLOAD_BID_ERROR_UNKNOWN_BLOCK_ROOT",
+  INVALID_SLOT = "EXECUTION_PAYLOAD_BID_ERROR_INVALID_SLOT",
+  INVALID_SIGNATURE = "EXECUTION_PAYLOAD_BID_ERROR_INVALID_SIGNATURE",
+}
+
+export type ExecutionPayloadBidErrorType =
+  | {code: ExecutionPayloadBidErrorCode.BUILDER_NOT_ELIGIBLE; builderIndex: BuilderIndex}
+  | {
+      code: ExecutionPayloadBidErrorCode.NON_ZERO_EXECUTION_PAYMENT;
+      builderIndex: BuilderIndex;
+      executionPayment: number;
+    }
+  | {
+      code: ExecutionPayloadBidErrorCode.BID_ALREADY_KNOWN;
+      builderIndex: BuilderIndex;
+      slot: Slot;
+      parentBlockRoot: RootHex;
+      parentBlockHash: RootHex;
+    }
+  | {code: ExecutionPayloadBidErrorCode.BID_TOO_LOW; bidValue: number; currentHighestBid: number}
+  | {code: ExecutionPayloadBidErrorCode.BID_TOO_HIGH; bidValue: number; builderBalance: number}
+  | {code: ExecutionPayloadBidErrorCode.UNKNOWN_BLOCK_ROOT; parentBlockRoot: RootHex}
+  | {code: ExecutionPayloadBidErrorCode.INVALID_SLOT; builderIndex: BuilderIndex; slot: Slot}
+  | {code: ExecutionPayloadBidErrorCode.INVALID_SIGNATURE; builderIndex: BuilderIndex; slot: Slot};
+
+export class ExecutionPayloadBidError extends GossipActionError<ExecutionPayloadBidErrorType> {}

package/src/chain/errors/executionPayloadEnvelope.ts

@@ -0,0 +1,34 @@
+import {BuilderIndex, RootHex, Slot} from "@lodestar/types";
+import {GossipActionError} from "./gossipValidation.js";
+
+export enum ExecutionPayloadEnvelopeErrorCode {
+  BELONG_TO_FINALIZED_BLOCK = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_BELONG_TO_FINALIZED_BLOCK",
+  BLOCK_ROOT_UNKNOWN = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_BLOCK_ROOT_UNKNOWN",
+  ENVELOPE_ALREADY_KNOWN = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_ALREADY_KNOWN",
+  INVALID_BLOCK = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_INVALID_BLOCK",
+  SLOT_MISMATCH = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_SLOT_MISMATCH",
+  BUILDER_INDEX_MISMATCH = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_BUILDER_INDEX_MISMATCH",
+  BLOCK_HASH_MISMATCH = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_BLOCK_HASH_MISMATCH",
+  INVALID_SIGNATURE = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_INVALID_SIGNATURE",
+  CACHE_FAIL = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_CACHE_FAIL",
+}
+export type ExecutionPayloadEnvelopeErrorType =
+  | {code: ExecutionPayloadEnvelopeErrorCode.BELONG_TO_FINALIZED_BLOCK; envelopeSlot: Slot; finalizedSlot: Slot}
+  | {code: ExecutionPayloadEnvelopeErrorCode.BLOCK_ROOT_UNKNOWN; blockRoot: RootHex}
+  | {
+      code: ExecutionPayloadEnvelopeErrorCode.ENVELOPE_ALREADY_KNOWN;
+      blockRoot: RootHex;
+      slot: Slot;
+    }
+  | {code: ExecutionPayloadEnvelopeErrorCode.INVALID_BLOCK; blockRoot: RootHex}
+  | {code: ExecutionPayloadEnvelopeErrorCode.SLOT_MISMATCH; envelopeSlot: Slot; blockSlot: Slot}
+  | {
+      code: ExecutionPayloadEnvelopeErrorCode.BUILDER_INDEX_MISMATCH;
+      envelopeBuilderIndex: BuilderIndex;
+      bidBuilderIndex: BuilderIndex;
+    }
+  | {code: ExecutionPayloadEnvelopeErrorCode.BLOCK_HASH_MISMATCH; envelopeBlockHash: RootHex; bidBlockHash: RootHex}
+  | {code: ExecutionPayloadEnvelopeErrorCode.INVALID_SIGNATURE}
+  | {code: ExecutionPayloadEnvelopeErrorCode.CACHE_FAIL; blockRoot: RootHex};
+
+export class ExecutionPayloadEnvelopeError extends GossipActionError<ExecutionPayloadEnvelopeErrorType> {}

package/src/chain/errors/index.ts

@@ -4,7 +4,10 @@ export * from "./blobSidecarError.js";
 export * from "./blockError.js";
 export * from "./blsToExecutionChangeError.js";
 export * from "./dataColumnSidecarError.js";
+export * from "./executionPayloadBid.js";
+export * from "./executionPayloadEnvelope.js";
 export * from "./gossipValidation.js";
+export * from "./payloadAttestation.js";
 export * from "./proposerSlashingError.js";
 export * from "./syncCommitteeError.js";
 export * from "./voluntaryExitError.js";

package/src/chain/errors/payloadAttestation.ts

@@ -0,0 +1,25 @@
+import {RootHex, Slot, ValidatorIndex} from "@lodestar/types";
+import {GossipActionError} from "./gossipValidation.ts";
+
+export enum PayloadAttestationErrorCode {
+  NOT_CURRENT_SLOT = "PAYLOAD_ATTESTATION_ERROR_NOT_CURRENT_SLOT",
+  PAYLOAD_ATTESTATION_ALREADY_KNOWN = "PAYLOAD_ATTESTATION_ERROR_PAYLOAD_ATTESTATION_ALREADY_KNOWN",
+  UNKNOWN_BLOCK_ROOT = "PAYLOAD_ATTESTATION_ERROR_UNKNOWN_BLOCK_ROOT",
+  INVALID_BLOCK = "PAYLOAD_ATTESTATION_ERROR_INVALID_BLOCK",
+  INVALID_ATTESTER = "PAYLOAD_ATTESTATION_ERROR_INVALID_ATTESTER",
+  INVALID_SIGNATURE = "PAYLOAD_ATTESTATION_ERROR_INVALID_SIGNATURE",
+}
+export type PayloadAttestationErrorType =
+  | {code: PayloadAttestationErrorCode.NOT_CURRENT_SLOT; currentSlot: Slot; slot: Slot}
+  | {
+      code: PayloadAttestationErrorCode.PAYLOAD_ATTESTATION_ALREADY_KNOWN;
+      validatorIndex: ValidatorIndex;
+      slot: Slot;
+      blockRoot: RootHex;
+    }
+  | {code: PayloadAttestationErrorCode.UNKNOWN_BLOCK_ROOT; blockRoot: RootHex}
+  | {code: PayloadAttestationErrorCode.INVALID_BLOCK; blockRoot: RootHex}
+  | {code: PayloadAttestationErrorCode.INVALID_ATTESTER; attesterIndex: ValidatorIndex}
+  | {code: PayloadAttestationErrorCode.INVALID_SIGNATURE};
+
+export class PayloadAttestationError extends GossipActionError<PayloadAttestationErrorType> {}

package/src/chain/forkChoice/index.ts

@@ -11,6 +11,7 @@ import {
 import {ZERO_HASH_HEX} from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
+  CachedBeaconStateGloas,
   DataAvailabilityStatus,
   computeAnchorCheckpoint,
   computeEpochAtSlot,
@@ -144,6 +145,15 @@ export function initializeForkChoiceFromFinalizedState(
           : {executionPayloadBlockHash: null, executionStatus: ExecutionStatus.PreMerge}),
 
         dataAvailabilityStatus: DataAvailabilityStatus.PreData,
+        ...(computeEpochAtSlot(blockHeader.slot) < state.config.GLOAS_FORK_EPOCH
+          ? {
+              builderIndex: undefined,
+              blockHashHex: undefined,
+            }
+          : {
+              builderIndex: (state as CachedBeaconStateGloas).latestExecutionPayloadBid.builderIndex,
+              blockHashHex: toRootHex((state as CachedBeaconStateGloas).latestExecutionPayloadBid.blockHash),
+            }),
       },
       currentSlot
     ),
@@ -225,6 +235,15 @@ export function initializeForkChoiceFromUnfinalizedState(
       : {executionPayloadBlockHash: null, executionStatus: ExecutionStatus.PreMerge}),
 
     dataAvailabilityStatus: DataAvailabilityStatus.PreData,
+    ...(computeEpochAtSlot(blockHeader.slot) < unfinalizedState.config.GLOAS_FORK_EPOCH
+      ? {
+          builderIndex: undefined,
+          blockHashHex: undefined,
+        }
+      : {
+          builderIndex: (unfinalizedState as CachedBeaconStateGloas).latestExecutionPayloadBid.builderIndex,
+          blockHashHex: toRootHex((unfinalizedState as CachedBeaconStateGloas).latestExecutionPayloadBid.blockHash),
+        }),
   };
 
   const parentSlot = blockHeader.slot - 1;

package/src/chain/interface.ts

@@ -46,7 +46,14 @@ import {ForkchoiceCaller} from "./forkChoice/index.js";
 import {GetBlobsTracker} from "./GetBlobsTracker.js";
 import {LightClientServer} from "./lightClient/index.js";
 import {AggregatedAttestationPool} from "./opPools/aggregatedAttestationPool.js";
-import {AttestationPool, OpPool, SyncCommitteeMessagePool, SyncContributionAndProofPool} from "./opPools/index.js";
+import {
+  AttestationPool,
+  ExecutionPayloadBidPool,
+  OpPool,
+  PayloadAttestationPool,
+  SyncCommitteeMessagePool,
+  SyncContributionAndProofPool,
+} from "./opPools/index.js";
 import {IChainOptions} from "./options.js";
 import {AssembledBlockType, BlockAttributes, BlockType, ProduceResult} from "./produceBlock/produceBlockBody.js";
 import {IStateRegenerator, RegenCaller} from "./regen/index.js";
@@ -56,6 +63,9 @@ import {
   SeenAttesters,
   SeenBlockProposers,
   SeenContributionAndProof,
+  SeenExecutionPayloadBids,
+  SeenExecutionPayloadEnvelopes,
+  SeenPayloadAttesters,
   SeenSyncCommitteeMessages,
 } from "./seenCache/index.js";
 import {SeenAggregatedAttestations} from "./seenCache/seenAggregateAndProof.js";
@@ -116,12 +126,17 @@ export interface IBeaconChain {
   readonly aggregatedAttestationPool: AggregatedAttestationPool;
   readonly syncCommitteeMessagePool: SyncCommitteeMessagePool;
   readonly syncContributionAndProofPool: SyncContributionAndProofPool;
+  readonly executionPayloadBidPool: ExecutionPayloadBidPool;
+  readonly payloadAttestationPool: PayloadAttestationPool;
   readonly opPool: OpPool;
 
   // Gossip seen cache
   readonly seenAttesters: SeenAttesters;
   readonly seenAggregators: SeenAggregators;
+  readonly seenPayloadAttesters: SeenPayloadAttesters;
   readonly seenAggregatedAttestations: SeenAggregatedAttestations;
+  readonly seenExecutionPayloadEnvelopes: SeenExecutionPayloadEnvelopes;
+  readonly seenExecutionPayloadBids: SeenExecutionPayloadBids;
   readonly seenBlockProposers: SeenBlockProposers;
   readonly seenSyncCommitteeMessages: SeenSyncCommitteeMessages;
   readonly seenContributionAndProof: SeenContributionAndProof;

package/src/chain/opPools/executionPayloadBidPool.ts

@@ -0,0 +1,77 @@
+import {Slot, gloas} from "@lodestar/types";
+import {MapDef, toRootHex} from "@lodestar/utils";
+import {InsertOutcome} from "./types.js";
+import {pruneBySlot} from "./utils.js";
+
+/**
+ * TODO GLOAS: Revisit this value and add rational for choosing it
+ */
+const SLOTS_RETAINED = 2;
+
+type BlockRootHex = string;
+type BlockHashHex = string;
+
+/**
+ * Store the best execution payload bid per slot / (parent block root, parent block hash).
+ */
+export class ExecutionPayloadBidPool {
+  private readonly bidByParentHashByParentRootBySlot = new MapDef<
+    Slot,
+    MapDef<BlockRootHex, Map<BlockHashHex, gloas.ExecutionPayloadBid>>
+  >(() => new MapDef<BlockRootHex, Map<BlockHashHex, gloas.ExecutionPayloadBid>>(() => new Map()));
+  private lowestPermissibleSlot = 0;
+
+  get size(): number {
+    let count = 0;
+    for (const byParentRoot of this.bidByParentHashByParentRootBySlot.values()) {
+      for (const byParentHash of byParentRoot.values()) {
+        count += byParentHash.size;
+      }
+    }
+    return count;
+  }
+
+  add(bid: gloas.ExecutionPayloadBid): InsertOutcome {
+    const {slot, parentBlockRoot, parentBlockHash, value} = bid;
+    const lowestPermissibleSlot = this.lowestPermissibleSlot;
+
+    if (slot < lowestPermissibleSlot) {
+      return InsertOutcome.Old;
+    }
+
+    const parentRootHex = toRootHex(parentBlockRoot);
+    const parentHashHex = toRootHex(parentBlockHash);
+    const bidByParentHash = this.bidByParentHashByParentRootBySlot.getOrDefault(slot).getOrDefault(parentRootHex);
+    const existing = bidByParentHash.get(parentHashHex);
+
+    if (existing) {
+      const existingValue = existing.value;
+      const newValue = value;
+      if (newValue > existingValue) {
+        bidByParentHash.set(parentHashHex, bid);
+        return InsertOutcome.NewData;
+      }
+      return newValue === existingValue ? InsertOutcome.AlreadyKnown : InsertOutcome.NotBetterThan;
+    }
+
+    bidByParentHash.set(parentHashHex, bid);
+    return InsertOutcome.NewData;
+  }
+
+  /**
+   * Return the highest-value bid matching slot, parent block root, and parent block hash.
+   * Used for gossip validation and block production.
+   */
+  getBestBid(
+    parentBlockRoot: BlockRootHex,
+    parentBlockHash: BlockHashHex,
+    slot: Slot
+  ): gloas.ExecutionPayloadBid | null {
+    const bidByParentHash = this.bidByParentHashByParentRootBySlot.get(slot)?.get(parentBlockRoot);
+    return bidByParentHash?.get(parentBlockHash) ?? null;
+  }
+
+  prune(clockSlot: Slot): void {
+    this.lowestPermissibleSlot = pruneBySlot(this.bidByParentHashByParentRootBySlot, clockSlot, SLOTS_RETAINED);
+  }
+}

package/src/chain/opPools/index.ts

@@ -1,5 +1,7 @@
 export {AggregatedAttestationPool} from "./aggregatedAttestationPool.js";
 export {AttestationPool} from "./attestationPool.js";
+export {ExecutionPayloadBidPool} from "./executionPayloadBidPool.js";
 export {OpPool} from "./opPool.js";
+export {PayloadAttestationPool} from "./payloadAttestationPool.js";
 export {SyncCommitteeMessagePool} from "./syncCommitteeMessagePool.js";
 export {SyncContributionAndProofPool} from "./syncContributionAndProofPool.js";

package/src/chain/opPools/payloadAttestationPool.ts

@@ -0,0 +1,157 @@
+import {Signature, aggregateSignatures} from "@chainsafe/blst";
+import {BitArray} from "@chainsafe/ssz";
+import {ChainForkConfig} from "@lodestar/config";
+import {MAX_COMMITTEES_PER_SLOT, PTC_SIZE} from "@lodestar/params";
+import {RootHex, Slot, gloas} from "@lodestar/types";
+import {MapDef, toRootHex} from "@lodestar/utils";
+import {Metrics} from "../../metrics/metrics.js";
+import {IClock} from "../../util/clock.js";
+import {InsertOutcome, OpPoolError, OpPoolErrorCode} from "./types.js";
+import {pruneBySlot, signatureFromBytesNoCheck} from "./utils.js";
+
+/**
+ * TODO GLOAS: Revisit this value and add rational for choosing it
+ */
+const SLOTS_RETAINED = 2;
+
+/**
+ * The maximum number of distinct `PayloadAttestationData` that will be stored in each slot.
+ *
+ * This is a DoS protection measure.
+ */
+// TODO GLOAS: Revisit this value. Educated guess would be MAX_ATTESTATIONS_PER_SLOT in AttestationPool divided by MAX_COMMITTEES_PER_SLOT
+const MAX_PAYLOAD_ATTESTATIONS_PER_SLOT = 16_384 / MAX_COMMITTEES_PER_SLOT;
+
+type DataRootHex = string;
+type BlockRootHex = string;
+
+type AggregateFast = {
+  aggregationBits: BitArray;
+  data: gloas.PayloadAttestationData;
+  signature: Signature;
+};
+
+export class PayloadAttestationPool {
+  private readonly aggregateByDataRootByBlockRootBySlot = new MapDef<
+    Slot,
+    Map<BlockRootHex, Map<DataRootHex, AggregateFast>>
+  >(() => new Map<BlockRootHex, Map<DataRootHex, AggregateFast>>());
+  private lowestPermissibleSlot = 0;
+
+  constructor(
+    private readonly config: ChainForkConfig,
+    private readonly clock: IClock,
+    private readonly metrics: Metrics | null = null
+  ) {}
+
+  get size(): number {
+    let count = 0;
+    for (const aggregateByDataRootByBlockRoot of this.aggregateByDataRootByBlockRootBySlot.values()) {
+      for (const aggregateByDataRoot of aggregateByDataRootByBlockRoot.values()) {
+        count += aggregateByDataRoot.size;
+      }
+    }
+    return count;
+  }
+
+  add(
+    message: gloas.PayloadAttestationMessage,
+    payloadAttDataRootHex: RootHex,
+    validatorCommitteeIndex: number
+  ): InsertOutcome {
+    const slot = message.data.slot;
+    const lowestPermissibleSlot = this.lowestPermissibleSlot;
+
+    if (slot < lowestPermissibleSlot) {
+      return InsertOutcome.Old;
+    }
+
+    if (slot < this.clock.slotWithPastTolerance(this.config.MAXIMUM_GOSSIP_CLOCK_DISPARITY / 1000)) {
+      return InsertOutcome.Late;
+    }
+
+    const aggregateByDataRootByBlockRoot = this.aggregateByDataRootByBlockRootBySlot.getOrDefault(slot);
+    let aggregateByDataRoot = aggregateByDataRootByBlockRoot.get(toRootHex(message.data.beaconBlockRoot));
+
+    if (!aggregateByDataRoot) {
+      aggregateByDataRoot = new Map<DataRootHex, AggregateFast>();
+      aggregateByDataRootByBlockRoot.set(toRootHex(message.data.beaconBlockRoot), aggregateByDataRoot);
+    }
+
+    if (aggregateByDataRoot.size >= MAX_PAYLOAD_ATTESTATIONS_PER_SLOT) {
+      throw new OpPoolError({code: OpPoolErrorCode.REACHED_MAX_PER_SLOT});
+    }
+
+    const aggregate = aggregateByDataRoot.get(payloadAttDataRootHex);
+    if (aggregate) {
+      // Aggregate msg into aggregate
+      return aggregateMessageInto(message, validatorCommitteeIndex, aggregate);
+    }
+    // Create a new aggregate with data
+    aggregateByDataRoot.set(payloadAttDataRootHex, messageToAggregate(message, validatorCommitteeIndex));
+
+    return InsertOutcome.NewData;
+  }
+
+  /**
+   * Get payload attestations to be included in a block.
+   * Pick the top `maxAttestation` number of attestations with the most votes
+   */
+  getPayloadAttestationsForBlock(
+    beaconBlockRoot: BlockRootHex,
+    slot: Slot,
+    maxAttestation: number
+  ): gloas.PayloadAttestation[] {
+    const aggregateByDataRootByBlockRoot = this.aggregateByDataRootByBlockRootBySlot.get(slot);
+
+    if (!aggregateByDataRootByBlockRoot) {
+      this.metrics?.opPool.payloadAttestationPool.getPayloadAttestationsCacheMisses.inc();
+      return [];
+    }
+
+    const aggregateByDataRoot = aggregateByDataRootByBlockRoot.get(beaconBlockRoot);
+
+    if (!aggregateByDataRoot) {
+      this.metrics?.opPool.payloadAttestationPool.getPayloadAttestationsCacheMisses.inc();
+      return [];
+    }
+
+    return Array.from(aggregateByDataRoot.values())
+      .slice()
+      .sort((a, b) => b.aggregationBits.getTrueBitIndexes().length - a.aggregationBits.getTrueBitIndexes().length)
+      .slice(0, maxAttestation)
+      .map(fastToPayloadAttestation);
+  }
+
+  prune(clockSlot: Slot): void {
+    pruneBySlot(this.aggregateByDataRootByBlockRootBySlot, clockSlot, SLOTS_RETAINED);
+    this.lowestPermissibleSlot = clockSlot;
+  }
+}
+
+function messageToAggregate(message: gloas.PayloadAttestationMessage, validatorCommitteeIndex: number): AggregateFast {
+  return {
+    aggregationBits: BitArray.fromSingleBit(PTC_SIZE, validatorCommitteeIndex),
+    data: message.data,
+    signature: signatureFromBytesNoCheck(message.signature),
+  };
+}
+
+function aggregateMessageInto(
+  message: gloas.PayloadAttestationMessage,
+  validatorCommitteeIndex: number,
+  aggregate: AggregateFast
+): InsertOutcome {
+  if (aggregate.aggregationBits.get(validatorCommitteeIndex) === true) {
+    return InsertOutcome.AlreadyKnown;
+  }
+
+  aggregate.aggregationBits.set(validatorCommitteeIndex, true);
+  aggregate.signature = aggregateSignatures([aggregate.signature, signatureFromBytesNoCheck(message.signature)]);
+
+  return InsertOutcome.Aggregated;
+}
+
+function fastToPayloadAttestation(aggFast: AggregateFast): gloas.PayloadAttestation {
+  return {...aggFast, signature: aggFast.signature.toBytes()};
+}

package/src/chain/options.ts

@@ -45,7 +45,6 @@ export type IChainOptions = BlockProcessOpts &
     broadcastValidationStrictness?: string;
     minSameMessageSignatureSetsToBatch: number;
     archiveDateEpochs?: number;
-    nHistoricalStates?: boolean;
     nHistoricalStatesFileDataStore?: boolean;
   };
 
@@ -119,7 +118,6 @@ export const defaultChainOptions: IChainOptions = {
   // batching too much may block the I/O thread so if useWorker=false, suggest this value to be 32
   // since this batch attestation work is designed to work with useWorker=true, make this the lowest value
   minSameMessageSignatureSetsToBatch: 2,
-  nHistoricalStates: true,
   // as of Feb 2025, this option turned out to be very useful:
   //   - it allows to share a persisted checkpoint state to other nodes
   //   - users can prune the persisted checkpoint state files manually to save disc space

package/src/chain/regen/interface.ts

@@ -2,7 +2,7 @@ import {routes} from "@lodestar/api";
 import {ProtoBlock} from "@lodestar/fork-choice";
 import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
 import {BeaconBlock, Epoch, RootHex, Slot, phase0} from "@lodestar/types";
-import {CheckpointHex} from "../stateCache/index.js";
+import {CheckpointHex} from "../stateCache/types.js";
 
 export enum RegenCaller {
   getDuties = "getDuties",
@@ -18,6 +18,7 @@ export enum RegenCaller {
   validateGossipAggregateAndProof = "validateGossipAggregateAndProof",
   validateGossipAttestation = "validateGossipAttestation",
   validateGossipVoluntaryExit = "validateGossipVoluntaryExit",
+  validateGossipExecutionPayloadBid = "validateGossipExecutionPayloadBid",
   onForkChoiceFinalized = "onForkChoiceFinalized",
   restApi = "restApi",
 }

package/src/chain/regen/queued.ts

@@ -5,8 +5,7 @@ import {BeaconBlock, Epoch, RootHex, Slot, phase0} from "@lodestar/types";
 import {Logger, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/index.js";
 import {JobItemQueue} from "../../util/queue/index.js";
-import {CheckpointHex} from "../stateCache/index.js";
-import {BlockStateCache, CheckpointStateCache} from "../stateCache/types.js";
+import {BlockStateCache, CheckpointHex, CheckpointStateCache} from "../stateCache/types.js";
 import {RegenError, RegenErrorCode} from "./errors.js";
 import {
   IStateRegenerator,

package/src/chain/regen/regen.ts

@@ -18,6 +18,7 @@ import {Metrics} from "../../metrics/index.js";
 import {nextEventLoop} from "../../util/eventLoop.js";
 import {getCheckpointFromState} from "../blocks/utils/checkpoint.js";
 import {ChainEvent, ChainEventEmitter} from "../emitter.js";
+import {SeenBlockInput} from "../seenCache/seenGossipBlockInput.js";
 import {BlockStateCache, CheckpointStateCache} from "../stateCache/types.js";
 import {ValidatorMonitor} from "../validatorMonitor.js";
 import {RegenError, RegenErrorCode} from "./errors.js";
@@ -28,6 +29,7 @@ export type RegenModules = {
   forkChoice: IForkChoice;
   blockStateCache: BlockStateCache;
   checkpointStateCache: CheckpointStateCache;
+  seenBlockInputCache: SeenBlockInput;
   config: ChainForkConfig;
   emitter: ChainEventEmitter;
   logger: Logger;
@@ -191,7 +193,10 @@ export class StateRegenerator implements IStateRegeneratorInternal {
     const protoBlocksAsc = blocksToReplay.reverse();
     for (const [i, protoBlock] of protoBlocksAsc.entries()) {
       replaySlots[i] = protoBlock.slot;
-      blockPromises[i] = this.modules.db.block.get(fromHex(protoBlock.blockRoot));
+      const blockInput = this.modules.seenBlockInputCache.get(protoBlock.blockRoot);
+      blockPromises[i] = blockInput?.hasBlock()
+        ? Promise.resolve(blockInput.getBlock())
+        : this.modules.db.block.get(fromHex(protoBlock.blockRoot));
     }
 
     const logCtx = {stateRoot, caller, replaySlots: replaySlots.join(",")};

package/src/chain/seenCache/index.ts

@@ -1,5 +1,7 @@
-export {SeenAggregators, SeenAttesters} from "./seenAttesters.js";
+export {SeenAggregators, SeenAttesters, SeenPayloadAttesters} from "./seenAttesters.js";
 export {SeenBlockProposers} from "./seenBlockProposers.js";
 export {SeenSyncCommitteeMessages} from "./seenCommittee.js";
 export {SeenContributionAndProof} from "./seenCommitteeContribution.js";
+export {SeenExecutionPayloadBids} from "./seenExecutionPayloadBids.js";
+export {SeenExecutionPayloadEnvelopes} from "./seenExecutionPayloadEnvelope.js";
 export {SeenBlockInput} from "./seenGossipBlockInput.js";

package/src/chain/seenCache/seenAttesters.ts

@@ -56,3 +56,8 @@ export class SeenAttesters {
  * Keeps a cache to filter aggregated attestations from the same aggregators in the same epoch
  */
 export class SeenAggregators extends SeenAttesters {}
+
+/**
+ * Keeps a cache to filter payload attestations from the same attesters in the same epoch
+ */
+export class SeenPayloadAttesters extends SeenAttesters {}

package/src/chain/seenCache/seenExecutionPayloadBids.ts

@@ -0,0 +1,35 @@
+import {BuilderIndex, Slot} from "@lodestar/types";
+import {MapDef} from "@lodestar/utils";
+
+/**
+ * TODO GLOAS: Revisit this value and add rational for choosing it
+ */
+const SLOTS_RETAINED = 2;
+
+/**
+ * Tracks execution payload bids we've already seen per (slot, builder).
+ */
+export class SeenExecutionPayloadBids {
+  private readonly builderIndexesBySlot = new MapDef<Slot, Set<BuilderIndex>>(() => new Set<BuilderIndex>());
+  private lowestPermissibleSlot: Slot = 0;
+
+  isKnown(slot: Slot, builderIndex: BuilderIndex): boolean {
+    return this.builderIndexesBySlot.get(slot)?.has(builderIndex) === true;
+  }
+
+  add(slot: Slot, builderIndex: BuilderIndex): void {
+    if (slot < this.lowestPermissibleSlot) {
+      throw Error(`slot ${slot} < lowestPermissibleSlot ${this.lowestPermissibleSlot}`);
+    }
+    this.builderIndexesBySlot.getOrDefault(slot).add(builderIndex);
+  }
+
+  prune(currentSlot: Slot): void {
+    this.lowestPermissibleSlot = Math.max(currentSlot - SLOTS_RETAINED, 0);
+    for (const slot of this.builderIndexesBySlot.keys()) {
+      if (slot < this.lowestPermissibleSlot) {
+        this.builderIndexesBySlot.delete(slot);
+      }
+    }
+  }
+}

package/src/chain/seenCache/seenExecutionPayloadEnvelope.ts

@@ -0,0 +1,34 @@
+import {RootHex, Slot} from "@lodestar/types";
+
+/**
+ * Cache to prevent processing multiple execution payload envelopes for the same block root.
+ * Only one builder qualifies to submit an execution payload for a given slot.
+ * We only keep track of envelopes of unfinalized slots.
+ * [IGNORE] The node has not seen another valid `SignedExecutionPayloadEnvelope` for this block root.
+ */
+export class SeenExecutionPayloadEnvelopes {
+  private readonly slotByBlockRoot = new Map<RootHex, Slot>();
+  private finalizedSlot: Slot = 0;
+
+  isKnown(blockRoot: RootHex): boolean {
+    return this.slotByBlockRoot.has(blockRoot);
+  }
+
+  add(blockRoot: RootHex, slot: Slot): void {
+    if (slot < this.finalizedSlot) {
+      throw Error(`slot ${slot} < finalizedSlot ${this.finalizedSlot}`);
+    }
+
+    this.slotByBlockRoot.set(blockRoot, slot);
+  }
+
+  prune(finalizedSlot: Slot): void {
+    this.finalizedSlot = finalizedSlot;
+
+    for (const [blockRoot, slot] of this.slotByBlockRoot.entries()) {
+      if (slot < finalizedSlot) {
+        this.slotByBlockRoot.delete(blockRoot);
+      }
+    }
+  }
+}

package/src/chain/seenCache/seenGossipBlockInput.ts

@@ -379,7 +379,7 @@ export class SeenBlockInput {
     let itemsToDelete = this.blockInputs.size - MAX_BLOCK_INPUT_CACHE_SIZE;
 
     if (itemsToDelete > 0) {
-      const sorted = [...this.blockInputs.entries()].sort((a, b) => b[1].slot - a[1].slot);
+      const sorted = [...this.blockInputs.entries()].sort((a, b) => a[1].slot - b[1].slot);
       for (const [rootHex] of sorted) {
         this.blockInputs.delete(rootHex);
         itemsToDelete--;

package/src/chain/stateCache/index.ts

@@ -1,3 +1 @@
-export * from "./blockStateCacheImpl.js";
 export * from "./fifoBlockStateCache.js";
-export * from "./inMemoryCheckpointsCache.js";