@lodestar/beacon-node 1.35.0-dev.91dadf81de → 1.35.0-dev.955e9f89ed

package/src/network/processor/gossipQueues/index.ts

@@ -1,114 +0,0 @@
-import {mapValues} from "@lodestar/utils";
-import {getBeaconAttestationGossipIndex} from "../../../util/sszBytes.js";
-import {BatchGossipType, GossipType, SequentialGossipType} from "../../gossip/interface.js";
-import {PendingGossipsubMessage} from "../types.js";
-import {IndexedGossipQueueMinSize} from "./indexed.js";
-import {LinearGossipQueue} from "./linear.js";
-import {DropType, GossipQueue, GossipQueueOpts, QueueType, isIndexedGossipQueueMinSizeOpts} from "./types.js";
-
-/**
- * In normal condition, the higher this value the more efficient the signature verification.
- * However, if at least 1 signature is invalid, we need to verify each signature separately.
- */
-const MAX_GOSSIP_ATTESTATION_BATCH_SIZE = 128;
-
-/**
- * Minimum signature sets to batch verify without waiting for 50ms.
- */
-export const MIN_SIGNATURE_SETS_TO_BATCH_VERIFY = 32;
-
-/**
- * Numbers from https://github.com/sigp/lighthouse/blob/b34a79dc0b02e04441ba01fd0f304d1e203d877d/beacon_node/network/src/beacon_processor/mod.rs#L69
- */
-const linearGossipQueueOpts: {
-  [K in SequentialGossipType]: GossipQueueOpts<PendingGossipsubMessage>;
-} = {
-  // validation gossip block asap
-  [GossipType.beacon_block]: {maxLength: 1024, type: QueueType.FIFO, dropOpts: {type: DropType.count, count: 1}},
-  // gossip length for blob is beacon block length * max blobs per block = 4096
-  [GossipType.blob_sidecar]: {
-    maxLength: 4096,
-    type: QueueType.FIFO,
-    dropOpts: {type: DropType.count, count: 1},
-  },
-  [GossipType.data_column_sidecar]: {
-    maxLength: 4096,
-    type: QueueType.FIFO,
-    dropOpts: {type: DropType.count, count: 1},
-  },
-  // lighthoue has aggregate_queue 4096 and unknown_block_aggregate_queue 1024, we use single queue
-  [GossipType.beacon_aggregate_and_proof]: {
-    maxLength: 5120,
-    type: QueueType.LIFO,
-    dropOpts: {type: DropType.count, count: 1},
-  },
-  [GossipType.voluntary_exit]: {maxLength: 4096, type: QueueType.FIFO, dropOpts: {type: DropType.count, count: 1}},
-  [GossipType.proposer_slashing]: {maxLength: 4096, type: QueueType.FIFO, dropOpts: {type: DropType.count, count: 1}},
-  [GossipType.attester_slashing]: {maxLength: 4096, type: QueueType.FIFO, dropOpts: {type: DropType.count, count: 1}},
-  [GossipType.sync_committee_contribution_and_proof]: {
-    maxLength: 4096,
-    type: QueueType.LIFO,
-    dropOpts: {type: DropType.count, count: 1},
-  },
-  [GossipType.sync_committee]: {maxLength: 4096, type: QueueType.LIFO, dropOpts: {type: DropType.count, count: 1}},
-  [GossipType.light_client_finality_update]: {
-    maxLength: 1024,
-    type: QueueType.FIFO,
-    dropOpts: {type: DropType.count, count: 1},
-  },
-  [GossipType.light_client_optimistic_update]: {
-    maxLength: 1024,
-    type: QueueType.FIFO,
-    dropOpts: {type: DropType.count, count: 1},
-  },
-  // lighthouse has bls changes queue set to their max 16384 to handle large spike at capella
-  [GossipType.bls_to_execution_change]: {
-    maxLength: 16384,
-    type: QueueType.FIFO,
-    dropOpts: {type: DropType.count, count: 1},
-  },
-};
-
-const indexedGossipQueueOpts: {
-  [K in BatchGossipType]: GossipQueueOpts<PendingGossipsubMessage>;
-} = {
-  [GossipType.beacon_attestation]: {
-    // lighthouse has attestation_queue 16384 and unknown_block_attestation_queue 8192, we use single queue
-    // this topic may cause node to be overload and drop 100% of lower priority queues
-    maxLength: 24576,
-    indexFn: (item: PendingGossipsubMessage) => {
-      return getBeaconAttestationGossipIndex(item.topic.boundary.fork, item.msg.data);
-    },
-    minChunkSize: MIN_SIGNATURE_SETS_TO_BATCH_VERIFY,
-    maxChunkSize: MAX_GOSSIP_ATTESTATION_BATCH_SIZE,
-  },
-};
-
-/**
- * Wraps a GossipValidatorFn with a queue, to limit the processing of gossip objects by type.
- *
- * A queue here is essential to protect against DOS attacks, where a peer may send many messages at once.
- * Queues also protect the node against overloading. If the node gets bussy with an expensive epoch transition,
- * it may buffer too many gossip objects causing an Out of memory (OOM) error. With a queue the node will reject
- * new objects to fit its current throughput.
- *
- * Queues may buffer objects by
- *  - topic '/eth2/0011aabb/beacon_attestation_0/ssz_snappy'
- *  - type `GossipType.beacon_attestation`
- *  - all objects in one queue
- *
- * By topic is too specific, so by type groups all similar objects in the same queue. All in the same won't allow
- * to customize different queue behaviours per object type (see `gossipQueueOpts`).
- */
-export function createGossipQueues(): {
-  [K in GossipType]: GossipQueue<PendingGossipsubMessage>;
-} {
-  const gossipQueueOpts = {...linearGossipQueueOpts, ...indexedGossipQueueOpts};
-
-  return mapValues(gossipQueueOpts, (opts) => {
-    if (isIndexedGossipQueueMinSizeOpts(opts)) {
-      return new IndexedGossipQueueMinSize(opts);
-    }
-    return new LinearGossipQueue<PendingGossipsubMessage>(opts);
-  });
-}

package/src/network/processor/gossipQueues/indexed.ts

@@ -1,219 +0,0 @@
-import {LinkedList} from "../../../util/array.js";
-import {OrderedSet} from "../../../util/set.js";
-import {GossipQueue, IndexedGossipQueueMinSizeOpts} from "./types.js";
-
-type QueueItem<T> = {
-  listItems: LinkedList<T>;
-  firstSeenMs: number;
-};
-
-/**
- * Enforce minimum wait time for each key. On a mainnet node, wait time for beacon_attestation
- * is more than 500ms, it's worth to take 1/10 of that to help batch more items.
- * This is only needed for key item < minChunkSize.
- */
-const MINIMUM_WAIT_TIME_MS = 50;
-
-/**
- * This implementation tries to get the most items with same key:
- *   - index items by indexFn using a map
- *   - store keys with at least minChunkSize
- *   - on next, pick the last key with minChunkSize, pop up to maxChunkSize items
- *   - on delete, pick the 1st key in the map and delete the 1st item in the list
- * Although it does not strictly follow LIFO, it tries to have that behavior:
- *   - On delete, get the first key and the first item of respective list
- *   - On next pick the last key with minChunksize
- *     - if there is no key with minChunkSize, pop the last item of the last key
- *
- * This is a special gossip queue for beacon_attestation topic
- */
-export class IndexedGossipQueueMinSize<T extends {indexed?: string; queueAddedMs?: number}> implements GossipQueue<T> {
-  private _length = 0;
-  private indexedItems: Map<string, QueueItem<T>>;
-  // keys with at least minChunkSize items
-  // we want to process the last key with minChunkSize first, similar to LIFO
-  private minChunkSizeKeys = new OrderedSet<string>();
-  // wait time for the next() function to prevent having to search for items >=MINIMUM_WAIT_TIME_MS old repeatedly
-  // this value is <= MINIMUM_WAIT_TIME_MS
-  private nextWaitTimeMs: number | null = null;
-  // the last time we checked for items >=MINIMUM_WAIT_TIME_MS old
-  private lastWaitTimeCheckedMs = 0;
-  constructor(private readonly opts: IndexedGossipQueueMinSizeOpts<T>) {
-    const {minChunkSize, maxChunkSize} = opts;
-    if (minChunkSize < 0 || maxChunkSize < 0 || minChunkSize > maxChunkSize) {
-      throw Error(`Unexpected min chunk size ${minChunkSize}, max chunk size ${maxChunkSize}}`);
-    }
-    this.indexedItems = new Map<string, QueueItem<T>>();
-  }
-
-  get length(): number {
-    return this._length;
-  }
-
-  get keySize(): number {
-    return this.indexedItems.size;
-  }
-
-  clear(): void {
-    this.indexedItems = new Map();
-    this._length = 0;
-    this.minChunkSizeKeys = new OrderedSet();
-  }
-
-  /**
-   * Get age of each key in ms.
-   */
-  getDataAgeMs(): number[] {
-    const now = Date.now();
-    const result: number[] = [];
-    for (const queueItem of this.indexedItems.values()) {
-      result.push(now - queueItem.firstSeenMs);
-    }
-    return result;
-  }
-
-  /**
-   * Add item to gossip queue. If queue is full, drop first item of first key.
-   * Return number of items dropped
-   */
-  add(item: T): number {
-    const key = this.opts.indexFn(item);
-    if (key == null) {
-      // this comes from getAttDataBase64FromAttestationSerialized() return type
-      // should not happen
-      return 0;
-    }
-    const now = Date.now();
-    // here we mutate item, which is used for gossip validation later
-    item.indexed = key;
-    item.queueAddedMs = now;
-    let queueItem = this.indexedItems.get(key);
-    if (queueItem == null) {
-      queueItem = {firstSeenMs: now, listItems: new LinkedList<T>()};
-      this.indexedItems.set(key, queueItem);
-    }
-    queueItem.listItems.push(item);
-    if (queueItem.listItems.length >= this.opts.minChunkSize) {
-      this.minChunkSizeKeys.add(key);
-    }
-    this._length++;
-    if (this._length <= this.opts.maxLength) {
-      return 0;
-    }
-
-    // overload, need to drop more items
-    const firstKey = this.indexedItems.keys().next().value as string | undefined;
-    // there should be at least 1 key
-    if (firstKey == null) {
-      return 0;
-    }
-    const firstQueueItem = this.indexedItems.get(firstKey);
-    // should not happen
-    if (firstQueueItem == null) {
-      return 0;
-    }
-    const deletedItem = firstQueueItem.listItems.shift();
-    if (deletedItem != null) {
-      this._length--;
-      if (firstQueueItem.listItems.length === 0) {
-        this.indexedItems.delete(firstKey);
-      }
-      if (firstQueueItem.listItems.length < this.opts.minChunkSize) {
-        // it's faster to search for deleted item from the head in this case
-        this.minChunkSizeKeys.delete(firstKey, true);
-      }
-      return 1;
-    }
-    return 0;
-  }
-
-  /**
-   * Try to get items of last key with minChunkSize first.
-   * If not, pick the last key with MINIMUM_WAIT_TIME_MS old
-   */
-  next(): T[] | null {
-    let key: string | null = this.minChunkSizeKeys.last();
-    if (key == null) {
-      key = this.lastMinWaitKey();
-    }
-
-    if (key == null) {
-      return null;
-    }
-
-    const queueItem = this.indexedItems.get(key);
-    if (queueItem == null) {
-      // should not happen
-      return null;
-    }
-
-    const list = queueItem.listItems;
-    const result: T[] = [];
-    while (list.length > 0 && result.length < this.opts.maxChunkSize) {
-      const t = list.pop();
-      if (t != null) {
-        result.push(t);
-      }
-    }
-
-    if (list.length === 0) {
-      this.indexedItems.delete(key);
-    }
-    if (list.length < this.opts.minChunkSize) {
-      // it's faster to search for deleted item from the tail in this case
-      this.minChunkSizeKeys.delete(key, false);
-    }
-    this._length = Math.max(0, this._length - result.length);
-
-    return result;
-  }
-
-  getAll(): T[] {
-    const result: T[] = [];
-    for (const key of this.indexedItems.keys()) {
-      const array = this.indexedItems.get(key)?.listItems.toArray();
-      if (array) {
-        result.push(...array);
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * `indexedItems` is already sorted by key, so we can just iterate through it
-   * Search for the last key with >= MINIMUM_WAIT_TIME_MS old
-   * Do not search again if we already searched recently
-   */
-  private lastMinWaitKey(): string | null {
-    const now = Date.now();
-    // searched recently, skip
-    if (this.nextWaitTimeMs != null && now - this.lastWaitTimeCheckedMs < this.nextWaitTimeMs) {
-      return null;
-    }
-
-    this.lastWaitTimeCheckedMs = now;
-    this.nextWaitTimeMs = null;
-    let resultedKey: string | null = null;
-    for (const [key, queueItem] of this.indexedItems.entries()) {
-      if (now - queueItem.firstSeenMs >= MINIMUM_WAIT_TIME_MS) {
-        // found, do not return to find the last key with >= MINIMUM_WAIT_TIME_MS old
-        this.nextWaitTimeMs = null;
-        resultedKey = key;
-      } else {
-        // if a key is not at least MINIMUM_WAIT_TIME_MS old, all remaining keys are not either
-        break;
-      }
-    }
-
-    if (resultedKey == null) {
-      // all items are not old enough, set nextWaitTimeMs to avoid searching again
-      const firstValue = this.indexedItems.values().next().value as QueueItem<T> | undefined;
-      if (firstValue != null) {
-        this.nextWaitTimeMs = Math.max(0, MINIMUM_WAIT_TIME_MS - (now - firstValue.firstSeenMs));
-      }
-    }
-
-    return resultedKey;
-  }
-}

package/src/network/processor/gossipQueues/linear.ts

@@ -1,162 +0,0 @@
-import {LinkedList} from "../../../util/array.js";
-import {DropType, GossipQueue, LinearGossipQueueOpts, QueueType} from "./types.js";
-
-// Having a drop ratio of 1 will empty the queue which is too severe
-// Worse case drop 95% of the queue
-const MAX_DROP_RATIO = 0.95;
-
-/**
- * Default gossip queue for all topics except for beacon_attestation
- * Support LIFO and FIFO type.
- */
-export class LinearGossipQueue<T> implements GossipQueue<T> {
-  private readonly list = new LinkedList<T>();
-  // Increase _dropRatio gradually, retest its initial value if node is in good status
-  private _dropRatio = 0;
-  // this is to avoid the case we drop 90% of the queue, then queue is empty and we consider
-  // node is in good status
-  private recentDrop = false;
-  // set recentDrop to false after we process up to maxLength items
-  private processedCountSinceDrop = 0;
-
-  constructor(private readonly opts: LinearGossipQueueOpts) {
-    if (opts.dropOpts.type === DropType.ratio) {
-      const {start, step} = opts.dropOpts;
-      if (start <= 0 || start > 1) {
-        throw Error(`Invalid drop ratio start ${start} step ${step}`);
-      }
-      this._dropRatio = opts.dropOpts.start;
-    }
-  }
-
-  get length(): number {
-    return this.list.length;
-  }
-
-  get keySize(): number {
-    // this implementation doesn't support indexing
-    return 1;
-  }
-
-  // not implemented for this gossip queue
-  getDataAgeMs(): number[] {
-    return [];
-  }
-
-  get dropRatio(): number {
-    return this._dropRatio;
-  }
-
-  clear(): void {
-    this.list.clear();
-  }
-
-  /**
-   * Add item to gossip queue.
-   * Return number of items dropped
-   */
-  add(item: T): number {
-    // this signals the node is not overloaded anymore
-    if (this.opts.dropOpts.type === DropType.ratio && !this.recentDrop && this.length === 0) {
-      // reset drop ratio to see if node is comfortable with it
-      this._dropRatio = this.opts.dropOpts.start;
-    }
-
-    this.list.push(item);
-
-    if (this.list.length <= this.opts.maxLength) {
-      return 0;
-    }
-
-    // overload, need to drop more items
-    if (this.opts.dropOpts.type === DropType.count) {
-      return this.dropByCount(this.opts.dropOpts.count);
-    }
-
-    this.recentDrop = true;
-    const droppedCount = this.dropByRatio(this._dropRatio);
-    // increase drop ratio the next time queue is full
-    this._dropRatio = Math.min(MAX_DROP_RATIO, this._dropRatio + this.opts.dropOpts.step);
-    return droppedCount;
-  }
-
-  next(): T | null {
-    let item: T | null = null;
-    // LIFO -> pop() remove last item, FIFO -> shift() remove first item
-    switch (this.opts.type) {
-      case QueueType.LIFO:
-        item = this.list.pop();
-        break;
-      case QueueType.FIFO:
-        item = this.list.shift();
-        break;
-    }
-
-    // it's ok to mark recent drop as false if we dropped <50% of the queue the last time
-    if (this.opts.dropOpts.type === DropType.ratio && this.recentDrop && item !== null) {
-      this.processedCountSinceDrop++;
-      if (this.processedCountSinceDrop >= this.opts.maxLength) {
-        this.recentDrop = false;
-        this.processedCountSinceDrop = 0;
-      }
-    }
-
-    return item;
-  }
-
-  getAll(): T[] {
-    return this.list.toArray();
-  }
-
-  /**
-   * Drop up to some ratio of items from the queue
-   * ratio is from 0 to 1 inclusive
-   * Return number of items dropped
-   */
-  private dropByRatio(ratio: number): number {
-    if (ratio < 0 || ratio > 1) {
-      throw Error(`Invalid ratio ${ratio}`);
-    }
-
-    if (ratio === 0) {
-      return 0;
-    }
-
-    if (ratio === 1) {
-      const numDeleted = this.length;
-      this.clear();
-      return numDeleted;
-    }
-
-    const count = Math.floor(this.list.length * ratio);
-    return this.dropByCount(count);
-  }
-
-  /**
-   * Drop up to some number of items from the queue
-   * Return number of items dropped
-   */
-  private dropByCount(count: number): number {
-    if (count <= 0) {
-      return 0;
-    }
-
-    if (count >= this.length) {
-      const numDeleted = this.length;
-      this.clear();
-      return numDeleted;
-    }
-
-    let i = 0;
-    while (i < count && this.length > 0) {
-      if (this.opts.type === QueueType.LIFO) {
-        this.list.shift();
-      } else {
-        this.list.pop();
-      }
-      i++;
-    }
-
-    return i;
-  }
-}

package/src/network/processor/gossipQueues/types.ts

@@ -1,57 +0,0 @@
-export type GossipQueueOpts<T> = LinearGossipQueueOpts | IndexedGossipQueueMinSizeOpts<T>;
-
-export type LinearGossipQueueOpts = {
-  type: QueueType;
-  maxLength: number;
-  dropOpts: DropOpts;
-};
-
-export type IndexedGossipQueueOpts<T> = {
-  maxLength: number;
-  indexFn: (item: T) => string | null;
-};
-
-export type IndexedGossipQueueMinSizeOpts<T> = IndexedGossipQueueOpts<T> & {
-  minChunkSize: number;
-  maxChunkSize: number;
-};
-
-export function isIndexedGossipQueueMinSizeOpts<T>(opts: GossipQueueOpts<T>): opts is IndexedGossipQueueMinSizeOpts<T> {
-  const minSizeOpts = opts as IndexedGossipQueueMinSizeOpts<T>;
-  return (
-    minSizeOpts.indexFn !== undefined &&
-    minSizeOpts.minChunkSize !== undefined &&
-    minSizeOpts.maxChunkSize !== undefined
-  );
-}
-
-export interface GossipQueue<T> {
-  length: number;
-  keySize: number;
-  getDataAgeMs(): number[];
-  clear: () => void;
-  next: () => T | T[] | null;
-  add: (item: T) => number;
-  getAll(): T[];
-}
-
-export enum QueueType {
-  FIFO = "FIFO",
-  LIFO = "LIFO",
-}
-
-export enum DropType {
-  count = "count",
-  ratio = "ratio",
-}
-
-export type DropOpts =
-  | {
-      type: DropType.count;
-      count: number;
-    }
-  | {
-      type: DropType.ratio;
-      start: number;
-      step: number;
-    };

package/src/network/processor/gossipValidatorFn.ts

@@ -1,142 +0,0 @@
-import {TopicValidatorResult} from "@libp2p/interface";
-import {ChainForkConfig} from "@lodestar/config";
-import {Logger} from "@lodestar/utils";
-import {AttestationError, GossipAction, GossipActionError} from "../../chain/errors/index.js";
-import {Metrics} from "../../metrics/index.js";
-import {
-  BatchGossipHandlerFn,
-  GossipHandlerFn,
-  GossipHandlers,
-  GossipMessageInfo,
-  GossipValidatorBatchFn,
-  GossipValidatorFn,
-} from "../gossip/interface.js";
-
-export type ValidatorFnModules = {
-  config: ChainForkConfig;
-  logger: Logger;
-  metrics: Metrics | null;
-};
-
-/**
- * Similar to getGossipValidatorFn but return a function to accept a batch of beacon_attestation messages
- * with the same attestation data
- */
-export function getGossipValidatorBatchFn(
-  gossipHandlers: GossipHandlers,
-  modules: ValidatorFnModules
-): GossipValidatorBatchFn {
-  const {logger, metrics} = modules;
-
-  return async function gossipValidatorBatchFn(messageInfos: GossipMessageInfo[]) {
-    // all messageInfos have same topic type
-    const type = messageInfos[0].topic.type;
-    try {
-      const results = await (gossipHandlers[type] as BatchGossipHandlerFn)(
-        messageInfos.map((messageInfo) => ({
-          gossipData: {
-            serializedData: messageInfo.msg.data,
-            msgSlot: messageInfo.msgSlot,
-            indexed: messageInfo.indexed,
-          },
-          topic: messageInfo.topic,
-          peerIdStr: messageInfo.propagationSource,
-          seenTimestampSec: messageInfo.seenTimestampSec,
-        }))
-      );
-
-      return results.map((e) => {
-        if (e == null) {
-          return TopicValidatorResult.Accept;
-        }
-
-        if (!(e instanceof AttestationError)) {
-          logger.debug(`Gossip batch validation ${type} threw a non-AttestationError`, {}, e as Error);
-          metrics?.networkProcessor.gossipValidationIgnore.inc({topic: type});
-          return TopicValidatorResult.Ignore;
-        }
-
-        switch (e.action) {
-          case GossipAction.IGNORE:
-            metrics?.networkProcessor.gossipValidationIgnore.inc({topic: type});
-            // only beacon_attestation topic is validated in batch
-            metrics?.networkProcessor.gossipAttestationIgnoreByReason.inc({reason: e.type.code});
-            return TopicValidatorResult.Ignore;
-          case GossipAction.REJECT:
-            metrics?.networkProcessor.gossipValidationReject.inc({topic: type});
-            // only beacon_attestation topic is validated in batch
-            metrics?.networkProcessor.gossipAttestationRejectByReason.inc({reason: e.type.code});
-            logger.debug(`Gossip validation ${type} rejected`, {}, e);
-            return TopicValidatorResult.Reject;
-        }
-      });
-    } catch (e) {
-      // Don't expect error here
-      logger.debug(`Gossip batch validation ${type} threw an error`, {}, e as Error);
-      const results: TopicValidatorResult[] = [];
-      for (let i = 0; i < messageInfos.length; i++) {
-        results.push(TopicValidatorResult.Ignore);
-      }
-      return results;
-    }
-  };
-}
-
-/**
- * Returns a GossipSub validator function from a GossipHandlerFn. GossipHandlerFn may throw GossipActionError if one
- * or more validation conditions from the consensus-specs#p2p-interface are not satisfied.
- *
- * This function receives a string topic and a binary message `InMessage` and deserializes both using caches.
- * - The topic string should be known in advance and pre-computed
- * - The message.data should already by uncompressed when computing its msgID
- *
- * All logging and metrics associated with gossip object validation should happen in this function. We want to know
- * - In debug logs what objects are we processing, the result and some succint metadata
- * - In metrics what's the throughput and ratio of accept/ignore/reject per type
- *
- * @see getGossipHandlers for reasoning on why GossipHandlerFn are used for gossip validation.
- */
-export function getGossipValidatorFn(gossipHandlers: GossipHandlers, modules: ValidatorFnModules): GossipValidatorFn {
-  const {logger, metrics} = modules;
-
-  return async function gossipValidatorFn({topic, msg, propagationSource, seenTimestampSec, msgSlot}) {
-    const type = topic.type;
-
-    try {
-      await (gossipHandlers[type] as GossipHandlerFn)({
-        gossipData: {serializedData: msg.data, msgSlot},
-        topic,
-        peerIdStr: propagationSource,
-        seenTimestampSec,
-      });
-
-      metrics?.networkProcessor.gossipValidationAccept.inc({topic: type});
-
-      return TopicValidatorResult.Accept;
-    } catch (e) {
-      if (!(e instanceof GossipActionError)) {
-        // not deserve to log error here, it looks too dangerous to users
-        logger.debug(`Gossip validation ${type} threw a non-GossipActionError`, {}, e as Error);
-        return TopicValidatorResult.Ignore;
-      }
-
-      // Metrics on specific error reason
-      // Note: LodestarError.code are bounded pre-declared error messages, not from arbitrary error.message
-      metrics?.networkProcessor.gossipValidationError.inc({
-        topic: type,
-        error: (e as GossipActionError<{code: string}>).type.code,
-      });
-
-      switch (e.action) {
-        case GossipAction.IGNORE:
-          metrics?.networkProcessor.gossipValidationIgnore.inc({topic: type});
-          return TopicValidatorResult.Ignore;
-
-        case GossipAction.REJECT:
-          metrics?.networkProcessor.gossipValidationReject.inc({topic: type});
-          logger.debug(`Gossip validation ${type} rejected`, {}, e);
-          return TopicValidatorResult.Reject;
-      }
-    }
-  };
-}