@aztec/p2p 0.75.0 → 0.76.1

package/src/config.ts

@@ -1,3 +1,4 @@
+import { type ChainConfig, chainConfigMappings } from '@aztec/circuit-types/config';
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
@@ -13,7 +14,7 @@ import { type P2PReqRespConfig, p2pReqRespConfigMappings } from './services/reqr
 /**
  * P2P client configuration values.
  */
-export interface P2PConfig extends P2PReqRespConfig {
+export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
   /**
    * A flag dictating whether the P2P subsystem should be enabled.
    */
@@ -29,6 +30,16 @@ export interface P2PConfig extends P2PReqRespConfig {
    */
   blockRequestBatchSize: number;
 
+  /**
+   * DEBUG: Disable message validation - for testing purposes only
+   */
+  debugDisableMessageValidation: boolean;
+
+  /**
+   * DEBUG: Disable colocation penalty - for testing purposes only
+   */
+  debugDisableColocationPenalty: boolean;
+
   /**
    * The frequency in which to check for new peers.
    */
@@ -69,16 +80,14 @@ export interface P2PConfig extends P2PReqRespConfig {
    */
   bootstrapNodes: string[];
 
+  /** Whether to execute the version check in the bootstrap node ENR. */
+  bootstrapNodeEnrVersionCheck: boolean;
+
   /**
    * Protocol identifier for transaction gossiping.
    */
   transactionProtocol: string;
 
-  /**
-   * The minimum number of peers (a peer count below this will cause the node to look for more peers)
-   */
-  minPeerCount: number;
-
   /**
    * The maximum number of peers (a peer count above this will cause the node to refuse connection attempts)
    */
@@ -115,6 +124,16 @@ export interface P2PConfig extends P2PReqRespConfig {
    */
   gossipsubDhi: number;
 
+  /**
+   * The Dlazy parameter for the gossipsub protocol.
+   */
+  gossipsubDLazy: number;
+
+  /**
+   * Whether to flood publish messages. - For testing purposes only
+   */
+  gossipsubFloodPublish: boolean;
+
   /**
    * The number of gossipsub interval message cache windows to keep.
    */
@@ -150,11 +169,6 @@ export interface P2PConfig extends P2PReqRespConfig {
    */
   peerPenaltyValues: number[];
 
-  /**
-   * The chain id of the L1 chain.
-   */
-  l1ChainId: number;
-
   /** Limit of transactions to archive in the tx pool. Once the archived tx limit is reached, the oldest archived txs will be purged. */
   archivedTxLimit: number;
 }
@@ -170,6 +184,16 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     description: 'The frequency in which to check for new L2 blocks.',
     ...numberConfigHelper(100),
   },
+  debugDisableMessageValidation: {
+    env: 'DEBUG_P2P_DISABLE_MESSAGE_VALIDATION',
+    description: 'DEBUG: Disable message validation - NEVER set to true in production',
+    ...booleanConfigHelper(false),
+  },
+  debugDisableColocationPenalty: {
+    env: 'DEBUG_P2P_DISABLE_COLOCATION_PENALTY',
+    description: 'DEBUG: Disable colocation penalty - NEVER set to true in production',
+    ...booleanConfigHelper(false),
+  },
   peerCheckIntervalMS: {
     env: 'P2P_PEER_CHECK_INTERVAL_MS',
     description: 'The frequency in which to check for new peers.',
@@ -209,16 +233,16 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     parseEnv: (val: string) => val.split(','),
     description: 'A list of bootstrap peer ENRs to connect to. Separated by commas.',
   },
+  bootstrapNodeEnrVersionCheck: {
+    env: 'P2P_BOOTSTRAP_NODE_ENR_VERSION_CHECK',
+    description: 'Whether to check the version of the bootstrap node ENR.',
+    ...booleanConfigHelper(),
+  },
   transactionProtocol: {
     env: 'P2P_TX_PROTOCOL',
     description: 'Protocol identifier for transaction gossiping.',
     defaultValue: '/aztec/0.1.0',
   },
-  minPeerCount: {
-    env: 'P2P_MIN_PEERS',
-    description: 'The minimum number of peers to connect to.',
-    ...numberConfigHelper(10),
-  },
   maxPeerCount: {
     env: 'P2P_MAX_PEERS',
     description: 'The maximum number of peers to connect to.',
@@ -244,7 +268,7 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   gossipsubInterval: {
     env: 'P2P_GOSSIPSUB_INTERVAL_MS',
     description: 'The interval of the gossipsub heartbeat to perform maintenance tasks.',
-    ...numberConfigHelper(1_000),
+    ...numberConfigHelper(700),
   },
   gossipsubD: {
     env: 'P2P_GOSSIPSUB_D',
@@ -261,10 +285,20 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     description: 'The Dhi parameter for the gossipsub protocol.',
     ...numberConfigHelper(12),
   },
+  gossipsubDLazy: {
+    env: 'P2P_GOSSIPSUB_DLAZY',
+    description: 'The Dlazy parameter for the gossipsub protocol.',
+    ...numberConfigHelper(6),
+  },
+  gossipsubFloodPublish: {
+    env: 'P2P_GOSSIPSUB_FLOOD_PUBLISH',
+    description: 'Whether to flood publish messages. - For testing purposes only',
+    ...booleanConfigHelper(true),
+  },
   gossipsubMcacheLength: {
     env: 'P2P_GOSSIPSUB_MCACHE_LENGTH',
     description: 'The number of gossipsub interval message cache windows to keep.',
-    ...numberConfigHelper(5),
+    ...numberConfigHelper(6),
   },
   gossipsubMcacheGossip: {
     env: 'P2P_GOSSIPSUB_MCACHE_GOSSIP',
@@ -298,11 +332,6 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     description: 'The "age" (in L2 blocks) of a tx after which we heavily penalize a peer for sending it.',
     ...numberConfigHelper(30),
   },
-  l1ChainId: {
-    env: 'L1_CHAIN_ID',
-    description: 'The chain id of the L1 chain.',
-    ...numberConfigHelper(31337),
-  },
   blockRequestBatchSize: {
     env: 'P2P_BLOCK_REQUEST_BATCH_SIZE',
     description: 'The number of blocks to fetch in a single batch.',
@@ -315,6 +344,7 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     ...numberConfigHelper(0),
   },
   ...p2pReqRespConfigMappings,
+  ...chainConfigMappings,
 };
 
 /**
@@ -332,17 +362,14 @@ export function getP2PDefaultConfig(): P2PConfig {
 /**
  * Required P2P config values for a bootstrap node.
  */
-export type BootnodeConfig = Pick<
-  P2PConfig,
-  'udpAnnounceAddress' | 'peerIdPrivateKey' | 'minPeerCount' | 'maxPeerCount'
-> &
+export type BootnodeConfig = Pick<P2PConfig, 'udpAnnounceAddress' | 'peerIdPrivateKey' | 'maxPeerCount'> &
   Required<Pick<P2PConfig, 'udpListenAddress'>> &
-  Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKB'>;
+  Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKB'> &
+  ChainConfig;
 
 const bootnodeConfigKeys: (keyof BootnodeConfig)[] = [
   'udpAnnounceAddress',
   'peerIdPrivateKey',
-  'minPeerCount',
   'maxPeerCount',
   'udpListenAddress',
   'dataDirectory',

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -1,10 +1,10 @@
 import { type BlockAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/circuit-types';
-import { type EpochCache } from '@aztec/epoch-cache';
+import { type EpochCacheInterface } from '@aztec/epoch-cache';
 
 export class AttestationValidator implements P2PValidator<BlockAttestation> {
-  private epochCache: EpochCache;
+  private epochCache: EpochCacheInterface;
 
-  constructor(epochCache: EpochCache) {
+  constructor(epochCache: EpochCacheInterface) {
     this.epochCache = epochCache;
   }
 

package/src/msg_validators/block_proposal_validator/block_proposal_validator.ts

@@ -1,10 +1,10 @@
 import { type BlockProposal, type P2PValidator, PeerErrorSeverity } from '@aztec/circuit-types';
-import { type EpochCache } from '@aztec/epoch-cache';
+import { type EpochCacheInterface } from '@aztec/epoch-cache';
 
 export class BlockProposalValidator implements P2PValidator<BlockProposal> {
-  private epochCache: EpochCache;
+  private epochCache: EpochCacheInterface;
 
-  constructor(epochCache: EpochCache) {
+  constructor(epochCache: EpochCacheInterface) {
     this.epochCache = epochCache;
   }
 

package/src/msg_validators/epoch_proof_quote_validator/epoch_proof_quote_validator.ts

@@ -1,10 +1,10 @@
 import { type EpochProofQuote, type P2PValidator, PeerErrorSeverity } from '@aztec/circuit-types';
-import { type EpochCache } from '@aztec/epoch-cache';
+import { type EpochCacheInterface } from '@aztec/epoch-cache';
 
 export class EpochProofQuoteValidator implements P2PValidator<EpochProofQuote> {
-  private epochCache: EpochCache;
+  private epochCache: EpochCacheInterface;
 
-  constructor(epochCache: EpochCache) {
+  constructor(epochCache: EpochCacheInterface) {
     this.epochCache = epochCache;
   }
 

package/src/services/discv5/discV5_service.ts

@@ -1,3 +1,4 @@
+import { type ComponentsVersions, checkCompressedComponentVersion } from '@aztec/circuit-types';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { OtelMetricsAdapter, type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
@@ -10,8 +11,9 @@ import EventEmitter from 'events';
 
 import type { P2PConfig } from '../../config.js';
 import { convertToMultiaddr } from '../../util.js';
+import { setAztecEnrKey } from '../../versioning.js';
 import { type PeerDiscoveryService, PeerDiscoveryState } from '../service.js';
-import { AZTEC_ENR_KEY, AZTEC_NET, Discv5Event, PeerEvent } from '../types.js';
+import { AZTEC_ENR_KEY, Discv5Event, PeerEvent } from '../types.js';
 
 const delayBeforeStart = 2000; // 2sec
 
@@ -25,29 +27,32 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
   /** This instance's ENR */
   private enr: SignableENR;
 
+  /** Version identifiers. */
+  private versions: ComponentsVersions;
+
   /** UDP listen addr */
   private listenMultiAddrUdp: Multiaddr;
 
   private currentState = PeerDiscoveryState.STOPPED;
 
-  private bootstrapNodes: string[];
+  public readonly bootstrapNodes: string[] = [];
   private bootstrapNodePeerIds: PeerId[] = [];
 
   private startTime = 0;
 
   constructor(
     private peerId: PeerId,
-    config: P2PConfig,
+    private config: P2PConfig,
     telemetry: TelemetryClient = getTelemetryClient(),
     private logger = createLogger('p2p:discv5_service'),
   ) {
     super();
     const { tcpAnnounceAddress, udpAnnounceAddress, udpListenAddress, bootstrapNodes } = config;
-    this.bootstrapNodes = bootstrapNodes;
+    this.bootstrapNodes = bootstrapNodes ?? [];
     // create ENR from PeerId
     this.enr = SignableENR.createFromPeerId(peerId);
     // Add aztec identification to ENR
-    this.enr.set(AZTEC_ENR_KEY, Uint8Array.from([AZTEC_NET]));
+    this.versions = setAztecEnrKey(this.enr, config);
 
     if (!tcpAnnounceAddress) {
       throw new Error('You need to provide at least a TCP announce address.');
@@ -78,6 +83,20 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       metricsRegistry,
     });
 
+    // Hook onto the onEstablished method to check the peer's version from the ENR,
+    // so we don't add it to our dht if it doesn't have the correct version.
+    // In addition, we'll hook onto onDiscovered to to repeat the same check there,
+    // just in case. Note that not adding the peer to the dht could lead to it
+    // being "readded" constantly, we'll need to keep an eye on whether this
+    // turns out to be a problem or not.
+    const origOnEstablished = this.discv5.onEstablished.bind(this.discv5);
+    this.discv5.onEstablished = (...args: unknown[]) => {
+      const enr = args[1] as ENR;
+      if (this.validateEnr(enr)) {
+        return origOnEstablished(...args);
+      }
+    };
+
     this.discv5.on(Discv5Event.DISCOVERED, this.onDiscovered.bind(this));
     this.discv5.on(Discv5Event.ENR_ADDED, this.onEnrAdded.bind(this));
   }
@@ -95,20 +114,29 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       peerId: this.peerId,
       enrUdp: await this.enr.getFullMultiaddr('udp'),
       enrTcp: await this.enr.getFullMultiaddr('tcp'),
+      versions: this.versions,
     });
     this.currentState = PeerDiscoveryState.RUNNING;
 
     // Add bootnode ENR if provided
     if (this.bootstrapNodes?.length) {
       // Do this conversion once since it involves an async function call
-      this.bootstrapNodePeerIds = await Promise.all(this.bootstrapNodes.map(enr => ENR.decodeTxt(enr).peerId()));
-      this.logger.info(`Adding bootstrap nodes ENRs: ${this.bootstrapNodes.join(', ')}`);
-      try {
-        this.bootstrapNodes.forEach(enr => {
+      const bootstrapNodesEnrs = this.bootstrapNodes.map(enr => ENR.decodeTxt(enr));
+      this.bootstrapNodePeerIds = await Promise.all(bootstrapNodesEnrs.map(enr => enr.peerId()));
+      this.logger.info(`Adding ${this.bootstrapNodes} bootstrap nodes ENRs: ${this.bootstrapNodes.join(', ')}`);
+      for (const enr of bootstrapNodesEnrs) {
+        try {
+          if (this.config.bootstrapNodeEnrVersionCheck) {
+            const value = enr.kvs.get(AZTEC_ENR_KEY);
+            if (!value) {
+              throw new Error('ENR does not contain aztec key');
+            }
+            checkCompressedComponentVersion(Buffer.from(value).toString(), this.versions);
+          }
           this.discv5.addEnr(enr);
-        });
-      } catch (e) {
-        this.logger.error(`Error adding bootnode ENRs: ${e}`);
+        } catch (e) {
+          this.logger.error(`Error adding bootratrap node ${enr.encodeTxt()}`, e);
+        }
       }
     }
   }
@@ -169,14 +197,35 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
   }
 
   private onDiscovered(enr: ENR) {
-    // check the peer is an aztec peer
+    if (this.validateEnr(enr)) {
+      this.emit(PeerEvent.DISCOVERED, enr);
+    }
+  }
+
+  private validateEnr(enr: ENR): boolean {
+    // Check the peer is an aztec peer
     const value = enr.kvs.get(AZTEC_ENR_KEY);
-    if (value) {
-      const network = value[0];
-      // check if the peer is on the same network
-      if (network === AZTEC_NET) {
-        this.emit(PeerEvent.DISCOVERED, enr);
+    if (!value) {
+      this.logger.warn(`Peer ${enr.nodeId} does not have aztec key in ENR`);
+      return false;
+    }
+
+    let compressedVersion;
+    try {
+      // And check it has the correct version
+      compressedVersion = Buffer.from(value).toString();
+      checkCompressedComponentVersion(compressedVersion, this.versions);
+      return true;
+    } catch (err: any) {
+      if (err.name === 'ComponentsVersionsError') {
+        this.logger.warn(`Peer ${enr.nodeId} has incorrect version: ${err.message}`, {
+          compressedVersion,
+          expected: this.versions,
+        });
+      } else {
+        this.logger.error(`Error checking peer version`, err);
       }
     }
+    return false;
   }
 }

package/src/services/dummy_service.ts

@@ -88,6 +88,8 @@ export class DummyP2PService implements P2PService {
  */
 export class DummyPeerDiscoveryService extends EventEmitter implements PeerDiscoveryService {
   private currentState = PeerDiscoveryState.STOPPED;
+  public bootstrapNodes: string[] = [];
+
   /**
    * Starts the dummy implementation.
    * @returns A resolved promise.

package/src/services/libp2p/libp2p_logger.ts

@@ -0,0 +1,78 @@
+import { createLogger } from '@aztec/foundation/log';
+
+import { type ComponentLogger, type Logger } from '@libp2p/interface';
+
+/**
+ * Creates a libp2p compatible logger that wraps our pino logger.
+ * This adapter implements the ComponentLogger interface required by libp2p.
+ */
+export function createLibp2pComponentLogger(namespace: string, fixedTerms = {}): ComponentLogger {
+  return {
+    forComponent: (component: string) => createLibp2pLogger(`${namespace}:${component}`, fixedTerms),
+  };
+}
+
+function createLibp2pLogger(component: string, fixedTerms = {}): Logger {
+  const logger = createLogger(component, fixedTerms);
+
+  // Default log level is trace as this is super super noisy
+  const logFn = (formatter: any, ...args: any[]) => {
+    // Handle %p format specifier by manually replacing with args
+    if (typeof formatter === 'string' && args.length > 0) {
+      // Handle %p, %a, %s and %d format specifiers
+      const parts = formatter.split(/(%p|%a|%s|%d)/);
+      let result = parts[0];
+      let argIndex = 0;
+
+      for (let i = 1; i < parts.length; i += 2) {
+        if (argIndex < args.length) {
+          result += String(args[argIndex]) + (parts[i + 1] || '');
+          argIndex++;
+        }
+      }
+
+      formatter = result;
+      // Only keep non-format args as data
+      args = args.slice(argIndex);
+    }
+
+    // Handle object args by spreading them, but only if they weren't used in formatting
+    if (args.length === 1 && typeof args[0] === 'object') {
+      logger.trace(formatter, args[0]);
+    } else if (args.length > 0) {
+      // If we have remaining args after formatting, pass them as data
+      logger.trace(formatter, { _args: args });
+    } else {
+      logger.trace(formatter);
+    }
+  };
+
+  return Object.assign(logFn, {
+    enabled: logger.isLevelEnabled('debug'),
+
+    error(...args: any[]) {
+      const [msg, ...rest] = args;
+      logger.error(msg as string, ...rest);
+    },
+
+    debug(...args: any[]) {
+      const [msg, ...rest] = args;
+      logger.debug(msg as string, ...rest);
+    },
+
+    info(...args: any[]) {
+      const [msg, ...rest] = args;
+      logger.info(msg as string, ...rest);
+    },
+
+    warn(...args: any[]) {
+      const [msg, ...rest] = args;
+      logger.warn(msg as string, ...rest);
+    },
+
+    trace(...args: any[]) {
+      const [msg, ...rest] = args;
+      logger.trace(msg as string, ...rest);
+    },
+  });
+}

package/src/services/libp2p/libp2p_service.ts

@@ -19,7 +19,7 @@ import {
   metricsTopicStrToLabels,
 } from '@aztec/circuit-types';
 import { Fr } from '@aztec/circuits.js';
-import { type EpochCache } from '@aztec/epoch-cache';
+import { type EpochCacheInterface } from '@aztec/epoch-cache';
 import { createLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { RunningPromise } from '@aztec/foundation/running-promise';
@@ -34,8 +34,10 @@ import {
   gossipsub,
 } from '@chainsafe/libp2p-gossipsub';
 import { createPeerScoreParams, createTopicScoreParams } from '@chainsafe/libp2p-gossipsub/score';
+import { SignaturePolicy } from '@chainsafe/libp2p-gossipsub/types';
 import { noise } from '@chainsafe/libp2p-noise';
 import { yamux } from '@chainsafe/libp2p-yamux';
+import { bootstrap } from '@libp2p/bootstrap';
 import { identify } from '@libp2p/identify';
 import { type Message, type PeerId, TopicValidatorResult } from '@libp2p/interface';
 import { type ConnectionManager } from '@libp2p/interface-internal';
@@ -65,6 +67,7 @@ import { pingHandler, reqRespBlockHandler, reqRespTxHandler, statusHandler } fro
 import { ReqResp } from '../reqresp/reqresp.js';
 import type { P2PService, PeerDiscoveryService } from '../service.js';
 import { GossipSubEvent } from '../types.js';
+import { createLibp2pComponentLogger } from './libp2p_logger.js';
 
 interface MessageValidator {
   validator: {
@@ -111,7 +114,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     private peerDiscoveryService: PeerDiscoveryService,
     private mempools: MemPools<T>,
     private l2BlockSource: L2BlockSource,
-    epochCache: EpochCache,
+    epochCache: EpochCacheInterface,
     private proofVerifier: ClientProtocolCircuitVerifier,
     private worldStateSynchronizer: WorldStateSynchronizer,
     telemetry: TelemetryClient,
@@ -127,7 +130,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
       peerDiscoveryService,
       config,
       telemetry,
-      logger,
+      createLogger(`${logger.module}:peer_manager`),
       peerScoring,
       this.reqresp,
     );
@@ -164,13 +167,14 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     peerId: PeerId,
     mempools: MemPools<T>,
     l2BlockSource: L2BlockSource,
-    epochCache: EpochCache,
+    epochCache: EpochCacheInterface,
     proofVerifier: ClientProtocolCircuitVerifier,
     worldStateSynchronizer: WorldStateSynchronizer,
     store: AztecAsyncKVStore,
     telemetry: TelemetryClient,
+    logger = createLogger('p2p:libp2p_service'),
   ) {
-    const { tcpListenAddress, tcpAnnounceAddress, minPeerCount, maxPeerCount } = config;
+    const { tcpListenAddress, tcpAnnounceAddress, maxPeerCount } = config;
     const bindAddrTcp = convertToMultiaddr(tcpListenAddress, 'tcp');
     // We know tcpAnnounceAddress cannot be null here because we set it or throw when setting up the service.
     const announceAddrTcp = convertToMultiaddr(tcpAnnounceAddress!, 'tcp');
@@ -179,6 +183,12 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
 
     const otelMetricsAdapter = new OtelMetricsAdapter(telemetry);
 
+    // If bootstrap nodes are provided, also provide them to the p2p service
+    const peerDiscovery = [];
+    if (peerDiscoveryService.bootstrapNodes.length > 0) {
+      peerDiscovery.push(bootstrap({ list: peerDiscoveryService.bootstrapNodes }));
+    }
+
     const node = await createLibp2p({
       start: false,
       peerId,
@@ -200,24 +210,35 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
         }),
       ],
       datastore,
-      streamMuxers: [yamux(), mplex()],
+      peerDiscovery,
+      streamMuxers: [mplex(), yamux()],
       connectionEncryption: [noise()],
       connectionManager: {
-        minConnections: minPeerCount,
+        minConnections: 0,
         maxConnections: maxPeerCount,
+
+        maxParallelDials: 100,
+        maxPeerAddrsToDial: 5,
+        maxIncomingPendingConnections: 5,
       },
       services: {
         identify: identify({
           protocolPrefix: 'aztec',
         }),
         pubsub: gossipsub({
+          debugName: 'gossipsub',
+          globalSignaturePolicy: SignaturePolicy.StrictNoSign,
           allowPublishToZeroTopicPeers: true,
+          floodPublish: config.gossipsubFloodPublish,
           D: config.gossipsubD,
           Dlo: config.gossipsubDlo,
           Dhi: config.gossipsubDhi,
+          Dlazy: config.gossipsubDLazy,
           heartbeatInterval: config.gossipsubInterval,
           mcacheLength: config.gossipsubMcacheLength,
           mcacheGossip: config.gossipsubMcacheGossip,
+          // Increased from default 3s to give time for input lag: configuration and rationale from lodestar
+          gossipsubIWantFollowupMs: 12 * 1000,
           msgIdFn: getMsgIdFn,
           msgIdToStrFn: msgIdToStrFn,
           fastMsgIdFn: fastMsgIdFn,
@@ -226,6 +247,8 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
           metricsTopicStrToLabel: metricsTopicStrToLabels(),
           asyncValidation: true,
           scoreParams: createPeerScoreParams({
+            // IPColocation factor can be disabled for local testing - default to -5
+            IPColocationFactorWeight: config.debugDisableColocationPenalty ? 0 : -5.0,
             topics: {
               [Tx.p2pTopic]: createTopicScoreParams({
                 topicWeight: 1,
@@ -254,6 +277,8 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
           connectionManager: components.connectionManager,
         }),
       },
+      // Fix the peer id in libp2p logs so we can see the source of the log
+      logger: createLibp2pComponentLogger(logger.module, { sourcePeerId: peerId }),
     });
 
     return new LibP2PService(
@@ -267,6 +292,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
       proofVerifier,
       worldStateSynchronizer,
       telemetry,
+      logger,
     );
   }
 
@@ -319,8 +345,16 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
       [BlockProposal.p2pTopic]: this.validatePropagatedBlockFromMessage.bind(this),
       [EpochProofQuote.p2pTopic]: this.validatePropagatedEpochProofQuoteFromMessage.bind(this),
     };
-    for (const [topic, validator] of Object.entries(topicValidators)) {
-      this.node.services.pubsub.topicValidators.set(topic, validator);
+    // When running bandwidth benchmarks, we use send blobs of data we do not want to validate
+    // NEVER switch this off in production
+    if (!this.config.debugDisableMessageValidation) {
+      for (const [topic, validator] of Object.entries(topicValidators)) {
+        this.node.services.pubsub.topicValidators.set(topic, validator);
+      }
+    } else {
+      this.logger.warn(
+        'MESSAGE VALIDATION DISABLED - IF YOU SEE THIS LOG AND ARE NOT DEBUGGING AND ARE RUNNING IN A PRODUCTION ENVIRONMENT, PLEASE RE-ENABLE MESSAGE VALIDATION',
+      );
     }
 
     // add GossipSub listener
@@ -904,7 +938,10 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     this.logger.trace(`Sending message ${identifier}`, { p2pMessageIdentifier: identifier });
 
     const recipientsNum = await this.publishToTopic(parent.p2pTopic, message.toBuffer());
-    this.logger.debug(`Sent message ${identifier} to ${recipientsNum} peers`, { p2pMessageIdentifier: identifier });
+    this.logger.debug(`Sent message ${identifier} to ${recipientsNum} peers`, {
+      p2pMessageIdentifier: identifier,
+      sourcePeer: this.node.peerId.toString(),
+    });
   }
 
   // Libp2p seems to hang sometimes if new peers are initiating connections.

package/src/services/reqresp/interface.ts

@@ -3,6 +3,8 @@ import { Fr } from '@aztec/foundation/fields';
 
 import { type PeerId } from '@libp2p/interface';
 
+import { type ReqRespStatus } from './status.js';
+
 /*
  * Request Response Sub Protocols
  */
@@ -31,6 +33,15 @@ export type ReqRespSubProtocolHandler = (peerId: PeerId, msg: Buffer) => Promise
  */
 export type ReqRespSubProtocolRateLimits = Record<ReqRespSubProtocol, ProtocolRateLimitQuota>;
 
+/**
+ * The response from the ReqResp protocol
+ * Consists of a status (Error code) and data
+ */
+export interface ReqRespResponse {
+  status: ReqRespStatus;
+  data: Buffer;
+}
+
 /**
  * A rate limit quota
  */

package/src/services/reqresp/protocols/goodbye.ts

@@ -95,7 +95,7 @@ export function reqGoodbyeHandler(peerManager: PeerManager): ReqRespSubProtocolH
 
     peerManager.goodbyeReceived(peerId, reason);
 
-    // Return a buffer of length 1 as an acknowledgement
+    // Return a buffer of length 1 as an acknowledgement: this is allowed to fail
     return Promise.resolve(Buffer.from([0x0]));
   };
 }