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

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

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

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

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

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

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