@lodestar/beacon-node 1.35.0-dev.e18102ed8c → 1.35.0-dev.f45a2be721

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

@@ -0,0 +1,75 @@
+import {routes} from "@lodestar/api";
+import {ChainForkConfig} from "@lodestar/config";
+import {IForkChoice} from "@lodestar/fork-choice";
+import {blockToHeader} from "@lodestar/state-transition";
+import {RootHex, SignedBeaconBlock, Slot} from "@lodestar/types";
+import {IBeaconChain} from "../../../../chain/interface.js";
+import {GENESIS_SLOT} from "../../../../constants/index.js";
+import {rootHexRegex} from "../../../../eth1/provider/utils.js";
+import {ApiError, ValidationError} from "../../errors.js";
+
+export function toBeaconHeaderResponse(
+  config: ChainForkConfig,
+  block: SignedBeaconBlock,
+  canonical = false
+): routes.beacon.BlockHeaderResponse {
+  return {
+    root: config.getForkTypes(block.message.slot).BeaconBlock.hashTreeRoot(block.message),
+    canonical,
+    header: {
+      message: blockToHeader(config, block.message),
+      signature: block.signature,
+    },
+  };
+}
+
+export function resolveBlockId(forkChoice: IForkChoice, blockId: routes.beacon.BlockId): RootHex | Slot {
+  blockId = String(blockId).toLowerCase();
+  if (blockId === "head") {
+    return forkChoice.getHead().blockRoot;
+  }
+
+  if (blockId === "genesis") {
+    return GENESIS_SLOT;
+  }
+
+  if (blockId === "finalized") {
+    return forkChoice.getFinalizedBlock().blockRoot;
+  }
+
+  if (blockId === "justified") {
+    return forkChoice.getJustifiedBlock().blockRoot;
+  }
+
+  if (blockId.startsWith("0x")) {
+    if (!rootHexRegex.test(blockId)) {
+      throw new ValidationError(`Invalid block id '${blockId}'`, "blockId");
+    }
+    return blockId;
+  }
+
+  // block id must be slot
+  const blockSlot = parseInt(blockId, 10);
+  if (Number.isNaN(blockSlot) && Number.isNaN(blockSlot - 0)) {
+    throw new ValidationError(`Invalid block id '${blockId}'`, "blockId");
+  }
+  return blockSlot;
+}
+
+export async function getBlockResponse(
+  chain: IBeaconChain,
+  blockId: routes.beacon.BlockId
+): Promise<{block: SignedBeaconBlock; executionOptimistic: boolean; finalized: boolean}> {
+  const rootOrSlot = resolveBlockId(chain.forkChoice, blockId);
+
+  const res =
+    typeof rootOrSlot === "string"
+      ? await chain.getBlockByRoot(rootOrSlot)
+      : await chain.getCanonicalBlockAtSlot(rootOrSlot);
+
+  if (!res) {
+    throw new ApiError(404, `Block not found for id '${blockId}'`);
+  }
+
+  return res;
+}

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

@@ -0,0 +1,35 @@
+import {routes} from "@lodestar/api";
+import {ApplicationMethods} from "@lodestar/api/server";
+import {ApiModules} from "../types.js";
+import {getBeaconBlockApi} from "./blocks/index.js";
+import {getBeaconPoolApi} from "./pool/index.js";
+import {getBeaconRewardsApi} from "./rewards/index.js";
+import {getBeaconStateApi} from "./state/index.js";
+
+export function getBeaconApi(
+  modules: Pick<ApiModules, "chain" | "config" | "logger" | "metrics" | "network" | "db">
+): ApplicationMethods<routes.beacon.Endpoints> {
+  const block = getBeaconBlockApi(modules);
+  const pool = getBeaconPoolApi(modules);
+  const state = getBeaconStateApi(modules);
+  const rewards = getBeaconRewardsApi(modules);
+
+  const {chain, config} = modules;
+
+  return {
+    ...block,
+    ...pool,
+    ...state,
+    ...rewards,
+
+    async getGenesis() {
+      return {
+        data: {
+          genesisForkVersion: config.GENESIS_FORK_VERSION,
+          genesisTime: chain.genesisTime,
+          genesisValidatorsRoot: chain.genesisValidatorsRoot,
+        },
+      };
+    },
+  };
+}

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

@@ -0,0 +1,314 @@
+import {routes} from "@lodestar/api";
+import {ApplicationMethods} from "@lodestar/api/server";
+import {ForkPostElectra, ForkPreElectra, SYNC_COMMITTEE_SUBNET_SIZE, isForkPostElectra} from "@lodestar/params";
+import {Attestation, Epoch, SingleAttestation, isElectraAttestation, ssz, sszTypesFor} from "@lodestar/types";
+import {
+  AttestationError,
+  AttestationErrorCode,
+  GossipAction,
+  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 {validateApiProposerSlashing} from "../../../../chain/validation/proposerSlashing.js";
+import {validateApiSyncCommittee} from "../../../../chain/validation/syncCommittee.js";
+import {validateApiVoluntaryExit} from "../../../../chain/validation/voluntaryExit.js";
+import {validateGossipFnRetryUnknownRoot} from "../../../../network/processor/gossipHandlers.js";
+import {ApiError, FailureList, IndexedError} from "../../errors.js";
+import {ApiModules} from "../../types.js";
+
+export function getBeaconPoolApi({
+  chain,
+  logger,
+  metrics,
+  network,
+}: Pick<ApiModules, "chain" | "logger" | "metrics" | "network">): ApplicationMethods<routes.beacon.pool.Endpoints> {
+  return {
+    async getPoolAttestations({slot, committeeIndex}) {
+      // Already filtered by slot
+      let attestations: Attestation[] = chain.aggregatedAttestationPool.getAll(slot);
+      const fork = chain.config.getForkName(slot ?? chain.clock.currentSlot);
+
+      if (isForkPostElectra(fork)) {
+        throw new ApiError(
+          400,
+          `Use getPoolAttestationsV2 to retrieve pool attestations for post-electra fork=${fork}`
+        );
+      }
+
+      if (committeeIndex !== undefined) {
+        attestations = attestations.filter((attestation) => committeeIndex === attestation.data.index);
+      }
+
+      return {data: attestations};
+    },
+
+    async getPoolAttestationsV2({slot, committeeIndex}) {
+      // Already filtered by slot
+      let attestations = chain.aggregatedAttestationPool.getAll(slot);
+      const fork = chain.config.getForkName(slot ?? attestations[0]?.data.slot ?? chain.clock.currentSlot);
+      const isPostElectra = isForkPostElectra(fork);
+
+      attestations = attestations.filter((attestation) =>
+        isPostElectra ? isElectraAttestation(attestation) : !isElectraAttestation(attestation)
+      );
+
+      if (committeeIndex !== undefined) {
+        attestations = attestations.filter((attestation) => committeeIndex === attestation.data.index);
+      }
+
+      return {data: attestations, meta: {version: fork}};
+    },
+
+    async getPoolAttesterSlashings() {
+      const fork = chain.config.getForkName(chain.clock.currentSlot);
+
+      if (isForkPostElectra(fork)) {
+        throw new ApiError(
+          400,
+          `Use getPoolAttesterSlashingsV2 to retrieve pool attester slashings for post-electra fork=${fork}`
+        );
+      }
+
+      return {data: chain.opPool.getAllAttesterSlashings()};
+    },
+
+    async getPoolAttesterSlashingsV2() {
+      const fork = chain.config.getForkName(chain.clock.currentSlot);
+      return {data: chain.opPool.getAllAttesterSlashings(), meta: {version: fork}};
+    },
+
+    async getPoolProposerSlashings() {
+      return {data: chain.opPool.getAllProposerSlashings()};
+    },
+
+    async getPoolVoluntaryExits() {
+      return {data: chain.opPool.getAllVoluntaryExits()};
+    },
+
+    async getPoolBLSToExecutionChanges() {
+      return {data: chain.opPool.getAllBlsToExecutionChanges().map(({data}) => data)};
+    },
+
+    async submitPoolAttestations({signedAttestations}) {
+      await this.submitPoolAttestationsV2({signedAttestations});
+    },
+
+    async submitPoolAttestationsV2({signedAttestations}) {
+      const fork = chain.config.getForkName(chain.clock.currentSlot);
+      const seenTimestampSec = Date.now() / 1000;
+      const failures: FailureList = [];
+      // api attestation has high priority, we allow them to be added to pool even when it's late
+      // this is to prevent "No aggregated attestation for slot" issue
+      // see https://github.com/ChainSafe/lodestar/issues/7548
+      const priority = true;
+
+      await Promise.all(
+        signedAttestations.map(async (attestation, i) => {
+          try {
+            const validateFn = () => validateApiAttestation(fork, chain, {attestation, serializedData: null});
+            const {slot, beaconBlockRoot} = attestation.data;
+            // when a validator is configured with multiple beacon node urls, this attestation data may come from another beacon node
+            // and the block hasn't been in our forkchoice since we haven't seen / processing that block
+            // see https://github.com/ChainSafe/lodestar/issues/5098
+            const {indexedAttestation, subnet, attDataRootHex, committeeIndex, validatorCommitteeIndex, committeeSize} =
+              await validateGossipFnRetryUnknownRoot(validateFn, network, chain, slot, beaconBlockRoot);
+
+            if (network.shouldAggregate(subnet, slot)) {
+              const insertOutcome = chain.attestationPool.add(
+                committeeIndex,
+                attestation,
+                attDataRootHex,
+                validatorCommitteeIndex,
+                committeeSize,
+                priority
+              );
+              metrics?.opPool.attestationPool.apiInsertOutcome.inc({insertOutcome});
+            }
+
+            if (isForkPostElectra(fork)) {
+              chain.emitter.emit(
+                routes.events.EventType.singleAttestation,
+                attestation as SingleAttestation<ForkPostElectra>
+              );
+            } else {
+              chain.emitter.emit(routes.events.EventType.attestation, attestation as SingleAttestation<ForkPreElectra>);
+              chain.emitter.emit(
+                routes.events.EventType.singleAttestation,
+                toElectraSingleAttestation(
+                  attestation as SingleAttestation<ForkPreElectra>,
+                  indexedAttestation.attestingIndices[0]
+                )
+              );
+            }
+
+            const sentPeers = await network.publishBeaconAttestation(attestation, subnet);
+            chain.validatorMonitor?.onPoolSubmitUnaggregatedAttestation(
+              seenTimestampSec,
+              indexedAttestation,
+              subnet,
+              sentPeers
+            );
+          } catch (e) {
+            const logCtx = {slot: attestation.data.slot, index: attestation.data.index};
+
+            if (e instanceof AttestationError && e.type.code === AttestationErrorCode.ATTESTATION_ALREADY_KNOWN) {
+              logger.debug("Ignoring known attestation", logCtx);
+              // Attestations might already be published by another node as part of a fallback setup or DVT cluster
+              // and can reach our node by gossip before the api. The error can be ignored and should not result in a 500 response.
+              return;
+            }
+
+            failures.push({index: i, message: (e as Error).message});
+            logger.verbose(`Error on submitPoolAttestations [${i}]`, logCtx, e as Error);
+            if (e instanceof AttestationError && e.action === GossipAction.REJECT) {
+              chain.persistInvalidSszValue(sszTypesFor(fork).SingleAttestation, attestation, "api_reject");
+            }
+          }
+        })
+      );
+
+      if (failures.length > 0) {
+        throw new IndexedError("Error processing attestations", failures);
+      }
+    },
+
+    async submitPoolAttesterSlashings({attesterSlashing}) {
+      await this.submitPoolAttesterSlashingsV2({attesterSlashing});
+    },
+
+    async submitPoolAttesterSlashingsV2({attesterSlashing}) {
+      await validateApiAttesterSlashing(chain, attesterSlashing);
+      const fork = chain.config.getForkName(Number(attesterSlashing.attestation1.data.slot));
+      chain.opPool.insertAttesterSlashing(fork, attesterSlashing);
+      await network.publishAttesterSlashing(attesterSlashing);
+    },
+
+    async submitPoolProposerSlashings({proposerSlashing}) {
+      await validateApiProposerSlashing(chain, proposerSlashing);
+      chain.opPool.insertProposerSlashing(proposerSlashing);
+      await network.publishProposerSlashing(proposerSlashing);
+    },
+
+    async submitPoolVoluntaryExit({signedVoluntaryExit}) {
+      await validateApiVoluntaryExit(chain, signedVoluntaryExit);
+      chain.opPool.insertVoluntaryExit(signedVoluntaryExit);
+      chain.emitter.emit(routes.events.EventType.voluntaryExit, signedVoluntaryExit);
+      await network.publishVoluntaryExit(signedVoluntaryExit);
+    },
+
+    async submitPoolBLSToExecutionChange({blsToExecutionChanges}) {
+      const failures: FailureList = [];
+
+      await Promise.all(
+        blsToExecutionChanges.map(async (blsToExecutionChange, i) => {
+          try {
+            // Ignore even if the change exists and reprocess
+            await validateApiBlsToExecutionChange(chain, blsToExecutionChange);
+            const preCapella = chain.clock.currentEpoch < chain.config.CAPELLA_FORK_EPOCH;
+            chain.opPool.insertBlsToExecutionChange(blsToExecutionChange, preCapella);
+
+            chain.emitter.emit(routes.events.EventType.blsToExecutionChange, blsToExecutionChange);
+
+            if (!preCapella) {
+              await network.publishBlsToExecutionChange(blsToExecutionChange);
+            }
+          } catch (e) {
+            failures.push({index: i, message: (e as Error).message});
+            logger.verbose(
+              `Error on submitPoolBLSToExecutionChange [${i}]`,
+              {validatorIndex: blsToExecutionChange.message.validatorIndex},
+              e as Error
+            );
+          }
+        })
+      );
+
+      if (failures.length > 0) {
+        throw new IndexedError("Error processing BLS to execution changes", failures);
+      }
+    },
+
+    /**
+     * POST `/eth/v1/beacon/pool/sync_committees`
+     *
+     * Submits sync committee signature objects to the node.
+     * Sync committee signatures are not present in phase0, but are required for Altair networks.
+     * If a sync committee signature is validated successfully the node MUST publish that sync committee signature on all applicable subnets.
+     * If one or more sync committee signatures fail validation the node MUST return a 400 error with details of which sync committee signatures have failed, and why.
+     *
+     * https://github.com/ethereum/beacon-APIs/pull/135
+     */
+    async submitPoolSyncCommitteeSignatures({signatures}) {
+      // Fetch states for all slots of the `signatures`
+      const slots = new Set<Epoch>();
+      for (const signature of signatures) {
+        slots.add(signature.slot);
+      }
+
+      // TODO: Fetch states at signature slots
+      const state = chain.getHeadState();
+
+      const failures: FailureList = [];
+
+      await Promise.all(
+        signatures.map(async (signature, i) => {
+          try {
+            const synCommittee = state.epochCtx.getIndexedSyncCommittee(signature.slot);
+            const indexesInCommittee = synCommittee.validatorIndexMap.get(signature.validatorIndex);
+            if (indexesInCommittee === undefined || indexesInCommittee.length === 0) {
+              return; // Not a sync committee member
+            }
+
+            // Verify signature only, all other data is very likely to be correct, since the `signature` object is created by this node.
+            // Worst case if `signature` is not valid, gossip peers will drop it and slightly downscore us.
+            await validateApiSyncCommittee(chain, state, signature);
+
+            // The same validator can appear multiple times in the sync committee. It can appear multiple times per
+            // subnet even. First compute on which subnet the signature must be broadcasted to.
+            const subnets: number[] = [];
+            // same to api attestation, we allow api SyncCommittee to be added to pool even when it's late
+            // see https://github.com/ChainSafe/lodestar/issues/7548
+            const priority = true;
+
+            for (const indexInCommittee of indexesInCommittee) {
+              // Sync committee subnet members are just sequential in the order they appear in SyncCommitteeIndexes array
+              const subnet = Math.floor(indexInCommittee / SYNC_COMMITTEE_SUBNET_SIZE);
+              const indexInSubcommittee = indexInCommittee % SYNC_COMMITTEE_SUBNET_SIZE;
+              chain.syncCommitteeMessagePool.add(subnet, signature, indexInSubcommittee, priority);
+
+              // Cheap de-duplication code to avoid using a Set. indexesInCommittee is always sorted
+              if (subnets.length === 0 || subnets.at(-1) !== subnet) {
+                subnets.push(subnet);
+              }
+            }
+
+            // TODO: Broadcast at once to all topics
+            await Promise.all(subnets.map(async (subnet) => network.publishSyncCommitteeSignature(signature, subnet)));
+          } catch (e) {
+            // TODO: gossipsub should allow publishing same message to different topics
+            // https://github.com/ChainSafe/js-libp2p-gossipsub/issues/272
+            if ((e as Error).message === "PublishError.Duplicate") {
+              return;
+            }
+
+            failures.push({index: i, message: (e as Error).message});
+            logger.verbose(
+              `Error on submitPoolSyncCommitteeSignatures [${i}]`,
+              {slot: signature.slot, validatorIndex: signature.validatorIndex},
+              e as Error
+            );
+            if (e instanceof SyncCommitteeError && e.action === GossipAction.REJECT) {
+              chain.persistInvalidSszValue(ssz.altair.SyncCommitteeMessage, signature, "api_reject");
+            }
+          }
+        })
+      );
+
+      if (failures.length > 0) {
+        throw new IndexedError("Error processing sync committee signatures", failures);
+      }
+    },
+  };
+}

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

@@ -0,0 +1,30 @@
+import {routes} from "@lodestar/api";
+import {ApplicationMethods} from "@lodestar/api/server";
+import {ApiModules} from "../../types.js";
+import {assertUniqueItems} from "../../utils.js";
+import {getBlockResponse} from "../blocks/utils.js";
+
+export function getBeaconRewardsApi({
+  chain,
+}: Pick<ApiModules, "chain">): ApplicationMethods<routes.beacon.rewards.Endpoints> {
+  return {
+    async getBlockRewards({blockId}) {
+      const {block, executionOptimistic, finalized} = await getBlockResponse(chain, blockId);
+      const data = await chain.getBlockRewards(block.message);
+      return {data, meta: {executionOptimistic, finalized}};
+    },
+    async getAttestationsRewards({epoch, validatorIds}) {
+      assertUniqueItems(validatorIds, "Duplicate validator IDs provided");
+
+      const {rewards, executionOptimistic, finalized} = await chain.getAttestationsRewards(epoch, validatorIds);
+      return {data: rewards, meta: {executionOptimistic, finalized}};
+    },
+    async getSyncCommitteeRewards({blockId, validatorIds}) {
+      assertUniqueItems(validatorIds, "Duplicate validator IDs provided");
+
+      const {block, executionOptimistic, finalized} = await getBlockResponse(chain, blockId);
+      const data = await chain.getSyncCommitteeRewards(block.message, validatorIds);
+      return {data, meta: {executionOptimistic, finalized}};
+    },
+  };
+}