@lodestar/beacon-node 1.35.0-dev.f80d2d52da → 1.35.0-dev.fd1dac853d

package/src/chain/emitter.ts

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,194 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,166 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,20 @@
+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;
+  }
+}