@lodestar/beacon-node 1.35.0-dev.39be8f0882 → 1.35.0-dev.3d8b04e1a0

package/src/chain/emitter.ts

@@ -1,113 +0,0 @@
-import {EventEmitter} from "node:events";
-import {StrictEventEmitter} from "strict-event-emitter-types";
-import {routes} from "@lodestar/api";
-import {CheckpointWithHex} from "@lodestar/fork-choice";
-import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {RootHex, deneb, fulu, phase0} from "@lodestar/types";
-import {PeerIdStr} from "../util/peerId.js";
-import {BlockInputSource, IBlockInput} from "./blocks/blockInput/types.js";
-
-/**
- * Important chain events that occur during normal chain operation.
- *
- * Chain events can be broken into several categories:
- * - Clock: the chain's clock is updated
- * - Fork Choice: the chain's fork choice is updated
- * - Checkpointing: the chain processes epoch boundaries
- */
-export enum ChainEvent {
-  /**
-   * This event signals that the chain has processed (or reprocessed) a checkpoint.
-   *
-   * This event is not tied to clock events, but rather tied to generation (or regeneration) of state.
-   * This event is guaranteed to be called after _any_ checkpoint is processed, including skip-slot checkpoints, checkpoints that are formed as a result of processing blocks, etc.
-   */
-  checkpoint = "checkpoint",
-  /**
-   * This event signals that the fork choice store has been updated.
-   *
-   * This event is guaranteed to be triggered whenever the fork choice justified checkpoint is updated. This is either in response to a newly processed block or a new clock tick.
-   */
-  forkChoiceJustified = "forkChoice:justified",
-  /**
-   * This event signals that the fork choice store has been updated.
-   *
-   * This event is guaranteed to be triggered whenever the fork choice justified checkpoint is updated. This is in response to a newly processed block.
-   */
-  forkChoiceFinalized = "forkChoice:finalized",
-  /**
-   * This event signals that dependent services (e.g. custody sampling) should update to account for the new target group count.
-   */
-  updateTargetCustodyGroupCount = "updateTargetCustodyGroupCount",
-  /**
-   * This event signals that data columns have been fetched from the execution engine
-   * and are ready to be published.
-   */
-  publishDataColumns = "publishDataColumns",
-  /**
-   * This event signals that blobs have been fetched from the execution engine
-   * and are ready to be published.
-   */
-  publishBlobSidecars = "publishBlobSidecars",
-  /**
-   * Trigger an update of status so reqresp by peers have current earliestAvailableSlot
-   */
-  updateStatus = "updateStatus",
-  /**
-   * Trigger a BlockInputSync for blocks where the parentRoot is not known to fork choice
-   */
-  unknownParent = "unknownParent",
-  /**
-   * Trigger BlockInputSync for objects that correspond to a block that is not known to fork choice
-   */
-  unknownBlockRoot = "unknownBlockRoot",
-  /**
-   * Trigger BlockInputSync for blocks that are partially received via gossip but are not complete by time the
-   * cut-off window passes for waiting on gossip
-   */
-  incompleteBlockInput = "incompleteBlockInput",
-}
-
-export type HeadEventData = routes.events.EventData[routes.events.EventType.head];
-export type ReorgEventData = routes.events.EventData[routes.events.EventType.chainReorg];
-
-// API events are emitted through the same ChainEventEmitter for re-use internally
-type ApiEvents = {[K in routes.events.EventType]: (data: routes.events.EventData[K]) => void};
-
-export type ChainEventData = {
-  [ChainEvent.unknownParent]: {blockInput: IBlockInput; peer: PeerIdStr; source: BlockInputSource};
-  [ChainEvent.unknownBlockRoot]: {rootHex: RootHex; peer?: PeerIdStr; source: BlockInputSource};
-  [ChainEvent.incompleteBlockInput]: {blockInput: IBlockInput; peer: PeerIdStr; source: BlockInputSource};
-};
-
-export type IChainEvents = ApiEvents & {
-  [ChainEvent.checkpoint]: (checkpoint: phase0.Checkpoint, state: CachedBeaconStateAllForks) => void;
-
-  [ChainEvent.forkChoiceJustified]: (checkpoint: CheckpointWithHex) => void;
-  [ChainEvent.forkChoiceFinalized]: (checkpoint: CheckpointWithHex) => void;
-
-  [ChainEvent.updateTargetCustodyGroupCount]: (targetGroupCount: number) => void;
-
-  [ChainEvent.publishDataColumns]: (sidecars: fulu.DataColumnSidecar[]) => void;
-
-  [ChainEvent.publishBlobSidecars]: (sidecars: deneb.BlobSidecar[]) => void;
-
-  [ChainEvent.updateStatus]: () => void;
-
-  // Sync events that are chain->chain. Initiated from network requests but do not cross the network
-  // barrier so are considered ChainEvent(s).
-  [ChainEvent.unknownParent]: (data: ChainEventData[ChainEvent.unknownParent]) => void;
-  [ChainEvent.unknownBlockRoot]: (data: ChainEventData[ChainEvent.unknownBlockRoot]) => void;
-  [ChainEvent.incompleteBlockInput]: (data: ChainEventData[ChainEvent.incompleteBlockInput]) => void;
-};
-
-/**
- * Emits important chain events that occur during normal chain operation.
- *
- * Chain events can be broken into several categories:
- * - Clock: the chain's clock is updated
- * - Fork Choice: the chain's fork choice is updated
- * - Processing: the chain processes attestations and blocks, either successfully or with an error
- * - Checkpointing: the chain processes epoch boundaries
- */
-export class ChainEventEmitter extends (EventEmitter as {new (): StrictEventEmitter<EventEmitter, IChainEvents>}) {}

package/src/chain/errors/attestationError.ts

@@ -1,194 +0,0 @@
-import {Epoch, RootHex, Slot, ValidatorIndex} from "@lodestar/types";
-import {toRootHex} from "@lodestar/utils";
-import {GossipActionError} from "./gossipValidation.js";
-
-export enum AttestationErrorCode {
-  /**
-   * The target state cannot be fetched
-   */
-  TARGET_STATE_MISSING = "ATTESTATION_ERROR_TARGET_STATE_MISSING",
-  /**
-   * The attestation is from a slot that is later than the current slot (with respect to the gossip clock disparity).
-   */
-  FUTURE_SLOT = "ATTESTATION_ERROR_FUTURE_SLOT",
-  /**
-   * The attestation is from a slot that is prior to the earliest permissible slot
-   * (with respect to the gossip clock disparity).
-   */
-  PAST_SLOT = "ATTESTATION_ERROR_PAST_SLOT",
-  /**
-   * The attestations aggregation bits were empty when they shouldn't be.
-   */
-  EMPTY_AGGREGATION_BITFIELD = "ATTESTATION_ERROR_EMPTY_AGGREGATION_BITFIELD",
-  /**
-   * The `selection_proof` on the aggregate attestation selects it as a validator,
-   * however the aggregator index is not in the committee for that attestation.
-   */
-  AGGREGATOR_NOT_IN_COMMITTEE = "ATTESTATION_ERROR_AGGREGATOR_NOT_IN_COMMITTEE",
-  /**
-   * The aggregator index refers to a validator index that we have not seen.
-   */
-  AGGREGATOR_PUBKEY_UNKNOWN = "ATTESTATION_ERROR_AGGREGATOR_PUBKEY_UNKNOWN",
-  /**
-   * The attestation has been seen before; either in a block, on the gossip network or from a local validator.
-   */
-  ATTESTATION_ALREADY_KNOWN = "ATTESTATION_ERROR_ATTESTATION_ALREADY_KNOWN",
-  /**
-   * There has already been an aggregation observed for this validator, we refuse to process a second.
-   */
-  AGGREGATOR_ALREADY_KNOWN = "ATTESTATION_ERROR_AGGREGATOR_ALREADY_KNOWN",
-  /**
-   * All of the attesters are known, we refuse to process subset of attesting indices since it brings no value.
-   */
-  ATTESTERS_ALREADY_KNOWN = "ATTESTATION_ERROR_ATTESTERS_ALREADY_KNOWN",
-  /**
-   * The aggregator index is higher than the maximum possible validator count.
-   */
-  AGGREGATOR_INDEX_TOO_HIGH = "ATTESTATION_ERROR_AGGREGATOR_INDEX_TOO_HIGH",
-  /**
-   * The `attestation.data.beacon_block_root` block is unknown or prefinalized.
-   */
-  UNKNOWN_OR_PREFINALIZED_BEACON_BLOCK_ROOT = "ATTESTATION_ERROR_UNKNOWN_OR_PREFINALIZED_BEACON_BLOCK_ROOT",
-  /**
-   * The `attestation.data.slot` is not from the same epoch as `data.target.epoch`.
-   */
-  BAD_TARGET_EPOCH = "ATTESTATION_ERROR_BAD_TARGET_EPOCH",
-  /**
-   * The `attestation.data.beaconBlockRoot` is not a descendant of `data.target.root`.
-   */
-  HEAD_NOT_TARGET_DESCENDANT = "ATTESTATION_ERROR_HEAD_NOT_TARGET_DESCENDANT",
-  /**
-   * The target root of the attestation points to a block that we have not verified.
-   */
-  UNKNOWN_TARGET_ROOT = "ATTESTATION_ERROR_UNKNOWN_TARGET_ROOT",
-  /**
-   * A signature on the attestation is invalid.
-   */
-  INVALID_SIGNATURE = "ATTESTATION_ERROR_INVALID_SIGNATURE",
-  /**
-   * The unaggregated attestation doesn't have only one aggregation bit set.
-   */
-  NOT_EXACTLY_ONE_AGGREGATION_BIT_SET = "ATTESTATION_ERROR_NOT_EXACTLY_ONE_AGGREGATION_BIT_SET",
-  /**
-   * We have already observed an attestation for the `validator_index` and refuse to process another.
-   */
-  PRIOR_ATTESTATION_KNOWN = "ATTESTATION_ERROR_PRIOR_ATTESTATION_KNOWN",
-  /**
-   * The attestation is for an epoch in the future (with respect to the gossip clock disparity).
-   */
-  FUTURE_EPOCH = "ATTESTATION_ERROR_FUTURE_EPOCH",
-  /**
-   * The attestation is for an epoch in the past (with respect to the gossip clock disparity).
-   */
-  PAST_EPOCH = "ATTESTATION_ERROR_PAST_EPOCH",
-  /**
-   * The attestation is attesting to a state that is later than itself. (Viz., attesting to the future).
-   */
-  ATTESTS_TO_FUTURE_BLOCK = "ATTESTATION_ERROR_ATTESTS_TO_FUTURE_BLOCK",
-  /**
-   * The attestation was received on an invalid attestation subnet.
-   */
-  INVALID_SUBNET_ID = "ATTESTATION_ERROR_INVALID_SUBNET_ID",
-  /**
-   * Number of aggregation bits does not match committee size
-   */
-  WRONG_NUMBER_OF_AGGREGATION_BITS = "ATTESTATION_ERROR_WRONG_NUMBER_OF_AGGREGATION_BITS",
-  /**
-   * Block did not pass validation during block processing.
-   */
-  KNOWN_BAD_BLOCK = "ATTESTATION_ERROR_KNOWN_BAD_BLOCK",
-  /**
-   * The current finalized checkpoint is not an ancestor of the block defined by attestation.data.beacon_block_root.
-   */
-  INVALID_TARGET_ROOT = "ATTESTATION_ERROR_INVALID_TARGET_ROOT",
-  /**
-   * The The attestation target block is not an ancestor of the block named in the LMD vote.
-   */
-  TARGET_BLOCK_NOT_AN_ANCESTOR_OF_LMD_BLOCK = "ATTESTATION_ERROR_TARGET_BLOCK_NOT_AN_ANCESTOR_OF_LMD_BLOCK",
-  /**
-   * Committee index out of range.
-   */
-  COMMITTEE_INDEX_OUT_OF_RANGE = "ATTESTATION_ERROR_COMMITTEE_INDEX_OUT_OF_RANGE",
-  /**
-   * Missing state to verify attestation
-   */
-  MISSING_STATE_TO_VERIFY_ATTESTATION = "ATTESTATION_ERROR_MISSING_STATE_TO_VERIFY_ATTESTATION",
-  /**
-   * Invalid aggregator.
-   */
-  INVALID_AGGREGATOR = "ATTESTATION_ERROR_INVALID_AGGREGATOR",
-  /**
-   * Invalid attestation indexes: not sorted or unique
-   */
-  INVALID_INDEXED_ATTESTATION = "ATTESTATION_ERROR_INVALID_INDEXED_ATTESTATION",
-  /**
-   * Invalid ssz bytes.
-   */
-  INVALID_SERIALIZED_BYTES = "ATTESTATION_ERROR_INVALID_SERIALIZED_BYTES",
-  /** Too many skipped slots. */
-  TOO_MANY_SKIPPED_SLOTS = "ATTESTATION_ERROR_TOO_MANY_SKIPPED_SLOTS",
-  /**
-   * Electra: The aggregated attestation does not have exactly one committee bit set.
-   */
-  NOT_EXACTLY_ONE_COMMITTEE_BIT_SET = "ATTESTATION_ERROR_NOT_EXACTLY_ONE_COMMITTEE_BIT_SET",
-  /**
-   * Electra: Invalid attestationData index: is non-zero
-   */
-  NON_ZERO_ATTESTATION_DATA_INDEX = "ATTESTATION_ERROR_NON_ZERO_ATTESTATION_DATA_INDEX",
-  /**
-   * Electra: Attester not in committee
-   */
-  ATTESTER_NOT_IN_COMMITTEE = "ATTESTATION_ERROR_ATTESTER_NOT_IN_COMMITTEE",
-}
-
-export type AttestationErrorType =
-  | {code: AttestationErrorCode.TARGET_STATE_MISSING}
-  | {code: AttestationErrorCode.FUTURE_SLOT; attestationSlot: Slot; latestPermissibleSlot: Slot}
-  | {code: AttestationErrorCode.PAST_SLOT; attestationSlot: Slot; earliestPermissibleSlot: Slot}
-  | {code: AttestationErrorCode.EMPTY_AGGREGATION_BITFIELD}
-  | {code: AttestationErrorCode.AGGREGATOR_NOT_IN_COMMITTEE}
-  | {code: AttestationErrorCode.AGGREGATOR_PUBKEY_UNKNOWN; aggregatorIndex: ValidatorIndex}
-  | {code: AttestationErrorCode.ATTESTATION_ALREADY_KNOWN; targetEpoch: Epoch; validatorIndex: number}
-  | {code: AttestationErrorCode.AGGREGATOR_ALREADY_KNOWN; targetEpoch: Epoch; aggregatorIndex: number}
-  | {code: AttestationErrorCode.ATTESTERS_ALREADY_KNOWN; targetEpoch: Epoch; aggregateRoot: RootHex}
-  | {code: AttestationErrorCode.AGGREGATOR_INDEX_TOO_HIGH; aggregatorIndex: ValidatorIndex}
-  | {code: AttestationErrorCode.UNKNOWN_OR_PREFINALIZED_BEACON_BLOCK_ROOT; root: RootHex}
-  | {code: AttestationErrorCode.BAD_TARGET_EPOCH}
-  | {code: AttestationErrorCode.HEAD_NOT_TARGET_DESCENDANT}
-  | {code: AttestationErrorCode.UNKNOWN_TARGET_ROOT; root: Uint8Array}
-  | {code: AttestationErrorCode.INVALID_SIGNATURE}
-  | {code: AttestationErrorCode.NOT_EXACTLY_ONE_AGGREGATION_BIT_SET}
-  | {code: AttestationErrorCode.PRIOR_ATTESTATION_KNOWN; validatorIndex: ValidatorIndex; epoch: Epoch}
-  | {code: AttestationErrorCode.FUTURE_EPOCH; attestationEpoch: Epoch; currentEpoch: Epoch}
-  | {code: AttestationErrorCode.PAST_EPOCH; attestationEpoch: Epoch; previousEpoch: Epoch}
-  | {code: AttestationErrorCode.ATTESTS_TO_FUTURE_BLOCK; block: Slot; attestation: Slot}
-  | {code: AttestationErrorCode.INVALID_SUBNET_ID; received: number; expected: number}
-  | {code: AttestationErrorCode.WRONG_NUMBER_OF_AGGREGATION_BITS}
-  | {code: AttestationErrorCode.KNOWN_BAD_BLOCK}
-  | {code: AttestationErrorCode.INVALID_TARGET_ROOT; targetRoot: RootHex; expected: string | null}
-  | {code: AttestationErrorCode.TARGET_BLOCK_NOT_AN_ANCESTOR_OF_LMD_BLOCK}
-  | {code: AttestationErrorCode.COMMITTEE_INDEX_OUT_OF_RANGE; index: number}
-  | {code: AttestationErrorCode.MISSING_STATE_TO_VERIFY_ATTESTATION; error: Error}
-  | {code: AttestationErrorCode.INVALID_AGGREGATOR}
-  | {code: AttestationErrorCode.INVALID_INDEXED_ATTESTATION}
-  | {code: AttestationErrorCode.INVALID_SERIALIZED_BYTES}
-  | {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};
-
-export class AttestationError extends GossipActionError<AttestationErrorType> {
-  getMetadata(): Record<string, string | number | null> {
-    const type = this.type;
-    switch (type.code) {
-      case AttestationErrorCode.UNKNOWN_TARGET_ROOT:
-        return {code: type.code, root: toRootHex(type.root)};
-      case AttestationErrorCode.MISSING_STATE_TO_VERIFY_ATTESTATION:
-        // TODO: The stack trace gets lost here
-        return {code: type.code, error: type.error.message};
-
-      default:
-        return type;
-    }
-  }
-}

package/src/chain/errors/attesterSlashingError.ts

@@ -1,11 +0,0 @@
-import {GossipActionError} from "./gossipValidation.js";
-
-export enum AttesterSlashingErrorCode {
-  ALREADY_EXISTS = "ATTESTATION_SLASHING_ERROR_ALREADY_EXISTS",
-  INVALID = "ATTESTATION_SLASHING_ERROR_INVALID",
-}
-export type AttesterSlashingErrorType =
-  | {code: AttesterSlashingErrorCode.ALREADY_EXISTS}
-  | {code: AttesterSlashingErrorCode.INVALID; error: Error};
-
-export class AttesterSlashingError extends GossipActionError<AttesterSlashingErrorType> {}

package/src/chain/errors/blobSidecarError.ts

@@ -1,60 +0,0 @@
-import {RootHex, Slot, SubnetID, ValidatorIndex} from "@lodestar/types";
-import {LodestarError} from "@lodestar/utils";
-import {GossipActionError} from "./gossipValidation.js";
-
-export enum BlobSidecarErrorCode {
-  INDEX_TOO_LARGE = "BLOB_SIDECAR_ERROR_INDEX_TOO_LARGE",
-  INVALID_INDEX = "BLOB_SIDECAR_ERROR_INVALID_INDEX",
-  /** !bls.KeyValidate(block.body.blob_kzg_commitments[i]) */
-  INVALID_KZG = "BLOB_SIDECAR_ERROR_INVALID_KZG",
-  /** !verify_kzg_commitments_against_transactions(block.body.execution_payload.transactions, block.body.blob_kzg_commitments) */
-  INVALID_KZG_TXS = "BLOB_SIDECAR_ERROR_INVALID_KZG_TXS",
-  /** sidecar.beacon_block_slot != block.slot */
-  INCORRECT_SLOT = "BLOB_SIDECAR_ERROR_INCORRECT_SLOT",
-  /** BLSFieldElement in valid range (x < BLS_MODULUS) */
-  INVALID_BLOB = "BLOB_SIDECAR_ERROR_INVALID_BLOB",
-  /** !bls.KeyValidate(blobs_sidecar.kzg_aggregated_proof) */
-  INVALID_KZG_PROOF = "BLOBS_SIDECAR_ERROR_INVALID_KZG_PROOF",
-
-  // Validation errors when validating against an existing block
-
-  /** Block and sidecars blob count mismatch */
-  INCORRECT_SIDECAR_COUNT = "BLOBS_SIDECAR_ERROR_INCORRECT_SIDECAR_COUNT",
-  /** Sidecar doesn't match block */
-  INCORRECT_BLOCK = "BLOBS_SIDECAR_ERROR_INCORRECT_BLOCK",
-  /** Sidecars proofs not valid */
-  INVALID_KZG_PROOF_BATCH = "BLOBS_SIDECAR_ERROR_INVALID_KZG_PROOF_BATCH",
-
-  // following errors are adapted from the block errors
-  FUTURE_SLOT = "BLOB_SIDECAR_ERROR_FUTURE_SLOT",
-  WOULD_REVERT_FINALIZED_SLOT = "BLOB_SIDECAR_ERROR_WOULD_REVERT_FINALIZED_SLOT",
-  ALREADY_KNOWN = "BLOB_SIDECAR_ERROR_ALREADY_KNOWN",
-  PARENT_UNKNOWN = "BLOB_SIDECAR_ERROR_PARENT_UNKNOWN",
-  NOT_LATER_THAN_PARENT = "BLOB_SIDECAR_ERROR_NOT_LATER_THAN_PARENT",
-  PROPOSAL_SIGNATURE_INVALID = "BLOB_SIDECAR_ERROR_PROPOSAL_SIGNATURE_INVALID",
-  INCLUSION_PROOF_INVALID = "BLOB_SIDECAR_ERROR_INCLUSION_PROOF_INVALID",
-  INCORRECT_PROPOSER = "BLOB_SIDECAR_ERROR_INCORRECT_PROPOSER",
-}
-
-export type BlobSidecarErrorType =
-  | {code: BlobSidecarErrorCode.INDEX_TOO_LARGE; blobIdx: number; maxBlobsPerBlock: number}
-  | {code: BlobSidecarErrorCode.INVALID_INDEX; blobIdx: number; subnet: SubnetID}
-  | {code: BlobSidecarErrorCode.INVALID_KZG; blobIdx: number}
-  | {code: BlobSidecarErrorCode.INVALID_KZG_TXS}
-  | {code: BlobSidecarErrorCode.INCORRECT_SLOT; blockSlot: Slot; blobSlot: Slot; blobIdx: number}
-  | {code: BlobSidecarErrorCode.INVALID_BLOB; blobIdx: number}
-  | {code: BlobSidecarErrorCode.INVALID_KZG_PROOF; blobIdx: number}
-  | {code: BlobSidecarErrorCode.INCORRECT_SIDECAR_COUNT; slot: number; expected: number; actual: number}
-  | {code: BlobSidecarErrorCode.INCORRECT_BLOCK; slot: number; blobIdx: number; expected: string; actual: string}
-  | {code: BlobSidecarErrorCode.INVALID_KZG_PROOF_BATCH; slot: number; reason: string}
-  | {code: BlobSidecarErrorCode.FUTURE_SLOT; blockSlot: Slot; currentSlot: Slot}
-  | {code: BlobSidecarErrorCode.WOULD_REVERT_FINALIZED_SLOT; blockSlot: Slot; finalizedSlot: Slot}
-  | {code: BlobSidecarErrorCode.ALREADY_KNOWN; root: RootHex}
-  | {code: BlobSidecarErrorCode.PARENT_UNKNOWN; parentRoot: RootHex}
-  | {code: BlobSidecarErrorCode.NOT_LATER_THAN_PARENT; parentSlot: Slot; slot: Slot}
-  | {code: BlobSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID}
-  | {code: BlobSidecarErrorCode.INCLUSION_PROOF_INVALID; slot: Slot; blobIdx: number}
-  | {code: BlobSidecarErrorCode.INCORRECT_PROPOSER; proposerIndex: ValidatorIndex};
-
-export class BlobSidecarGossipError extends GossipActionError<BlobSidecarErrorType> {}
-export class BlobSidecarValidationError extends LodestarError<BlobSidecarErrorType> {}

package/src/chain/errors/blockError.ts

@@ -1,166 +0,0 @@
-import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {RootHex, SignedBeaconBlock, Slot, ValidatorIndex} from "@lodestar/types";
-import {LodestarError, toRootHex} from "@lodestar/utils";
-import {ExecutionPayloadStatus} from "../../execution/engine/interface.js";
-import {QueueErrorCode} from "../../util/queue/index.js";
-import {GossipActionError} from "./gossipValidation.js";
-
-export enum BlockErrorCode {
-  /** The prestate cannot be fetched */
-  PRESTATE_MISSING = "BLOCK_ERROR_PRESTATE_MISSING",
-  /** The parent block was unknown. */
-  PARENT_UNKNOWN = "BLOCK_ERROR_PARENT_UNKNOWN",
-  /** The block slot is greater than the present slot. */
-  FUTURE_SLOT = "BLOCK_ERROR_FUTURE_SLOT",
-  /** The block state_root does not match the generated state. */
-  STATE_ROOT_MISMATCH = "BLOCK_ERROR_STATE_ROOT_MISMATCH",
-  /** The block was a genesis block, these blocks cannot be re-imported. */
-  GENESIS_BLOCK = "BLOCK_ERROR_GENESIS_BLOCK",
-  /** The slot is finalized, no need to import. */
-  WOULD_REVERT_FINALIZED_SLOT = "BLOCK_ERROR_WOULD_REVERT_FINALIZED_SLOT",
-  /** Block is already known, no need to re-import. */
-  ALREADY_KNOWN = "BLOCK_ERROR_ALREADY_KNOWN",
-  /** A block for this proposer and slot has already been observed. */
-  REPEAT_PROPOSAL = "BLOCK_ERROR_REPEAT_PROPOSAL",
-  /** The block slot exceeds the MAXIMUM_BLOCK_SLOT_NUMBER. */
-  BLOCK_SLOT_LIMIT_REACHED = "BLOCK_ERROR_BLOCK_SLOT_LIMIT_REACHED",
-  /** The `BeaconBlock` has a `proposer_index` that does not match the index we computed locally. */
-  INCORRECT_PROPOSER = "BLOCK_ERROR_INCORRECT_PROPOSER",
-  /** The proposal signature in invalid. */
-  PROPOSAL_SIGNATURE_INVALID = "BLOCK_ERROR_PROPOSAL_SIGNATURE_INVALID",
-  /** The `block.proposer_index` is not known. */
-  UNKNOWN_PROPOSER = "BLOCK_ERROR_UNKNOWN_PROPOSER",
-  /** A signature in the block is invalid (exactly which is unknown). */
-  INVALID_SIGNATURE = "BLOCK_ERROR_INVALID_SIGNATURE",
-  /** Block transition returns invalid state root. */
-  INVALID_STATE_ROOT = "BLOCK_ERROR_INVALID_STATE_ROOT",
-  /** Block (its parent) is not a descendant of current finalized block */
-  NOT_FINALIZED_DESCENDANT = "BLOCK_ERROR_NOT_FINALIZED_DESCENDANT",
-  /** The provided block is from an later slot than its parent. */
-  NOT_LATER_THAN_PARENT = "BLOCK_ERROR_NOT_LATER_THAN_PARENT",
-  /** At least one block in the chain segment did not have it's parent root set to the root of the prior block. */
-  NON_LINEAR_PARENT_ROOTS = "BLOCK_ERROR_NON_LINEAR_PARENT_ROOTS",
-  /** The slots of the blocks in the chain segment were not strictly increasing. */
-  NON_LINEAR_SLOTS = "BLOCK_ERROR_NON_LINEAR_SLOTS",
-  /** The block failed the specification's `per_block_processing` function, it is invalid. */
-  PER_BLOCK_PROCESSING_ERROR = "BLOCK_ERROR_PER_BLOCK_PROCESSING_ERROR",
-  /** There was an error whilst processing the block. It is not necessarily invalid. */
-  BEACON_CHAIN_ERROR = "BLOCK_ERROR_BEACON_CHAIN_ERROR",
-  /** Block did not pass validation during block processing. */
-  KNOWN_BAD_BLOCK = "BLOCK_ERROR_KNOWN_BAD_BLOCK",
-  /** Blacklisted blocks that should not pass processing */
-  BLACKLISTED_BLOCK = "BLOCK_ERROR_BLACKLISTED_BLOCK",
-  // Merge p2p
-  /** executionPayload.timestamp is not the expected value */
-  INCORRECT_TIMESTAMP = "BLOCK_ERROR_INCORRECT_TIMESTAMP",
-  /** executionPayload.gasUsed > executionPayload.gasLimit */
-  TOO_MUCH_GAS_USED = "BLOCK_ERROR_TOO_MUCH_GAS_USED",
-  /** executionPayload.blockHash == executionPayload.parentHash */
-  SAME_PARENT_HASH = "BLOCK_ERROR_SAME_PARENT_HASH",
-  /** Total size of executionPayload.transactions exceed a sane limit to prevent DOS attacks */
-  TRANSACTIONS_TOO_BIG = "BLOCK_ERROR_TRANSACTIONS_TOO_BIG",
-  /** Execution engine is unavailable, syncing, or api call errored. Peers must not be downscored on this code */
-  EXECUTION_ENGINE_ERROR = "BLOCK_ERROR_EXECUTION_ERROR",
-  /** The attestation head block is too far behind the attestation slot, causing many skip slots.
-  This is deemed a DoS risk */
-  TOO_MANY_SKIPPED_SLOTS = "TOO_MANY_SKIPPED_SLOTS",
-  /** The blobs are unavailable */
-  DATA_UNAVAILABLE = "BLOCK_ERROR_DATA_UNAVAILABLE",
-  /** Block contains too many kzg commitments */
-  TOO_MANY_KZG_COMMITMENTS = "BLOCK_ERROR_TOO_MANY_KZG_COMMITMENTS",
-}
-
-type ExecutionErrorStatus = Exclude<
-  ExecutionPayloadStatus,
-  ExecutionPayloadStatus.VALID | ExecutionPayloadStatus.ACCEPTED | ExecutionPayloadStatus.SYNCING
->;
-
-export type BlockErrorType =
-  | {code: BlockErrorCode.PRESTATE_MISSING; error: Error}
-  | {code: BlockErrorCode.PARENT_UNKNOWN; parentRoot: RootHex}
-  | {code: BlockErrorCode.FUTURE_SLOT; blockSlot: Slot; currentSlot: Slot}
-  | {code: BlockErrorCode.STATE_ROOT_MISMATCH}
-  | {code: BlockErrorCode.GENESIS_BLOCK}
-  | {code: BlockErrorCode.TOO_MANY_SKIPPED_SLOTS; parentSlot: Slot; blockSlot: Slot}
-  | {code: BlockErrorCode.WOULD_REVERT_FINALIZED_SLOT; blockSlot: Slot; finalizedSlot: Slot}
-  | {code: BlockErrorCode.ALREADY_KNOWN; root: RootHex}
-  | {code: BlockErrorCode.REPEAT_PROPOSAL; proposerIndex: ValidatorIndex}
-  | {code: BlockErrorCode.BLOCK_SLOT_LIMIT_REACHED}
-  | {code: BlockErrorCode.INCORRECT_PROPOSER; proposerIndex: ValidatorIndex}
-  | {code: BlockErrorCode.PROPOSAL_SIGNATURE_INVALID}
-  | {code: BlockErrorCode.UNKNOWN_PROPOSER; proposerIndex: ValidatorIndex}
-  | {code: BlockErrorCode.INVALID_SIGNATURE; state: CachedBeaconStateAllForks}
-  | {
-      code: BlockErrorCode.INVALID_STATE_ROOT;
-      root: Uint8Array;
-      expectedRoot: Uint8Array;
-      preState: CachedBeaconStateAllForks;
-      postState: CachedBeaconStateAllForks;
-    }
-  | {code: BlockErrorCode.NOT_FINALIZED_DESCENDANT; parentRoot: RootHex}
-  | {code: BlockErrorCode.NOT_LATER_THAN_PARENT; parentSlot: Slot; slot: Slot}
-  | {code: BlockErrorCode.NON_LINEAR_PARENT_ROOTS}
-  | {code: BlockErrorCode.NON_LINEAR_SLOTS}
-  | {code: BlockErrorCode.PER_BLOCK_PROCESSING_ERROR; error: Error}
-  | {code: BlockErrorCode.BEACON_CHAIN_ERROR; error: Error}
-  | {code: BlockErrorCode.KNOWN_BAD_BLOCK}
-  | {code: BlockErrorCode.BLACKLISTED_BLOCK}
-  | {code: BlockErrorCode.INCORRECT_TIMESTAMP; timestamp: number; expectedTimestamp: number}
-  | {code: BlockErrorCode.TOO_MUCH_GAS_USED; gasUsed: number; gasLimit: number}
-  | {code: BlockErrorCode.SAME_PARENT_HASH; blockHash: RootHex}
-  | {code: BlockErrorCode.TRANSACTIONS_TOO_BIG; size: number; max: number}
-  | {code: BlockErrorCode.EXECUTION_ENGINE_ERROR; execStatus: ExecutionErrorStatus; errorMessage: string}
-  | {code: BlockErrorCode.DATA_UNAVAILABLE}
-  | {code: BlockErrorCode.TOO_MANY_KZG_COMMITMENTS; blobKzgCommitmentsLen: number; commitmentLimit: number};
-
-export class BlockGossipError extends GossipActionError<BlockErrorType> {}
-
-export class BlockError extends LodestarError<BlockErrorType> {
-  constructor(
-    readonly signedBlock: SignedBeaconBlock,
-    type: BlockErrorType
-  ) {
-    super(type);
-  }
-
-  getMetadata(): Record<string, string | number | null> {
-    return renderBlockErrorType(this.type);
-  }
-}
-
-export function isBlockErrorAborted(e: unknown): e is BlockError {
-  return (
-    e instanceof BlockError &&
-    e.type.code === BlockErrorCode.EXECUTION_ENGINE_ERROR &&
-    e.type.errorMessage === QueueErrorCode.QUEUE_ABORTED
-  );
-}
-
-export function renderBlockErrorType(type: BlockErrorType): Record<string, string | number | null> {
-  switch (type.code) {
-    case BlockErrorCode.PRESTATE_MISSING:
-    case BlockErrorCode.PER_BLOCK_PROCESSING_ERROR:
-    case BlockErrorCode.BEACON_CHAIN_ERROR:
-      return {
-        code: type.code,
-        error: type.error.message,
-      };
-
-    case BlockErrorCode.INVALID_SIGNATURE:
-      return {
-        code: type.code,
-        slot: type.state.slot,
-      };
-
-    case BlockErrorCode.INVALID_STATE_ROOT:
-      return {
-        code: type.code,
-        slot: type.postState.slot,
-        root: toRootHex(type.root),
-        expectedRoot: toRootHex(type.expectedRoot),
-      };
-
-    default:
-      return type;
-  }
-}

package/src/chain/errors/blsToExecutionChangeError.ts

@@ -1,13 +0,0 @@
-import {GossipActionError} from "./gossipValidation.js";
-
-export enum BlsToExecutionChangeErrorCode {
-  ALREADY_EXISTS = "BLS_TO_EXECUTION_CHANGE_ERROR_ALREADY_EXISTS",
-  INVALID = "BLS_TO_EXECUTION_CHANGE_ERROR_INVALID",
-  INVALID_SIGNATURE = "BLS_TO_EXECUTION_CHANGE_ERROR_INVALID_SIGNATURE",
-}
-export type BlsToExecutionChangeErrorType =
-  | {code: BlsToExecutionChangeErrorCode.ALREADY_EXISTS}
-  | {code: BlsToExecutionChangeErrorCode.INVALID}
-  | {code: BlsToExecutionChangeErrorCode.INVALID_SIGNATURE};
-
-export class BlsToExecutionChangeError extends GossipActionError<BlsToExecutionChangeErrorType> {}

package/src/chain/errors/dataColumnSidecarError.ts

@@ -1,80 +0,0 @@
-import {RootHex, Slot, SubnetID} from "@lodestar/types";
-import {LodestarError} from "@lodestar/utils";
-import {GossipActionError} from "./gossipValidation.js";
-
-export enum DataColumnSidecarErrorCode {
-  INVALID_INDEX = "DATA_COLUMN_SIDECAR_ERROR_INVALID_INDEX",
-  NO_COMMITMENTS = "DATA_COLUMN_SIDECAR_ERROR_NO_COMMITMENTS",
-  MISMATCHED_LENGTHS = "DATA_COLUMN_SIDECAR_ERROR_MISMATCHED_LENGTHS",
-  INVALID_SUBNET = "DATA_COLUMN_SIDECAR_ERROR_INVALID_SUBNET",
-  INVALID_KZG_PROOF = "DATA_COLUMN_SIDECAR_ERROR_INVALID_KZG_PROOF",
-
-  // Validation errors when validating against an existing block
-
-  /** Block and sidecars data column count mismatch */
-  INCORRECT_SIDECAR_COUNT = "DATA_COLUMN_SIDECAR_ERROR_INCORRECT_SIDECAR_COUNT",
-  /** Sidecar doesn't match block */
-  INCORRECT_BLOCK = "DATA_COLUMN_SIDECAR_ERROR_INCORRECT_BLOCK",
-  /** Sidecar kzg proof count not as expected */
-  INCORRECT_KZG_COMMITMENTS_COUNT = "DATA_COLUMN_SIDECAR_ERROR_INCORRECT_KZG_COMMITMENTS_COUNT",
-  /** Sidecar kzg proof count not as expected */
-  INCORRECT_KZG_PROOF_COUNT = "DATA_COLUMN_SIDECAR_ERROR_INCORRECT_KZG_PROOF_COUNT",
-  /** Sidecars proofs not valid */
-  INVALID_KZG_PROOF_BATCH = "DATA_COLUMN_SIDECAR_ERROR_INVALID_KZG_PROOF_BATCH",
-
-  // following errors are adapted from the block errors
-  ALREADY_KNOWN = "DATA_COLUMN_SIDECAR_ERROR_ALREADY_KNOWN",
-  FUTURE_SLOT = "DATA_COLUMN_SIDECAR_ERROR_FUTURE_SLOT",
-  WOULD_REVERT_FINALIZED_SLOT = "DATA_COLUMN_SIDECAR_ERROR_WOULD_REVERT_FINALIZED_SLOT",
-  PARENT_UNKNOWN = "DATA_COLUMN_SIDECAR_ERROR_PARENT_UNKNOWN",
-  NOT_LATER_THAN_PARENT = "DATA_COLUMN_SIDECAR_ERROR_NOT_LATER_THAN_PARENT",
-  PROPOSAL_SIGNATURE_INVALID = "DATA_COLUMN_SIDECAR_ERROR_PROPOSAL_SIGNATURE_INVALID",
-  INCLUSION_PROOF_INVALID = "DATA_COLUMN_SIDECAR_ERROR_INCLUSION_PROOF_INVALID",
-  INCORRECT_PROPOSER = "DATA_COLUMN_SIDECAR_ERROR_INCORRECT_PROPOSER",
-}
-
-export type DataColumnSidecarErrorType =
-  | {code: DataColumnSidecarErrorCode.INVALID_INDEX; slot: Slot; columnIdx: number}
-  | {code: DataColumnSidecarErrorCode.NO_COMMITMENTS; slot: Slot; columnIdx: number}
-  | {
-      code: DataColumnSidecarErrorCode.MISMATCHED_LENGTHS;
-      columnLength: number;
-      commitmentsLength: number;
-      proofsLength: number;
-    }
-  | {code: DataColumnSidecarErrorCode.INVALID_SUBNET; columnIdx: number; gossipSubnet: SubnetID}
-  | {code: DataColumnSidecarErrorCode.ALREADY_KNOWN; columnIdx: number; slot: Slot}
-  | {code: DataColumnSidecarErrorCode.FUTURE_SLOT; blockSlot: Slot; currentSlot: Slot}
-  | {code: DataColumnSidecarErrorCode.WOULD_REVERT_FINALIZED_SLOT; blockSlot: Slot; finalizedSlot: Slot}
-  | {code: DataColumnSidecarErrorCode.PARENT_UNKNOWN; parentRoot: RootHex}
-  | {code: DataColumnSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID}
-  | {code: DataColumnSidecarErrorCode.NOT_LATER_THAN_PARENT; parentSlot: Slot; slot: Slot}
-  | {code: DataColumnSidecarErrorCode.INCLUSION_PROOF_INVALID; slot: Slot; columnIdx: number}
-  | {code: DataColumnSidecarErrorCode.INVALID_KZG_PROOF; slot: Slot; columnIdx: number}
-  | {code: DataColumnSidecarErrorCode.INCORRECT_SIDECAR_COUNT; slot: number; expected: number; actual: number}
-  | {
-      code: DataColumnSidecarErrorCode.INCORRECT_BLOCK;
-      slot: number;
-      columnIdx: number;
-      expected: string;
-      actual: string;
-    }
-  | {
-      code: DataColumnSidecarErrorCode.INCORRECT_KZG_COMMITMENTS_COUNT;
-      slot: number;
-      columnIdx: number;
-      expected: number;
-      actual: number;
-    }
-  | {
-      code: DataColumnSidecarErrorCode.INCORRECT_KZG_PROOF_COUNT;
-      slot: number;
-      columnIdx: number;
-      expected: number;
-      actual: number;
-    }
-  | {code: DataColumnSidecarErrorCode.INVALID_KZG_PROOF_BATCH; slot: number; reason: string}
-  | {code: DataColumnSidecarErrorCode.INCORRECT_PROPOSER; actualProposerIndex: number; expectedProposerIndex: number};
-
-export class DataColumnSidecarGossipError extends GossipActionError<DataColumnSidecarErrorType> {}
-export class DataColumnSidecarValidationError extends LodestarError<DataColumnSidecarErrorType> {}

package/src/chain/errors/gossipValidation.ts

@@ -1,20 +0,0 @@
-import {LodestarError} from "@lodestar/utils";
-
-export enum GossipAction {
-  IGNORE = "IGNORE",
-  REJECT = "REJECT",
-}
-
-export enum GossipErrorCode {
-  INVALID_SERIALIZED_BYTES_ERROR_CODE = "GOSSIP_ERROR_INVALID_SERIALIZED_BYTES",
-  PAST_SLOT = "GOSSIP_ERROR_PAST_SLOT",
-}
-
-export class GossipActionError<T extends {code: string}> extends LodestarError<T> {
-  action: GossipAction;
-
-  constructor(action: GossipAction, type: T) {
-    super(type);
-    this.action = action;
-  }
-}