@lodestar/beacon-node 1.42.0 → 1.43.0-dev.05a33e512f

package/src/api/impl/lodestar/index.ts

@@ -3,7 +3,13 @@ import {ApplicationMethods} from "@lodestar/api/server";
 import {ChainForkConfig} from "@lodestar/config";
 import {Repository} from "@lodestar/db";
 import {ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
-import {ssz} from "@lodestar/types";
+import {
+  computeEpochAtSlot,
+  computeStartSlotAtEpoch,
+  getIndexedAttestation,
+  isStatePostCapella,
+} from "@lodestar/state-transition";
+import {Attestation, Epoch, IndexedAttestation, ssz} from "@lodestar/types";
 import {Checkpoint} from "@lodestar/types/phase0";
 import {fromHex, toHex, toRootHex} from "@lodestar/utils";
 import {BeaconChain} from "../../../chain/index.js";
@@ -15,6 +21,7 @@ import {ProfileThread, profileThread, writeHeapSnapshot} from "../../../util/pro
 import {getStateResponseWithRegen} from "../beacon/state/utils.js";
 import {ApiError} from "../errors.js";
 import {ApiModules} from "../types.js";
+import {getAttesterSlashingsFromIndexedAttestations} from "./attesterSlashing.js";
 
 export function getLodestarApi({
   chain,
@@ -111,7 +118,7 @@ export function getLodestarApi({
       return {
         // biome-ignore lint/complexity/useLiteralKeys: The `blockProcessor` is a protected attribute
         data: (chain as BeaconChain)["blockProcessor"].jobQueue.getItems().map((item) => {
-          const [blockInputs, opts] = item.args;
+          const [blockInputs, _payloadEnvelopes, opts] = item.args;
           return {
             blockSlots: blockInputs.map((blockInput) => blockInput.slot),
             jobOpts: opts,
@@ -218,6 +225,9 @@ export function getLodestarApi({
       if (ForkSeq[fork] < ForkSeq.capella) {
         throw new Error("Historical summaries are not supported before Capella");
       }
+      if (!isStatePostCapella(stateView)) {
+        throw new Error("Expected Capella state for historical summaries");
+      }
 
       const {gindex} = ssz[fork].BeaconState.getPathInfo(["historicalSummaries"]);
       const proof = stateView.getSingleProof(gindex);
@@ -269,6 +279,46 @@ export function getLodestarApi({
         },
       };
     },
+
+    async getAttesterSlashingsFromBlocks({signedBlocks}) {
+      const attestations = new Map<Epoch, Attestation[]>();
+
+      for (const block of signedBlocks) {
+        const attestationsOfABlock = block.message.body.attestations;
+        for (const attestation of attestationsOfABlock) {
+          const epoch = computeEpochAtSlot(attestation.data.slot);
+          let attestationsPerEpoch = attestations.get(epoch);
+          if (!attestationsPerEpoch) {
+            attestationsPerEpoch = [];
+            attestations.set(epoch, attestationsPerEpoch);
+          }
+          attestationsPerEpoch.push(attestation);
+        }
+      }
+
+      const indexedAttestations: IndexedAttestation[] = [];
+      // Assume all blocks are from the same fork
+      const forkSeq = config.getForkSeq(signedBlocks[0].message.slot);
+
+      for (const [epoch, attestationsPerEpoch] of attestations) {
+        const slot = computeStartSlotAtEpoch(epoch);
+        const {state} = await getStateResponseWithRegen(chain, slot);
+        const stateView = state instanceof Uint8Array ? chain.getHeadState().loadOtherState(state) : state;
+        const shuffling = stateView.getShufflingAtEpoch(epoch);
+        for (const attestation of attestationsPerEpoch) {
+          indexedAttestations.push(getIndexedAttestation(shuffling, forkSeq, attestation));
+        }
+      }
+
+      const result = getAttesterSlashingsFromIndexedAttestations(forkSeq, indexedAttestations);
+
+      return {
+        data: result,
+        meta: {
+          version: config.getForkName(signedBlocks[0].message.slot),
+        },
+      };
+    },
   };
 }
 

package/src/api/impl/validator/index.ts

@@ -25,6 +25,8 @@ import {
   computeStartSlotAtEpoch,
   computeTimeAtSlot,
   getCurrentSlot,
+  isStatePostAltair,
+  isStatePostGloas,
   proposerShufflingDecisionRoot,
 } from "@lodestar/state-transition";
 import {
@@ -69,7 +71,7 @@ import {ChainEvent, CommonBlockBody} from "../../../chain/index.js";
 import {PREPARE_NEXT_SLOT_BPS} from "../../../chain/prepareNextSlot.js";
 import {BlockType, ProduceFullDeneb, ProduceFullGloas} from "../../../chain/produceBlock/index.js";
 import {RegenCaller} from "../../../chain/regen/index.js";
-import {CheckpointHexPayload} from "../../../chain/stateCache/types.js";
+import {CheckpointHex} from "../../../chain/stateCache/types.js";
 import {validateApiAggregateAndProof} from "../../../chain/validation/index.js";
 import {validateSyncCommitteeGossipContributionAndProof} from "../../../chain/validation/syncCommitteeContributionAndProof.js";
 import {ZERO_HASH} from "../../../constants/index.js";
@@ -300,7 +302,7 @@ export function getValidatorApi(
    *                    |
    *              prepareNextSlot (4s before next slot)
    */
-  async function waitForCheckpointState(cpHex: CheckpointHexPayload): Promise<IBeaconStateView | null> {
+  async function waitForCheckpointState(cpHex: CheckpointHex): Promise<IBeaconStateView | null> {
     const cpState = chain.regen.getCheckpointStateSync(cpHex);
     if (cpState) {
       return cpState;
@@ -1048,6 +1050,36 @@ export function getValidatorApi(
       };
     },
 
+    async producePayloadAttestationData({slot}) {
+      const fork = config.getForkName(slot);
+      if (!isForkPostGloas(fork)) {
+        throw new ApiError(400, `producePayloadAttestationData is not supported before Gloas fork=${fork}`);
+      }
+
+      notWhileSyncing();
+      await waitForSlot(slot);
+
+      const block = chain.forkChoice.getCanonicalBlockClosestLteSlot(slot);
+      if (!block) {
+        throw new ApiError(404, `No canonical block found at or before slot=${slot}`);
+      }
+
+      const blockIsForSlot = block.slot === slot;
+      const payloadInput = chain.seenPayloadEnvelopeInputCache.get(block.blockRoot);
+      const payloadPresent = blockIsForSlot && (payloadInput?.hasPayloadEnvelope() ?? false);
+      const blobDataAvailable = blockIsForSlot && (payloadInput?.hasAllData() ?? false);
+
+      return {
+        data: {
+          beaconBlockRoot: fromHex(block.blockRoot),
+          slot,
+          payloadPresent,
+          blobDataAvailable,
+        },
+        meta: {version: fork},
+      };
+    },
+
     /**
      * GET `/eth/v1/validator/sync_committee_contribution`
      *
@@ -1112,7 +1144,6 @@ export function getValidatorApi(
         const cpState = await waitForCheckpointState({
           rootHex: head.blockRoot,
           epoch,
-          payloadPresent: head.payloadStatus === PayloadStatus.FULL,
         });
         if (cpState) {
           state = cpState;
@@ -1263,6 +1294,55 @@ export function getValidatorApi(
       };
     },
 
+    async getPtcDuties({epoch, indices}) {
+      notWhileSyncing();
+
+      if (indices.length === 0) {
+        throw new ApiError(400, "No validator to get PTC duties");
+      }
+
+      const startSlot = computeStartSlotAtEpoch(epoch);
+      const fork = config.getForkName(startSlot);
+      if (!isForkPostGloas(fork)) {
+        throw new ApiError(400, `PTC duties are not supported before Gloas fork=${fork}`);
+      }
+
+      await waitForNextClosestEpoch();
+
+      if (epoch > chain.clock.currentEpoch + 1) {
+        throw new ApiError(400, "Cannot get PTC duties for epoch more than one ahead");
+      }
+
+      const head = chain.forkChoice.getHead();
+      const state = await chain.getHeadStateAtCurrentEpoch(RegenCaller.getDuties);
+      if (!isStatePostGloas(state)) {
+        throw new ApiError(400, `PTC duties are not available before Gloas fork=${state.forkName}`);
+      }
+
+      const pubkeys = getPubkeysForIndices(state, indices);
+      const ptcs = state.getEpochPTCs(epoch);
+      const duties: routes.validator.PtcDuty[] = [];
+      for (let i = 0, len = indices.length; i < len; i++) {
+        const validatorIndex = indices[i];
+        for (let j = 0; j < SLOTS_PER_EPOCH; j++) {
+          if (ptcs[j].indexOf(validatorIndex) !== -1) {
+            duties.push({pubkey: pubkeys[i], validatorIndex, slot: j + startSlot});
+            break;
+          }
+        }
+      }
+
+      const dependentRoot = fromHex(state.getShufflingDecisionRoot(epoch)) || (await getGenesisBlockRoot(state));
+
+      return {
+        data: duties,
+        meta: {
+          dependentRoot: toRootHex(dependentRoot),
+          executionOptimistic: isOptimisticBlock(head),
+        },
+      };
+    },
+
     /**
      * `POST /eth/v1/validator/duties/sync/{epoch}`
      *
@@ -1282,6 +1362,9 @@ export function getValidatorApi(
       if (indices.length === 0) {
         throw new ApiError(400, "No validator to get attester duties");
       }
+      if (epoch < config.ALTAIR_FORK_EPOCH) {
+        throw new ApiError(400, "Sync committee duties are not supported before Altair");
+      }
 
       // May request for an epoch that's in the future
       await waitForNextClosestEpoch();
@@ -1291,6 +1374,9 @@ export function getValidatorApi(
       // Note: does not support requesting past duties
       const head = chain.forkChoice.getHead();
       const state = chain.getHeadState();
+      if (!isStatePostAltair(state)) {
+        throw new ApiError(400, "Sync committee duties are not available before Altair");
+      }
 
       // Check that all validatorIndex belong to the state before calling getCommitteeAssignments()
       const pubkeys = getPubkeysForIndices(state, indices);
@@ -1635,15 +1721,14 @@ export function getValidatorApi(
         throw Error("Cached block production result is not full block");
       }
 
-      const {executionPayload, executionRequests, envelopeStateRoot} = produceResult as ProduceFullGloas;
+      const {executionPayload, executionRequests, parentBlockRoot} = produceResult as ProduceFullGloas;
 
       const envelope: gloas.ExecutionPayloadEnvelope = {
         payload: executionPayload,
         executionRequests: executionRequests,
         builderIndex: BUILDER_INDEX_SELF_BUILD,
         beaconBlockRoot,
-        slot,
-        stateRoot: envelopeStateRoot,
+        parentBeaconBlockRoot: parentBlockRoot,
       };
 
       logger.info("Produced execution payload envelope", {

package/src/chain/GetBlobsTracker.ts

@@ -44,7 +44,7 @@ export class GetBlobsTracker {
     this.config = init.config;
   }
 
-  triggerGetBlobs(input: IBlockInput | PayloadEnvelopeInput, onComplete?: () => void): void {
+  triggerGetBlobs(input: IBlockInput | PayloadEnvelopeInput): void {
     if (this.activeReconstructions.has(input.blockRootHex)) {
       return;
     }
@@ -101,7 +101,6 @@ export class GetBlobsTracker {
         .then((result) => {
           this.logger.debug("getBlobsV2 result for block", {...logCtx, result});
           this.metrics?.dataColumns.dataColumnEngineResult.inc({result});
-          onComplete?.();
         })
         .catch((error) => {
           this.logger.debug("Error during getBlobsV2 for block", logCtx, error as Error);

package/src/chain/archiveStore/archiveStore.ts

@@ -1,4 +1,4 @@
-import {CheckpointWithPayloadStatus} from "@lodestar/fork-choice";
+import {CheckpointWithHex} from "@lodestar/fork-choice";
 import {LoggerNode} from "@lodestar/logger/node";
 import {Checkpoint} from "@lodestar/types/phase0";
 import {callFnWhenAwait} from "@lodestar/utils";
@@ -41,7 +41,7 @@ export enum ArchiveStoreTask {
  */
 export class ArchiveStore {
   private archiveMode: ArchiveMode;
-  private jobQueue: JobItemQueue<[CheckpointWithPayloadStatus], void>;
+  private jobQueue: JobItemQueue<[CheckpointWithHex], void>;
 
   private archiveDataEpochs?: number;
   private readonly statesArchiverStrategy: StateArchiveStrategy;
@@ -64,7 +64,7 @@ export class ArchiveStore {
     this.archiveMode = opts.archiveMode;
     this.archiveDataEpochs = opts.archiveDataEpochs;
 
-    this.jobQueue = new JobItemQueue<[CheckpointWithPayloadStatus], void>(this.processFinalizedCheckpoint, {
+    this.jobQueue = new JobItemQueue<[CheckpointWithHex], void>(this.processFinalizedCheckpoint, {
       maxLength: PROCESS_FINALIZED_CHECKPOINT_QUEUE_LENGTH,
       signal,
     });
@@ -166,7 +166,7 @@ export class ArchiveStore {
   //-------------------------------------------------------------------------
   // Event handlers
   //-------------------------------------------------------------------------
-  private onFinalizedCheckpoint = (finalized: CheckpointWithPayloadStatus): void => {
+  private onFinalizedCheckpoint = (finalized: CheckpointWithHex): void => {
     this.jobQueue.push(finalized).catch((e) => {
       if (!isQueueErrorAborted(e)) {
         this.logger.error("Error queuing finalized checkpoint", {epoch: finalized.epoch}, e as Error);
@@ -187,7 +187,7 @@ export class ArchiveStore {
     });
   };
 
-  private processFinalizedCheckpoint = async (finalized: CheckpointWithPayloadStatus): Promise<void> => {
+  private processFinalizedCheckpoint = async (finalized: CheckpointWithHex): Promise<void> => {
     try {
       const finalizedEpoch = finalized.epoch;
       this.logger.verbose("Start processing finalized checkpoint", {epoch: finalizedEpoch, rootHex: finalized.rootHex});

package/src/chain/archiveStore/interface.ts

@@ -1,4 +1,4 @@
-import {CheckpointWithPayloadStatus} from "@lodestar/fork-choice";
+import {CheckpointWithHex} from "@lodestar/fork-choice";
 import {RootHex} from "@lodestar/types";
 import {Metrics} from "../../metrics/metrics.js";
 
@@ -45,9 +45,9 @@ export type FinalizedStats = {
 
 export interface StateArchiveStrategy {
   onCheckpoint(stateRoot: RootHex, metrics?: Metrics | null): Promise<void>;
-  onFinalizedCheckpoint(finalized: CheckpointWithPayloadStatus, metrics?: Metrics | null): Promise<void>;
-  maybeArchiveState(finalized: CheckpointWithPayloadStatus, metrics?: Metrics | null): Promise<void>;
-  archiveState(finalized: CheckpointWithPayloadStatus, metrics?: Metrics | null): Promise<void>;
+  onFinalizedCheckpoint(finalized: CheckpointWithHex, metrics?: Metrics | null): Promise<void>;
+  maybeArchiveState(finalized: CheckpointWithHex, metrics?: Metrics | null): Promise<void>;
+  archiveState(finalized: CheckpointWithHex, metrics?: Metrics | null): Promise<void>;
 }
 
 export interface IArchiveStore {

package/src/chain/archiveStore/strategies/frequencyStateArchiveStrategy.ts

@@ -1,4 +1,4 @@
-import {CheckpointWithPayloadStatus} from "@lodestar/fork-choice";
+import {CheckpointWithHex} from "@lodestar/fork-choice";
 import {SLOTS_PER_EPOCH} from "@lodestar/params";
 import {computeEpochAtSlot, computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {Epoch, RootHex, Slot} from "@lodestar/types";
@@ -9,7 +9,6 @@ import {AllocSource, BufferPool} from "../../../util/bufferPool.js";
 import {getStateSlotFromBytes} from "../../../util/multifork.js";
 import {IStateRegenerator} from "../../regen/interface.js";
 import {serializeState} from "../../serializeState.js";
-import {fcCheckpointToHexPayload} from "../../stateCache/persistentCheckpointsCache.js";
 import {StateArchiveStrategy, StatesArchiveOpts} from "../interface.js";
 
 /**
@@ -41,7 +40,7 @@ export class FrequencyStateArchiveStrategy implements StateArchiveStrategy {
     private readonly bufferPool?: BufferPool | null
   ) {}
 
-  async onFinalizedCheckpoint(_finalized: CheckpointWithPayloadStatus, _metrics?: Metrics | null): Promise<void> {}
+  async onFinalizedCheckpoint(_finalized: CheckpointWithHex, _metrics?: Metrics | null): Promise<void> {}
   async onCheckpoint(_stateRoot: RootHex, _metrics?: Metrics | null): Promise<void> {}
 
   /**
@@ -56,7 +55,7 @@ export class FrequencyStateArchiveStrategy implements StateArchiveStrategy {
    * epoch - 1024*2    epoch - 1024    epoch - 32    epoch
    * ```
    */
-  async maybeArchiveState(finalized: CheckpointWithPayloadStatus, metrics?: Metrics | null): Promise<void> {
+  async maybeArchiveState(finalized: CheckpointWithHex, metrics?: Metrics | null): Promise<void> {
     let timer = metrics?.processFinalizedCheckpoint.frequencyStateArchive.startTimer();
     const lastStoredSlot = await this.db.stateArchive.lastKey();
     timer?.({step: FrequencyStateArchiveStep.LoadLastStoredSlot});
@@ -105,12 +104,11 @@ export class FrequencyStateArchiveStrategy implements StateArchiveStrategy {
    * Archives finalized states from active bucket to archive bucket.
    * Only the new finalized state is stored to disk
    */
-  async archiveState(finalized: CheckpointWithPayloadStatus, metrics?: Metrics | null): Promise<void> {
+  async archiveState(finalized: CheckpointWithHex, metrics?: Metrics | null): Promise<void> {
     // starting from Mar 2024, the finalized state could be from disk or in memory
     let timer = metrics?.processFinalizedCheckpoint.frequencyStateArchive.startTimer();
-    // Convert fork-choice checkpoint to beacon-node checkpoint with payloadPresent
-    const finalizedHexPayload = fcCheckpointToHexPayload(finalized);
-    const finalizedStateOrBytes = await this.regen.getCheckpointStateOrBytes(finalizedHexPayload);
+    const finalizedHex = {epoch: finalized.epoch, rootHex: finalized.rootHex};
+    const finalizedStateOrBytes = await this.regen.getCheckpointStateOrBytes(finalizedHex);
     timer?.({step: FrequencyStateArchiveStep.GetFinalizedState});
 
     const {rootHex} = finalized;