@lodestar/beacon-node 1.45.0-dev.51a1c44b27 → 1.45.0-dev.7acc183c2b

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

@@ -7,7 +7,7 @@ import {getBeaconRewardsApi} from "./rewards/index.js";
 import {getBeaconStateApi} from "./state/index.js";
 
 export function getBeaconApi(
-  modules: Pick<ApiModules, "chain" | "config" | "logger" | "metrics" | "network" | "db">
+  modules: Pick<ApiModules, "chain" | "config" | "logger" | "metrics" | "network" | "db" | "sync">
 ): ApplicationMethods<routes.beacon.Endpoints> {
   const block = getBeaconBlockApi(modules);
   const pool = getBeaconPoolApi(modules);

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

@@ -1,7 +1,6 @@
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
 import {
-  ForkName,
   ForkPostElectra,
   ForkPreElectra,
   SYNC_COMMITTEE_SUBNET_SIZE,
@@ -17,15 +16,12 @@ import {
   GossipAction,
   PayloadAttestationError,
   PayloadAttestationErrorCode,
-  ProposerPreferencesError,
-  ProposerPreferencesErrorCode,
   SyncCommitteeError,
 } from "../../../../chain/errors/index.js";
 import {validateApiAttesterSlashing} from "../../../../chain/validation/attesterSlashing.js";
 import {validateApiBlsToExecutionChange} from "../../../../chain/validation/blsToExecutionChange.js";
 import {toElectraSingleAttestation, validateApiAttestation} from "../../../../chain/validation/index.js";
 import {validateApiPayloadAttestationMessage} from "../../../../chain/validation/payloadAttestationMessage.js";
-import {validateGossipProposerPreferences} from "../../../../chain/validation/proposerPreferences.js";
 import {validateApiProposerSlashing} from "../../../../chain/validation/proposerSlashing.js";
 import {validateApiSyncCommittee} from "../../../../chain/validation/syncCommittee.js";
 import {validateApiVoluntaryExit} from "../../../../chain/validation/voluntaryExit.js";
@@ -66,55 +62,6 @@ export function getBeaconPoolApi({
       return {data: chain.payloadAttestationPool.getAll(slot), meta: {version: fork}};
     },
 
-    async getPoolProposerPreferences({slot}) {
-      const fork = chain.config.getForkName(slot ?? chain.clock.currentSlot);
-      if (!isForkPostGloas(fork)) {
-        throw new ApiError(400, `Proposer preferences pool is not supported before Gloas fork=${fork}`);
-      }
-
-      return {data: chain.proposerPreferencesPool.getAll(slot), meta: {version: fork}};
-    },
-
-    async submitSignedProposerPreferences({signedProposerPreferences}) {
-      const failures: FailureList = [];
-
-      await Promise.all(
-        signedProposerPreferences.map(async (signed, i) => {
-          try {
-            await validateGossipProposerPreferences(chain, signed);
-
-            chain.proposerPreferencesPool.add(signed);
-            await network.publishProposerPreferences(signed);
-            chain.emitter.emit(routes.events.EventType.proposerPreferences, {
-              version: ForkName.gloas,
-              data: signed,
-            });
-          } catch (e) {
-            const logCtx = {
-              slot: signed.message.proposalSlot,
-              validatorIndex: signed.message.validatorIndex,
-              dependentRoot: toRootHex(signed.message.dependentRoot),
-            };
-
-            if (e instanceof ProposerPreferencesError && e.type.code === ProposerPreferencesErrorCode.ALREADY_KNOWN) {
-              logger.debug("Ignoring known signed proposer preferences", logCtx);
-              return;
-            }
-
-            failures.push({index: i, message: (e as Error).message});
-            logger.verbose(`Error on submitSignedProposerPreferences [${i}]`, logCtx, e as Error);
-            if (e instanceof ProposerPreferencesError && e.action === GossipAction.REJECT) {
-              chain.persistInvalidSszValue(ssz.gloas.SignedProposerPreferences, signed, "api_reject");
-            }
-          }
-        })
-      );
-
-      if (failures.length > 0) {
-        throw new IndexedError("Error processing signed proposer preferences", failures);
-      }
-    },
-
     async getPoolAttesterSlashingsV2() {
       const fork = chain.config.getForkName(chain.clock.currentSlot);
       return {data: chain.opPool.getAllAttesterSlashings(), meta: {version: fork}};
@@ -294,6 +241,11 @@ export function getBeaconPoolApi({
               payloadAttestationMessage.data.blobDataAvailable
             );
 
+            chain.emitter.emit(routes.events.EventType.payloadAttestationMessage, {
+              version: chain.config.getForkName(slot),
+              data: payloadAttestationMessage,
+            });
+
             await network.publishPayloadAttestationMessage(payloadAttestationMessage);
           } catch (e) {
             const logCtx = {

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

@@ -9,13 +9,15 @@ import {
   isStatePostAltair,
   isStatePostElectra,
   isStatePostFulu,
+  isStatePostGloas,
 } from "@lodestar/state-transition";
-import {ValidatorIndex, getValidatorStatus, ssz} from "@lodestar/types";
+import {ValidatorIndex, getBuilderStatus, getValidatorStatus, ssz} from "@lodestar/types";
 import {ApiError} from "../../errors.js";
 import {ApiModules} from "../../types.js";
 import {assertUniqueItems} from "../../utils.js";
 import {
   filterStateValidatorsByStatus,
+  getStateBuilderIndex,
   getStateResponseWithRegen,
   getStateValidatorIndex,
   toValidatorResponse,
@@ -24,11 +26,12 @@ import {
 export function getBeaconStateApi({
   chain,
   config,
-}: Pick<ApiModules, "chain" | "config">): ApplicationMethods<routes.beacon.state.Endpoints> {
+  sync,
+}: Pick<ApiModules, "chain" | "config" | "sync">): ApplicationMethods<routes.beacon.state.Endpoints> {
   async function getState(
     stateId: routes.beacon.StateId
   ): Promise<{state: IBeaconStateView; executionOptimistic: boolean; finalized: boolean}> {
-    const {state, executionOptimistic, finalized} = await getStateResponseWithRegen(chain, stateId);
+    const {state, executionOptimistic, finalized} = await getStateResponseWithRegen(chain, sync, stateId);
 
     return {
       state: state instanceof Uint8Array ? chain.getHeadState().loadOtherState(state) : state,
@@ -143,6 +146,55 @@ export function getBeaconStateApi({
       return this.getStateValidators(args, context);
     },
 
+    async getStateBuilders({stateId, builderIds = [], statuses = []}) {
+      const {state, executionOptimistic, finalized} = await getState(stateId);
+      if (!isStatePostGloas(state)) {
+        throw new ApiError(400, `Builders are not supported for pre-gloas state fork=${state.forkName}`);
+      }
+      const finalizedEpoch = state.finalizedCheckpoint.epoch;
+
+      const builderResponses: routes.beacon.BuilderResponse[] = [];
+      if (builderIds.length) {
+        assertUniqueItems(builderIds, "Duplicate builder IDs provided");
+
+        for (const id of builderIds) {
+          const resp = getStateBuilderIndex(id, state);
+          if (resp.valid) {
+            const builderIndex = resp.builderIndex;
+            const builder = state.getBuilder(builderIndex);
+            const status = getBuilderStatus(builder, finalizedEpoch);
+            if (statuses.length && !statuses.includes(status)) {
+              continue;
+            }
+            builderResponses.push({index: builderIndex, status, builder});
+          }
+        }
+        return {
+          data: builderResponses,
+          meta: {executionOptimistic, finalized},
+        };
+      }
+
+      if (statuses.length) {
+        assertUniqueItems(statuses, "Duplicate statuses provided");
+      }
+
+      const buildersLength = state.getBuildersLength();
+      for (let builderIndex = 0; builderIndex < buildersLength; builderIndex++) {
+        const builder = state.getBuilder(builderIndex);
+        const status = getBuilderStatus(builder, finalizedEpoch);
+        if (statuses.length && !statuses.includes(status)) {
+          continue;
+        }
+        builderResponses.push({index: builderIndex, status, builder});
+      }
+
+      return {
+        data: builderResponses,
+        meta: {executionOptimistic, finalized},
+      };
+    },
+
     async postStateValidatorIdentities({stateId, validatorIds = []}) {
       const {state, executionOptimistic, finalized} = await getState(stateId);
       const {pubkeyCache} = chain;

package/src/api/impl/beacon/state/utils.ts

@@ -1,11 +1,22 @@
 import {routes} from "@lodestar/api";
 import {CheckpointWithHex, IForkChoice} from "@lodestar/fork-choice";
 import {GENESIS_SLOT} from "@lodestar/params";
-import {IBeaconStateView, PubkeyCache} from "@lodestar/state-transition";
-import {BLSPubkey, Epoch, RootHex, Slot, ValidatorIndex, getValidatorStatus, phase0} from "@lodestar/types";
-import {fromHex} from "@lodestar/utils";
+import {IBeaconStateView, IBeaconStateViewGloas, PubkeyCache} from "@lodestar/state-transition";
+import {
+  BLSPubkey,
+  BuilderIndex,
+  Epoch,
+  RootHex,
+  Slot,
+  ValidatorIndex,
+  getValidatorStatus,
+  phase0,
+} from "@lodestar/types";
+import {byteArrayEquals, fromHex} from "@lodestar/utils";
 import {IBeaconChain} from "../../../../chain/index.js";
+import {IBeaconSync} from "../../../../sync/index.js";
 import {ApiError, ValidationError} from "../../errors.js";
+import {notWhileSyncing} from "../../utils.js";
 
 export function resolveStateId(
   forkChoice: IForkChoice,
@@ -42,8 +53,17 @@ export function resolveStateId(
 
 export async function getStateResponseWithRegen(
   chain: IBeaconChain,
+  sync: IBeaconSync,
   inStateId: routes.beacon.StateId
 ): Promise<{state: IBeaconStateView | Uint8Array; executionOptimistic: boolean; finalized: boolean}> {
+  // "head", "finalized" and "justified" resolve to already-available cached states, and "genesis" to a
+  // historical DB read - none trigger the forward regen that can walk back past the block-root window
+  // (SLOTS_PER_HISTORICAL_ROOT) and wedge a far-behind node. Keep serving those (node observability,
+  // dashboards, validator client checks) even while syncing; guard only the regen-capable lookups.
+  if (inStateId !== "head" && inStateId !== "finalized" && inStateId !== "justified" && inStateId !== "genesis") {
+    notWhileSyncing(chain, sync.state);
+  }
+
   const stateId = resolveStateId(chain.forkChoice, inStateId);
 
   const res =
@@ -78,6 +98,50 @@ export function toValidatorResponse(
   };
 }
 
+type StateBuilderIndexResponse =
+  | {valid: true; builderIndex: BuilderIndex}
+  | {valid: false; code: number; reason: string};
+
+export function getStateBuilderIndex(
+  id: routes.beacon.BuilderId | BLSPubkey,
+  state: IBeaconStateViewGloas
+): StateBuilderIndexResponse {
+  if (typeof id === "string") {
+    // mutate `id` and fallthrough to below
+    if (id.startsWith("0x")) {
+      try {
+        id = fromHex(id);
+      } catch (_e) {
+        return {valid: false, code: 400, reason: "Invalid pubkey hex encoding"};
+      }
+    } else {
+      id = Number(id);
+    }
+  }
+
+  if (typeof id === "number") {
+    const builderIndex = id;
+    // builder is invalid or added later than given stateId
+    if (!Number.isSafeInteger(builderIndex) || builderIndex < 0) {
+      return {valid: false, code: 400, reason: "Invalid builder index"};
+    }
+    if (builderIndex >= state.getBuildersLength()) {
+      return {valid: false, code: 404, reason: "Builder index from future state"};
+    }
+    return {valid: true, builderIndex};
+  }
+
+  // typeof id === Uint8Array
+  // There is no builder pubkey cache, linear scan over the registry
+  const buildersLength = state.getBuildersLength();
+  for (let builderIndex = 0; builderIndex < buildersLength; builderIndex++) {
+    if (byteArrayEquals(state.getBuilder(builderIndex).pubkey, id)) {
+      return {valid: true, builderIndex};
+    }
+  }
+  return {valid: false, code: 404, reason: "Builder pubkey not found in state"};
+}
+
 export function filterStateValidatorsByStatus(
   statuses: string[],
   state: IBeaconStateView,
@@ -122,7 +186,7 @@ export function getStateValidatorIndex(
   if (typeof id === "number") {
     const validatorIndex = id;
     // validator is invalid or added later than given stateId
-    if (!Number.isSafeInteger(validatorIndex)) {
+    if (!Number.isSafeInteger(validatorIndex) || validatorIndex < 0) {
       return {valid: false, code: 400, reason: "Invalid validator index"};
     }
     if (validatorIndex >= state.validatorCount) {

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

@@ -39,7 +39,8 @@ function toPayloadStatusName(status: PayloadStatus): "pending" | "empty" | "full
 export function getDebugApi({
   chain,
   config,
-}: Pick<ApiModules, "chain" | "config" | "db">): ApplicationMethods<routes.debug.Endpoints> {
+  sync,
+}: Pick<ApiModules, "chain" | "config" | "db" | "sync">): ApplicationMethods<routes.debug.Endpoints> {
   return {
     async getDebugChainHeadsV2() {
       const heads = chain.forkChoice.getHeads();
@@ -132,7 +133,7 @@ export function getDebugApi({
     },
 
     async getStateV2({stateId}, context) {
-      const {state, executionOptimistic, finalized} = await getStateResponseWithRegen(chain, stateId);
+      const {state, executionOptimistic, finalized} = await getStateResponseWithRegen(chain, sync, stateId);
       let slot: number, data: Uint8Array | BeaconState;
       if (state instanceof Uint8Array) {
         slot = getStateSlotFromBytes(state);

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

@@ -217,7 +217,7 @@ export function getLodestarApi({
     },
 
     async getHistoricalSummaries({stateId}) {
-      const {state, executionOptimistic, finalized} = await getStateResponseWithRegen(chain, stateId);
+      const {state, executionOptimistic, finalized} = await getStateResponseWithRegen(chain, sync, stateId);
 
       const stateView = state instanceof Uint8Array ? chain.getHeadState().loadOtherState(state) : state;
 
@@ -332,7 +332,7 @@ export function getLodestarApi({
 
       for (const [epoch, attestationsPerEpoch] of attestations) {
         const slot = computeStartSlotAtEpoch(epoch);
-        const {state} = await getStateResponseWithRegen(chain, slot);
+        const {state} = await getStateResponseWithRegen(chain, sync, slot);
         const stateView = state instanceof Uint8Array ? chain.getHeadState().loadOtherState(state) : state;
         const shuffling = stateView.getShufflingAtEpoch(epoch);
         for (const attestation of attestationsPerEpoch) {

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

@@ -8,7 +8,7 @@ import {ApiModules} from "../types.js";
 
 export function getProofApi(
   opts: ApiOptions,
-  {chain, config}: Pick<ApiModules, "chain" | "config" | "db">
+  {chain, config, sync}: Pick<ApiModules, "chain" | "config" | "db" | "sync">
 ): ApplicationMethods<routes.proof.Endpoints> {
   // It's currently possible to request gigantic proofs (eg: a proof of the entire beacon state)
   // We want some some sort of resistance against this DoS vector.
@@ -21,7 +21,7 @@ export function getProofApi(
         throw new Error("Requested proof is too large.");
       }
 
-      const res = await getStateResponseWithRegen(chain, stateId);
+      const res = await getStateResponseWithRegen(chain, sync, stateId);
 
       const state = res.state instanceof Uint8Array ? chain.getHeadState().loadOtherState(res.state) : res.state;
 

package/src/api/impl/utils.ts

@@ -1,4 +1,54 @@
-import {ApiError} from "./errors.js";
+import {SLOTS_PER_EPOCH} from "@lodestar/params";
+import type {IBeaconChain} from "../../chain/index.js";
+import {SyncState} from "../../sync/index.js";
+import {ApiError, NodeIsSyncing} from "./errors.js";
+
+/**
+ * If the node is within this many epochs from the head, we declare it to be synced regardless of
+ * the network sync state.
+ *
+ * This helps prevent attacks where nodes can convince us that we're syncing some non-existent
+ * finalized head.
+ *
+ * TODO: Lighthouse uses 8 for the attack described above. However, 8 kills Lodestar since validators
+ * can trigger regen to fast-forward head state 8 epochs to be immediately invalidated as sync sets
+ * a new head. Then the checkpoint state cache grows unbounded with very different states (because
+ * they are 8 epochs apart) and causes an OOM. Research a proper solution once regen and the state
+ * caches are better.
+ */
+export const SYNC_TOLERANCE_EPOCHS = 1;
+
+/**
+ * Reject any request while the node is syncing. Used by endpoints that must not serve while the
+ * node is behind — validator duties, and beacon state lookups whose regen could otherwise walk
+ * back past the block-root window (`SLOTS_PER_HISTORICAL_ROOT`) and wedge the node. Throws
+ * {@link NodeIsSyncing} (503).
+ */
+export function notWhileSyncing(chain: IBeaconChain, syncState: SyncState): void {
+  // Consider node synced before or close to genesis
+  if (chain.clock.currentSlot < SLOTS_PER_EPOCH) {
+    return;
+  }
+
+  switch (syncState) {
+    case SyncState.SyncingFinalized:
+    case SyncState.SyncingHead: {
+      const currentSlot = chain.clock.currentSlot;
+      const headSlot = chain.forkChoice.getHead().slot;
+      if (currentSlot - headSlot > SYNC_TOLERANCE_EPOCHS * SLOTS_PER_EPOCH) {
+        throw new NodeIsSyncing(`headSlot ${headSlot} currentSlot ${currentSlot}`);
+      }
+
+      return;
+    }
+
+    case SyncState.Synced:
+      return;
+
+    case SyncState.Stalled:
+      throw new NodeIsSyncing("waiting for peers");
+  }
+}
 
 /**
  * Ensures that the array contains unique values, and throws an ApiError