@aztec/p2p 0.0.1-commit.1bb068fb5 → 0.0.1-commit.1dcfe2301

package/src/services/tx_collection/request_tracker.ts

@@ -0,0 +1,127 @@
+import { type PromiseWithResolvers, promiseWithResolvers } from '@aztec/foundation/promise';
+import type { DateProvider } from '@aztec/foundation/timer';
+import { TxHash } from '@aztec/stdlib/tx';
+import type { Tx } from '@aztec/stdlib/tx';
+
+/**
+ * Tracks which transactions are still missing and need to be fetched.
+ * Manages the request deadline and serves as the sole source of cancellation signal.
+ * The request is cancelled when all txs are fetched or the deadline expires.
+ */
+export interface IRequestTracker {
+  /** Returns the set of transaction hashes that are still missing. */
+  get missingTxHashes(): Set<string>;
+  /** Size of this.missingTxHashes */
+  get numberOfMissingTxs(): number;
+  /** Are all requested txs fetched */
+  allFetched(): boolean;
+  /** Checks that transaction is still missing */
+  isMissing(txHash: string): boolean;
+  /** Marks a transaction as fetched. Returns true if it was previously missing. */
+  markFetched(tx: Tx): boolean;
+  /** Get list of collected txs */
+  get collectedTxs(): Tx[];
+  /** The deadline for this request. */
+  get deadline(): Date;
+  /** Remaining time in milliseconds until deadline. Returns 0 if already past. */
+  get timeoutMs(): number;
+  /** Checks whether the request is cancelled (deadline expired or all fetched). May trigger cancellation if deadline has passed. */
+  checkCancelled(): boolean;
+  /** Resolves when deadline expires or all txs are fetched. */
+  get cancellationToken(): Promise<void>;
+  /** Externally cancel the request. */
+  cancel(): void;
+}
+
+export class RequestTracker implements IRequestTracker {
+  public readonly collectedTxs: Tx[] = [];
+  private done = false;
+  private readonly cancellationTokenPromise: PromiseWithResolvers<void>;
+  private readonly deadlineTimer: ReturnType<typeof setTimeout> | undefined;
+
+  private constructor(
+    public readonly missingTxHashes: Set<string>,
+    public readonly deadline: Date,
+    private readonly dateProvider?: DateProvider,
+  ) {
+    this.cancellationTokenPromise = promiseWithResolvers<void>();
+
+    if (missingTxHashes.size === 0) {
+      this.finish();
+      return;
+    }
+
+    const now = this.dateProvider?.now() ?? Date.now();
+    const remaining = deadline.getTime() - now;
+    if (remaining <= 0) {
+      this.finish();
+    } else {
+      this.deadlineTimer = setTimeout(() => this.finish(), remaining);
+    }
+  }
+
+  public static create(hashes: TxHash[] | string[], deadline: Date, dateProvider?: DateProvider) {
+    return new RequestTracker(new Set(hashes.map(hash => hash.toString())), deadline, dateProvider);
+  }
+
+  markFetched(tx: Tx): boolean {
+    if (this.missingTxHashes.delete(tx.txHash.toString())) {
+      this.collectedTxs.push(tx);
+      if (this.allFetched()) {
+        this.finish();
+      }
+      return true;
+    }
+    return false;
+  }
+
+  get numberOfMissingTxs(): number {
+    return this.missingTxHashes.size;
+  }
+
+  allFetched(): boolean {
+    return this.numberOfMissingTxs === 0;
+  }
+
+  isMissing(txHash: string): boolean {
+    return this.missingTxHashes.has(txHash.toString());
+  }
+
+  get timeoutMs(): number {
+    const now = this.dateProvider?.now() ?? Date.now();
+    return Math.max(0, this.deadline.getTime() - now);
+  }
+
+  checkCancelled(): boolean {
+    if (this.done) {
+      return true;
+    }
+    // Synchronous fallback: check deadline even if setTimeout hasn't fired yet.
+    // This prevents macrotask starvation in tight async loops from blocking cancellation.
+    const now = this.dateProvider?.now() ?? Date.now();
+    if (now >= this.deadline.getTime()) {
+      this.finish();
+      return true;
+    }
+    return false;
+  }
+
+  get cancellationToken(): Promise<void> {
+    return this.cancellationTokenPromise.promise;
+  }
+
+  cancel(): void {
+    this.finish();
+  }
+
+  private finish() {
+    if (this.done) {
+      return;
+    }
+    this.done = true;
+    if (this.deadlineTimer) {
+      clearTimeout(this.deadlineTimer);
+    }
+    this.cancellationTokenPromise.resolve();
+  }
+}

package/src/services/tx_collection/slow_tx_collection.ts

@@ -8,8 +8,7 @@ import type { L2Block } from '@aztec/stdlib/block';
 import { type L1RollupConstants, getEpochAtSlot, getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 import { type Tx, TxHash } from '@aztec/stdlib/tx';
 
-import { type ReqRespInterface, ReqRespSubProtocol } from '../reqresp/interface.js';
-import { chunkTxHashesRequest } from '../reqresp/protocols/tx.js';
+import { type ReqRespInterface, ReqRespSubProtocol, chunkTxHashesRequest } from '../reqresp/index.js';
 import type { TxCollectionConfig } from './config.js';
 import type { FastTxCollection } from './fast_tx_collection.js';
 import type { MissingTxInfo } from './tx_collection.js';
@@ -120,8 +119,8 @@ export class SlowTxCollection {
       const txHashes = entries.map(([txHash]) => TxHash.fromString(txHash));
       for (const batch of chunk(txHashes, this.config.txCollectionNodeRpcMaxBatchSize)) {
         await this.txCollectionSink.collect(
-          hashes => node.getTxsByHash(hashes),
-          batch,
+          () => node.getTxsByHash(batch),
+          batch.map(h => h.toString()),
           {
             description: `node ${node.getInfo()}`,
             node: node.getInfo(),
@@ -166,18 +165,18 @@ export class SlowTxCollection {
       const txHashes = entries.map(([txHash]) => TxHash.fromString(txHash));
       const maxPeers = boundInclusive(Math.ceil(txHashes.length / 3), 4, 16);
       await this.txCollectionSink.collect(
-        async hashes => {
+        async () => {
           const txs = await this.reqResp.sendBatchRequest<ReqRespSubProtocol.TX>(
             ReqRespSubProtocol.TX,
-            chunkTxHashesRequest(hashes),
+            chunkTxHashesRequest(txHashes),
             pinnedPeer,
             timeoutMs,
             maxPeers,
             maxRetryAttempts,
           );
-          return txs.flat();
+          return { validTxs: txs.flat(), invalidTxHashes: [] };
         },
-        txHashes,
+        txHashes.map(h => h.toString()),
         { description: 'slow reqresp', timeoutMs, method: 'slow-req-resp' },
         { type: 'mined', block },
       );
@@ -197,7 +196,7 @@ export class SlowTxCollection {
     // from mined unproven blocks it has seen in the past.
     const fastRequests = this.fastCollection.getFastCollectionRequests();
     const fastCollectionTxs: Set<string> = new Set(
-      ...Array.from(fastRequests.values()).flatMap(r => r.missingTxHashes),
+      fastRequests.values().flatMap(r => Array.from(r.requestTracker.missingTxHashes)),
     );
 
     // Return all missing txs that are not in fastCollectionTxs and are ready for reqresp if requested

package/src/services/tx_collection/tx_collection.ts

@@ -1,13 +1,14 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { compactArray } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { type PromiseWithResolvers, RunningPromise } from '@aztec/foundation/promise';
+import { RunningPromise } from '@aztec/foundation/promise';
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider } from '@aztec/foundation/timer';
 import type { L2Block, L2BlockInfo } from '@aztec/stdlib/block';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import type { BlockProposal } from '@aztec/stdlib/p2p';
-import { Tx, TxHash } from '@aztec/stdlib/tx';
+import type { Tx } from '@aztec/stdlib/tx';
+import { TxHash } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import type { PeerId } from '@libp2p/interface';
@@ -18,6 +19,7 @@ import type { TxCollectionConfig } from './config.js';
 import { FastTxCollection } from './fast_tx_collection.js';
 import { FileStoreTxCollection } from './file_store_tx_collection.js';
 import type { FileStoreTxSource } from './file_store_tx_source.js';
+import type { IRequestTracker } from './request_tracker.js';
 import { SlowTxCollection, getProofDeadlineForSlot } from './slow_tx_collection.js';
 import { type TxAddContext, TxCollectionSink } from './tx_collection_sink.js';
 import type { TxSource } from './tx_source.js';
@@ -31,11 +33,8 @@ export type FastCollectionRequestInput =
   | { type: 'proposal'; blockProposal: BlockProposal; blockNumber: BlockNumber };
 
 export type FastCollectionRequest = FastCollectionRequestInput & {
-  missingTxHashes: Set<string>;
-  deadline: Date;
+  requestTracker: IRequestTracker;
   blockInfo: L2BlockInfo;
-  promise: PromiseWithResolvers<void>;
-  foundTxs: Map<string, Tx>;
 };
 
 /**

package/src/services/tx_collection/tx_collection_sink.ts

@@ -2,14 +2,15 @@ import type { Logger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { L2Block } from '@aztec/stdlib/block';
-import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
+import type { BlockHeader, Tx } from '@aztec/stdlib/tx';
 import type { TelemetryClient } from '@aztec/telemetry-client';
 
 import EventEmitter from 'node:events';
 
-import type { TxPoolV2, TxPoolV2Events } from '../../mem_pools/tx_pool_v2/interfaces.js';
+import type { TxPoolV2, TxPoolV2Events } from '../../mem_pools/index.js';
 import { TxCollectionInstrumentation } from './instrumentation.js';
 import type { CollectionMethod } from './tx_collection.js';
+import type { TxSourceCollectionResult } from './tx_source.js';
 
 /** Context determining how collected txs should be added to the pool. */
 export type TxAddContext = { type: 'proposal'; blockHeader: BlockHeader } | { type: 'mined'; block: L2Block };
@@ -31,52 +32,37 @@ export class TxCollectionSink extends (EventEmitter as new () => TypedEventEmitt
   }
 
   public async collect(
-    collectValidTxsFn: (txHashes: TxHash[]) => Promise<(Tx | undefined)[]>,
-    requested: TxHash[],
+    collectValidTxsFn: () => Promise<TxSourceCollectionResult>,
+    requested: string[],
     info: Record<string, any> & { description: string; method: CollectionMethod },
     context: TxAddContext,
   ) {
     this.log.trace(`Requesting ${requested.length} txs via ${info.description}`, {
       ...info,
-      requestedTxs: requested.map(t => t.toString()),
+      requestedTxs: requested,
     });
 
     // Execute collection function and measure the time taken, catching any errors.
-    const [duration, txs] = await elapsed(async () => {
+    const [duration, { validTxs, invalidTxHashes }] = await elapsed(async () => {
       try {
-        const response = await collectValidTxsFn(requested);
-        return response.filter(tx => tx !== undefined);
+        return await collectValidTxsFn();
       } catch (err) {
         this.log.error(`Error collecting txs via ${info.description}`, err, {
           ...info,
-          requestedTxs: requested.map(hash => hash.toString()),
+          requestedTxs: requested,
         });
-        return [] as Tx[];
+        return { validTxs: [] as Tx[], invalidTxHashes: [] as string[] };
       }
     });
 
-    if (txs.length === 0) {
+    if (validTxs.length === 0 && invalidTxHashes.length === 0) {
       this.log.trace(`No txs found via ${info.description}`, {
         ...info,
-        requestedTxs: requested.map(t => t.toString()),
+        requestedTxs: requested,
       });
-      return { txs, requested, duration };
+      return { txs: validTxs, requested, duration };
     }
 
-    // Validate tx hashes for all collected txs from external sources
-    const validTxs: Tx[] = [];
-    const invalidTxHashes: string[] = [];
-    await Promise.all(
-      txs.map(async tx => {
-        const isValid = await tx.validateTxHash();
-        if (isValid) {
-          validTxs.push(tx);
-        } else {
-          invalidTxHashes.push(tx.getTxHash().toString());
-        }
-      }),
-    );
-
     if (invalidTxHashes.length > 0) {
       this.log.warn(`Rejecting ${invalidTxHashes.length} txs with invalid hashes from ${info.description}`, {
         ...info,
@@ -87,7 +73,7 @@ export class TxCollectionSink extends (EventEmitter as new () => TypedEventEmitt
     if (validTxs.length === 0) {
       this.log.trace(`No valid txs found via ${info.description} after validation`, {
         ...info,
-        requestedTxs: requested.map(t => t.toString()),
+        requestedTxs: requested,
         invalidTxHashes,
       });
       return { txs: [], requested, duration };
@@ -99,7 +85,7 @@ export class TxCollectionSink extends (EventEmitter as new () => TypedEventEmitt
         ...info,
         duration,
         txs: validTxs.map(t => t.getTxHash().toString()),
-        requestedTxs: requested.map(t => t.toString()),
+        requestedTxs: requested,
         rejectedCount: invalidTxHashes.length,
       },
     );

package/src/services/tx_collection/tx_source.ts

@@ -2,36 +2,56 @@ import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
 import type { ChainConfig } from '@aztec/stdlib/config';
 import { type AztecNode, createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
-import type { Tx, TxHash } from '@aztec/stdlib/tx';
+import type { Tx, TxHash, TxValidator } from '@aztec/stdlib/tx';
 import { type ComponentsVersions, getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
 import { makeTracedFetch } from '@aztec/telemetry-client';
 
+export type TxSourceCollectionResult = { validTxs: Tx[]; invalidTxHashes: string[] };
+
 export interface TxSource {
   getInfo(): string;
-  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+  getTxsByHash(txHashes: TxHash[]): Promise<TxSourceCollectionResult>;
 }
 
 export class NodeRpcTxSource implements TxSource {
   constructor(
     private readonly client: Pick<AztecNode, 'getTxsByHash'>,
+    private readonly txValidator: TxValidator,
     private readonly info: string,
   ) {}
 
-  public static fromUrl(nodeUrl: string, versions: ComponentsVersions): NodeRpcTxSource {
+  public static fromUrl(nodeUrl: string, txValidator: TxValidator, versions: ComponentsVersions): NodeRpcTxSource {
     const client = createAztecNodeClient(nodeUrl, versions, makeTracedFetch([1, 2, 3], false));
-    return new NodeRpcTxSource(client, nodeUrl);
+    return new NodeRpcTxSource(client, txValidator, nodeUrl);
   }
 
   public getInfo() {
     return this.info;
   }
 
-  public getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
-    return this.client.getTxsByHash(txHashes);
+  public async getTxsByHash(txHashes: TxHash[]): Promise<TxSourceCollectionResult> {
+    return this.verifyTxs(await this.client.getTxsByHash(txHashes));
+  }
+
+  private async verifyTxs(txs: Tx[]): Promise<TxSourceCollectionResult> {
+    // Validate tx hashes for all collected txs from external sources
+    const validTxs: Tx[] = [];
+    const invalidTxHashes: string[] = [];
+    await Promise.all(
+      txs.map(async tx => {
+        const validation = await this.txValidator.validateTx(tx);
+        if (validation.result === 'valid') {
+          validTxs.push(tx);
+        } else {
+          invalidTxHashes.push(tx.getTxHash().toString());
+        }
+      }),
+    );
+    return { validTxs: validTxs, invalidTxHashes: invalidTxHashes };
   }
 }
 
-export function createNodeRpcTxSources(urls: string[], chainConfig: ChainConfig) {
+export function createNodeRpcTxSources(urls: string[], txValidator: TxValidator, chainConfig: ChainConfig) {
   const versions = getComponentsVersionsFromConfig(chainConfig, protocolContractsHash, getVKTreeRoot());
-  return urls.map(url => NodeRpcTxSource.fromUrl(url, versions));
+  return urls.map(url => NodeRpcTxSource.fromUrl(url, txValidator, versions));
 }

package/src/services/tx_file_store/tx_file_store.ts

@@ -146,7 +146,7 @@ export class TxFileStore {
       }
 
       await retry(
-        () => this.fileStore.save(path, tx.toBuffer(), { compress: false }),
+        () => this.fileStore.save(path, tx.toBuffer(), { compress: true }),
         `Uploading tx ${txHash}`,
         makeBackoff([0.1, 0.5, 2]),
         this.log,

package/src/services/tx_provider.ts

@@ -25,7 +25,7 @@ export class TxProvider implements ITxProvider {
   constructor(
     private txCollection: TxCollection,
     private txPool: TxPoolV2,
-    private txValidator: Pick<P2PClient, 'validate'>,
+    private blockProposalTransactionValidator: Pick<P2PClient, 'validateTxsReceivedInBlockProposal'>,
     private log: Logger = createLogger('p2p:tx-collector'),
     client: TelemetryClient = getTelemetryClient(),
   ) {
@@ -227,7 +227,7 @@ export class TxProvider implements ITxProvider {
     if (txs.length === 0) {
       return;
     }
-    await this.txValidator.validate(txs);
+    await this.blockProposalTransactionValidator.validateTxsReceivedInBlockProposal(txs);
     await this.txPool.addProtectedTxs(txs, blockHeader);
   }
 }

package/src/test-helpers/make-test-p2p-clients.ts

@@ -4,10 +4,9 @@ import { SecretValue } from '@aztec/foundation/config';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
-import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { P2PClientType } from '@aztec/stdlib/p2p';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 
 import { createP2PClient } from '../client/index.js';
 import type { P2PClient } from '../client/p2p_client.js';
@@ -98,7 +97,6 @@ export async function makeTestP2PClient(
   const kvStore = await openTmpStore('test');
 
   const client = await createP2PClient(
-    P2PClientType.Full,
     config,
     l2BlockSource,
     proofVerifier,

package/src/test-helpers/mock-pubsub.ts

@@ -1,10 +1,10 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { L2BlockSource } from '@aztec/stdlib/block';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { P2PClientType } from '@aztec/stdlib/p2p';
 import type { TelemetryClient } from '@aztec/telemetry-client';
 
 import type { GossipsubEvents, GossipsubMessage } from '@chainsafe/libp2p-gossipsub';
@@ -42,11 +42,10 @@ type GossipSubService = PubSubLibp2p['services']['pubsub'];
  * Given a mock gossip sub network, returns a factory function that creates an instance LibP2PService connected to it.
  * Designed to be used in tests in P2PClientDeps.p2pServiceFactory.
  */
-export function getMockPubSubP2PServiceFactory<T extends P2PClientType>(
+export function getMockPubSubP2PServiceFactory(
   network: MockGossipSubNetwork,
-): (...args: Parameters<(typeof LibP2PService<T>)['new']>) => Promise<LibP2PService<T>> {
+): (...args: Parameters<(typeof LibP2PService)['new']>) => Promise<LibP2PService> {
   return (
-    clientType: P2PClientType,
     config: P2PConfig,
     peerId: PeerId,
     deps: {
@@ -66,8 +65,7 @@ export function getMockPubSubP2PServiceFactory<T extends P2PClientType>(
     const peerManager = new DummyPeerManager(peerId, network);
     const reqresp: ReqRespInterface = new MockReqResp(peerId, network);
     const peerDiscoveryService = new DummyPeerDiscoveryService();
-    const service = new LibP2PService<T>(
-      clientType as T,
+    const service = new LibP2PService(
       config,
       libp2p,
       peerDiscoveryService,
@@ -103,6 +101,7 @@ class MockReqResp implements ReqRespInterface {
   }
 
   updateConfig(_config: Partial<P2PReqRespConfig>): void {}
+  setShouldRejectPeer(): void {}
 
   start(
     subProtocolHandlers: Partial<ReqRespSubProtocolHandlers>,
@@ -141,6 +140,11 @@ class MockReqResp implements ReqRespInterface {
     const responses: InstanceType<SubProtocolMap[SubProtocol]['response']>[] = [];
     const peers = this.network.getReqRespPeers().filter(p => !p.peerId.equals(this.peerId));
     const targetPeers = pinnedPeer ? peers.filter(p => p.peerId.equals(pinnedPeer)) : peers;
+    const delayMs = this.network.getPropagationDelayMs();
+
+    if (delayMs > 0) {
+      await sleep(delayMs);
+    }
 
     for (const request of requests) {
       const requestBuffer = request.toBuffer();
@@ -177,7 +181,12 @@ class MockReqResp implements ReqRespInterface {
       return { status: ReqRespStatus.SUCCESS, data: Buffer.from([]) };
     }
     try {
+      const delayMs = this.network.getPropagationDelayMs();
+      if (delayMs > 0) {
+        await sleep(delayMs);
+      }
       const data = await handler(this.peerId, payload);
+
       return { status: ReqRespStatus.SUCCESS, data };
     } catch {
       return { status: ReqRespStatus.FAILURE };
@@ -245,10 +254,10 @@ class MockGossipSubService extends TypedEventEmitter<GossipsubEvents> implements
     score: (_peerId: PeerIdStr) => 0,
   };
 
-  publish(topic: TopicStr, data: Uint8Array, _opts?: PublishOpts): Promise<PublishResult> {
+  async publish(topic: TopicStr, data: Uint8Array, _opts?: PublishOpts): Promise<PublishResult> {
     this.logger.debug(`Publishing message on topic ${topic}`, { topic, sender: this.peerId.toString() });
-    this.network.publishToPeers(topic, data, this.peerId);
-    return Promise.resolve({ recipients: this.network.getPeers().filter(peer => !this.peerId.equals(peer)) });
+    await this.network.publishToPeers(topic, data, this.peerId);
+    return { recipients: this.network.getPeers().filter(peer => !this.peerId.equals(peer)) };
   }
 
   receive(msg: GossipsubMessage) {
@@ -270,11 +279,22 @@ class MockGossipSubService extends TypedEventEmitter<GossipsubEvents> implements
       { msgId, propagationSource, acceptance },
     );
   }
+
+  getMeshPeers(topic?: TopicStr): PeerIdStr[] {
+    if (topic && !this.subscribedTopics.has(topic)) {
+      return [];
+    }
+    return this.network
+      .getPeers()
+      .filter(peer => !this.peerId.equals(peer))
+      .map(peer => peer.toString());
+  }
 }
 
 /**
  * Mock gossip sub network used for testing.
- * All instances of MockGossipSubService connected to the same network will instantly receive the same messages.
+ * All instances of MockGossipSubService connected to the same network receive the same messages,
+ * optionally delayed by a configurable propagation time.
  */
 export class MockGossipSubNetwork {
   private peers: MockGossipSubService[] = [];
@@ -283,6 +303,15 @@ export class MockGossipSubNetwork {
 
   private logger = createLogger('p2p:test:mock-gossipsub-network');
 
+  constructor(
+    /** Artificial propagation delay in milliseconds applied to each message delivery. */
+    private propagationDelayMs: number = 0,
+  ) {}
+
+  public getPropagationDelayMs(): number {
+    return this.propagationDelayMs;
+  }
+
   public getPeers(): PeerId[] {
     return this.peers.map(peer => peer.peerId);
   }
@@ -299,7 +328,7 @@ export class MockGossipSubNetwork {
     return this.reqRespPeers;
   }
 
-  public publishToPeers(topic: TopicStr, data: Uint8Array, sender: PeerId): void {
+  public async publishToPeers(topic: TopicStr, data: Uint8Array, sender: PeerId): Promise<void> {
     const msgId = (this.nextMsgId++).toString();
     this.logger.debug(`Network is distributing message on topic ${topic}`, {
       topic,
@@ -308,6 +337,10 @@ export class MockGossipSubNetwork {
       msgId,
     });
 
+    if (this.propagationDelayMs > 0) {
+      await sleep(this.propagationDelayMs);
+    }
+
     const gossipSubMsg: GossipsubMessage = { msgId, msg: { type: 'unsigned', topic, data }, propagationSource: sender };
     for (const peer of this.peers) {
       if (peer.subscribedTopics.has(topic)) {

package/src/test-helpers/reqresp-nodes.ts

@@ -2,7 +2,6 @@ import type { EpochCache } from '@aztec/epoch-cache';
 import { timesParallel } from '@aztec/foundation/collection';
 import { SecretValue } from '@aztec/foundation/config';
 import { createLogger } from '@aztec/foundation/log';
-import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 import type { L2BlockSource } from '@aztec/stdlib/block';
 import { type ChainConfig, emptyChainConfig } from '@aztec/stdlib/config';
@@ -12,7 +11,7 @@ import type {
   IVCProofVerificationResult,
   WorldStateSynchronizer,
 } from '@aztec/stdlib/interfaces/server';
-import type { P2PClientType } from '@aztec/stdlib/p2p';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 import type { Tx } from '@aztec/stdlib/tx';
 import { compressComponentVersions } from '@aztec/stdlib/versioning';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
@@ -107,8 +106,7 @@ export async function createLibp2pNode(
  *
  *
  */
-export async function createTestLibP2PService<T extends P2PClientType>(
-  clientType: T,
+export async function createTestLibP2PService(
   boostrapAddrs: string[] = [],
   archiver: L2BlockSource & ContractDataSource,
   worldStateSynchronizer: WorldStateSynchronizer,
@@ -155,12 +153,13 @@ export async function createTestLibP2PService<T extends P2PClientType>(
     epochCache,
   );
 
+  reqresp.setShouldRejectPeer(peerId => peerManager.shouldDisableP2PGossip(peerId));
+
   p2pNode.services.pubsub.score.params.appSpecificWeight = APP_SPECIFIC_WEIGHT;
   p2pNode.services.pubsub.score.params.appSpecificScore = (peerId: string) =>
     peerManager.shouldDisableP2PGossip(peerId) ? -Infinity : peerManager.getPeerScore(peerId);
 
-  return new LibP2PService<T>(
-    clientType,
+  return new LibP2PService(
     config,
     p2pNode as PubSubLibp2p,
     discoveryService,
@@ -190,7 +189,6 @@ export const MOCK_SUB_PROTOCOL_HANDLERS: ReqRespSubProtocolHandlers = {
   [ReqRespSubProtocol.STATUS]: (_msg: any) => Promise.resolve(Buffer.from('status')),
   [ReqRespSubProtocol.TX]: (_msg: any) => Promise.resolve(Buffer.from('tx')),
   [ReqRespSubProtocol.GOODBYE]: (_msg: any) => Promise.resolve(Buffer.from('goodbye')),
-  [ReqRespSubProtocol.BLOCK]: (_msg: any) => Promise.resolve(Buffer.from('block')),
   [ReqRespSubProtocol.AUTH]: (_msg: any) => Promise.resolve(Buffer.from('auth')),
   [ReqRespSubProtocol.BLOCK_TXS]: (_msg: any) => Promise.resolve(Buffer.from('block_txs')),
 };
@@ -202,7 +200,6 @@ export const MOCK_SUB_PROTOCOL_VALIDATORS: ReqRespSubProtocolValidators = {
   [ReqRespSubProtocol.STATUS]: noopValidator,
   [ReqRespSubProtocol.TX]: noopValidator,
   [ReqRespSubProtocol.GOODBYE]: noopValidator,
-  [ReqRespSubProtocol.BLOCK]: noopValidator,
   [ReqRespSubProtocol.AUTH]: noopValidator,
   [ReqRespSubProtocol.BLOCK_TXS]: noopValidator,
 };