@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.5476d83

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

@@ -0,0 +1,24 @@
+import { Fr } from '@aztec/foundation/fields';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { mockTx } from '@aztec/stdlib/testing';
+import { Tx } from '@aztec/stdlib/tx';
+
+import type { P2PConfig } from '../config.js';
+
+/**
+ * Helper function to create mock transactions with the correct metadata values
+ * that will pass validation when sent over the p2p network.
+ *
+ * @param config - The P2P configuration containing chainId and rollupVersion
+ * @param seed - Optional seed for the mock transaction
+ * @returns A mock transaction with valid metadata for p2p network transmission
+ */
+export const createMockTxWithMetadata = (config: P2PConfig, seed?: number): Promise<Tx> => {
+  return mockTx(seed, {
+    chainId: new Fr(config.l1ChainId),
+    version: new Fr(config.rollupVersion),
+    vkTreeRoot: getVKTreeRoot(),
+    protocolContractsHash,
+  });
+};

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

@@ -1,15 +1,22 @@
 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';
-import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type {
+  ClientProtocolCircuitVerifier,
+  IVCProofVerificationResult,
+  WorldStateSynchronizer,
+} from '@aztec/stdlib/interfaces/server';
 import type { P2PClientType } from '@aztec/stdlib/p2p';
 import type { Tx } from '@aztec/stdlib/tx';
+import { compressComponentVersions } from '@aztec/stdlib/versioning';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
-import { SignableENR } from '@chainsafe/enr';
 import { gossipsub } from '@chainsafe/libp2p-gossipsub';
 import { noise } from '@chainsafe/libp2p-noise';
 import { yamux } from '@chainsafe/libp2p-yamux';
@@ -19,6 +26,7 @@ import type { PeerId } from '@libp2p/interface';
 import { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
 import { tcp } from '@libp2p/tcp';
 import { multiaddr } from '@multiformats/multiaddr';
+import { SignableENR } from '@nethermindeth/enr';
 import getPort from 'get-port';
 import { type Libp2p, type Libp2pOptions, createLibp2p } from 'libp2p';
 
@@ -27,17 +35,20 @@ import type { BootnodeConfig, P2PConfig } from '../config.js';
 import type { MemPools } from '../mem_pools/interface.js';
 import { DiscV5Service } from '../services/discv5/discV5_service.js';
 import { LibP2PService } from '../services/libp2p/libp2p_service.js';
-import type { PeerScoring } from '../services/peer-manager/peer_scoring.js';
+import { PeerManager } from '../services/peer-manager/peer_manager.js';
+import { PeerScoring } from '../services/peer-manager/peer_scoring.js';
 import type { P2PReqRespConfig } from '../services/reqresp/config.js';
 import {
   ReqRespSubProtocol,
   type ReqRespSubProtocolHandlers,
+  type ReqRespSubProtocolRateLimits,
   type ReqRespSubProtocolValidators,
   noopValidator,
 } from '../services/reqresp/interface.js';
-import { pingHandler, statusHandler } from '../services/reqresp/protocols/index.js';
+import { pingHandler } from '../services/reqresp/protocols/index.js';
 import { ReqResp } from '../services/reqresp/reqresp.js';
-import { type PubSubLibp2p, convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js';
+import { type FullLibp2p, type PubSubLibp2p, convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js';
+import { getVersions } from '../versioning.js';
 
 /**
  * Creates a libp2p node, pre configured.
@@ -50,13 +61,13 @@ export async function createLibp2pNode(
   port?: number,
   enableGossipSub: boolean = false,
   start: boolean = true,
-): Promise<Libp2p> {
+): Promise<FullLibp2p> {
   port = port ?? (await getPort());
   const options: Libp2pOptions = {
     start,
     addresses: {
-      listen: [`/ip4/0.0.0.0/tcp/${port}`],
-      announce: [`/ip4/0.0.0.0/tcp/${port}`],
+      listen: [`/ip4/127.0.0.1/tcp/${port}`],
+      announce: [`/ip4/127.0.0.1/tcp/${port}`],
     },
     connectionEncryption: [noise()],
     streamMuxers: [yamux()],
@@ -86,7 +97,7 @@ export async function createLibp2pNode(
     });
   }
 
-  return await createLibp2p(options);
+  return (await createLibp2p(options)) as FullLibp2p;
 }
 
 /**
@@ -98,7 +109,7 @@ export async function createLibp2pNode(
 export async function createTestLibP2PService<T extends P2PClientType>(
   clientType: T,
   boostrapAddrs: string[] = [],
-  l2BlockSource: L2BlockSource,
+  archiver: L2BlockSource & ContractDataSource,
   worldStateSynchronizer: WorldStateSynchronizer,
   epochCache: EpochCache,
   mempools: MemPools<T>,
@@ -109,31 +120,53 @@ export async function createTestLibP2PService<T extends P2PClientType>(
 ) {
   peerId = peerId ?? (await createSecp256k1PeerId());
   const config = {
-    tcpAnnounceAddress: `127.0.0.1:${port}`,
-    udpAnnounceAddress: `127.0.0.1:${port}`,
-    tcpListenAddress: `0.0.0.0:${port}`,
-    udpListenAddress: `0.0.0.0:${port}`,
+    p2pIp: `127.0.0.1`,
+    p2pPort: port,
     bootstrapNodes: boostrapAddrs,
     peerCheckIntervalMS: 1000,
     maxPeerCount: 5,
     p2pEnabled: true,
-    peerIdPrivateKey: Buffer.from(peerId.privateKey!).toString('hex'),
+    peerIdPrivateKey: new SecretValue(Buffer.from(peerId.privateKey!).toString('hex')),
     bootstrapNodeEnrVersionCheck: false,
     ...chainConfig,
   } as P2PConfig & DataStoreConfig;
-  const discoveryService = new DiscV5Service(peerId, config, telemetry);
+  const discoveryService = new DiscV5Service(peerId, config, 'test-reqresp-node', telemetry);
   const proofVerifier = new AlwaysTrueCircuitVerifier();
 
   // No bootstrap nodes provided as the libp2p service will register them in the constructor
   const p2pNode = await createLibp2pNode([], peerId, port, /*enable gossip */ true, /**start */ false);
 
+  // Duplicated setup code from Libp2pService.new
+  const peerScoring = new PeerScoring(config);
+  const reqresp = new ReqResp(config, p2pNode, peerScoring);
+  const versions = getVersions(config);
+  const protocolVersion = compressComponentVersions(versions);
+  const peerManager = new PeerManager(
+    p2pNode,
+    discoveryService,
+    config,
+    telemetry,
+    createLogger(`p2p:peer_manager`),
+    peerScoring,
+    reqresp,
+    worldStateSynchronizer,
+    protocolVersion,
+    epochCache,
+  );
+
+  p2pNode.services.pubsub.score.params.appSpecificWeight = 10;
+  p2pNode.services.pubsub.score.params.appSpecificScore = (peerId: string) =>
+    peerManager.shouldDisableP2PGossip(peerId) ? -Infinity : peerManager.getPeerScore(peerId);
+
   return new LibP2PService<T>(
     clientType,
     config,
     p2pNode as PubSubLibp2p,
     discoveryService,
+    reqresp,
+    peerManager,
     mempools,
-    l2BlockSource,
+    archiver,
     epochCache,
     proofVerifier,
     worldStateSynchronizer,
@@ -153,10 +186,12 @@ export type ReqRespNode = {
 // Mock sub protocol handlers
 export const MOCK_SUB_PROTOCOL_HANDLERS: ReqRespSubProtocolHandlers = {
   [ReqRespSubProtocol.PING]: pingHandler,
-  [ReqRespSubProtocol.STATUS]: statusHandler,
+  [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')),
 };
 
 // By default, all requests are valid
@@ -167,14 +202,20 @@ export const MOCK_SUB_PROTOCOL_VALIDATORS: ReqRespSubProtocolValidators = {
   [ReqRespSubProtocol.TX]: noopValidator,
   [ReqRespSubProtocol.GOODBYE]: noopValidator,
   [ReqRespSubProtocol.BLOCK]: noopValidator,
+  [ReqRespSubProtocol.AUTH]: noopValidator,
+  [ReqRespSubProtocol.BLOCK_TXS]: noopValidator,
 };
 
 /**
  * @param numberOfNodes - the number of nodes to create
  * @returns An array of the created nodes
  */
-export const createNodes = (peerScoring: PeerScoring, numberOfNodes: number): Promise<ReqRespNode[]> => {
-  return timesParallel(numberOfNodes, () => createReqResp(peerScoring));
+export const createNodes = (
+  peerScoring: PeerScoring,
+  numberOfNodes: number,
+  rateLimits: Partial<ReqRespSubProtocolRateLimits> = {},
+): Promise<ReqRespNode[]> => {
+  return timesParallel(numberOfNodes, () => createReqResp(peerScoring, rateLimits));
 };
 
 export const startNodes = async (
@@ -193,17 +234,19 @@ export const stopNodes = async (nodes: ReqRespNode[]): Promise<void> => {
 };
 
 // Create a req resp node, exposing the underlying p2p node
-export const createReqResp = async (peerScoring: PeerScoring): Promise<ReqRespNode> => {
+export const createReqResp = async (
+  peerScoring: PeerScoring,
+  rateLimits: Partial<ReqRespSubProtocolRateLimits> = {},
+): Promise<ReqRespNode> => {
   const p2p = await createLibp2pNode();
   const config: P2PReqRespConfig = {
     overallRequestTimeoutMs: 4000,
     individualRequestTimeoutMs: 2000,
+    dialTimeoutMs: 1000,
+    p2pOptimisticNegotiation: false,
   };
-  const req = new ReqResp(config, p2p, peerScoring);
-  return {
-    p2p,
-    req,
-  };
+  const req = new ReqResp(config, p2p, peerScoring, undefined, rateLimits);
+  return { p2p, req };
 };
 
 // Given a node list; hand shake all of the nodes with each other
@@ -221,13 +264,19 @@ export const connectToPeers = async (nodes: ReqRespNode[]): Promise<void> => {
 
 // Mock circuit verifier for testing - reimplementation from bb to avoid dependency
 export class AlwaysTrueCircuitVerifier implements ClientProtocolCircuitVerifier {
-  verifyProof(_tx: Tx): Promise<boolean> {
-    return Promise.resolve(true);
+  stop(): Promise<void> {
+    return Promise.resolve();
+  }
+  verifyProof(_tx: Tx): Promise<IVCProofVerificationResult> {
+    return Promise.resolve({ valid: true, durationMs: 0, totalDurationMs: 0 });
   }
 }
 export class AlwaysFalseCircuitVerifier implements ClientProtocolCircuitVerifier {
-  verifyProof(_tx: Tx): Promise<boolean> {
-    return Promise.resolve(false);
+  stop(): Promise<void> {
+    return Promise.resolve();
+  }
+  verifyProof(_tx: Tx): Promise<IVCProofVerificationResult> {
+    return Promise.resolve({ valid: false, durationMs: 0, totalDurationMs: 0 });
   }
 }
 
@@ -235,12 +284,14 @@ export class AlwaysFalseCircuitVerifier implements ClientProtocolCircuitVerifier
 export function createBootstrapNodeConfig(privateKey: string, port: number, chainConfig: ChainConfig): BootnodeConfig {
   return {
     l1ChainId: chainConfig.l1ChainId,
-    udpListenAddress: `0.0.0.0:${port}`,
-    udpAnnounceAddress: `127.0.0.1:${port}`,
-    peerIdPrivateKey: privateKey,
+    p2pIp: '127.0.0.1',
+    p2pPort: port,
+    peerIdPrivateKey: new SecretValue(privateKey),
     dataDirectory: undefined,
-    dataStoreMapSizeKB: 0,
+    dataStoreMapSizeKb: 0,
     bootstrapNodes: [],
+    listenAddress: '127.0.0.1',
+    queryForIp: false,
   };
 }
 
@@ -263,7 +314,7 @@ export function createBootstrapNodeFromPrivateKey(
 export async function getBootstrapNodeEnr(privateKey: string, port: number) {
   const peerId = await createLibP2PPeerIdFromPrivateKey(privateKey);
   const enr = SignableENR.createFromPeerId(peerId);
-  const listenAddrUdp = multiaddr(convertToMultiaddr(`127.0.0.1:${port}`, 'udp'));
+  const listenAddrUdp = multiaddr(convertToMultiaddr('127.0.0.1', port, 'udp'));
   enr.setLocationMultiaddr(listenAddrUdp);
 
   return enr;

package/src/testbench/p2p_client_testbench_worker.ts

@@ -5,28 +5,41 @@
  */
 import { MockL2BlockSource } from '@aztec/archiver/test';
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 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 { L2BlockSource } from '@aztec/stdlib/block';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { P2PClientType, P2PMessage } from '@aztec/stdlib/p2p';
 import { Tx, TxStatus } from '@aztec/stdlib/tx';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import type { Message, PeerId } from '@libp2p/interface';
+import { TopicValidatorResult } from '@libp2p/interface';
+import EventEmitter from 'events';
 
 import type { P2PConfig } from '../config.js';
 import { createP2PClient } from '../index.js';
 import type { AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
+import type { MemPools } from '../mem_pools/interface.js';
 import type { TxPool } from '../mem_pools/tx_pool/index.js';
+import { LibP2PService } from '../services/libp2p/libp2p_service.js';
+import type { PeerManager } from '../services/peer-manager/peer_manager.js';
+import type { ReqResp } from '../services/reqresp/reqresp.js';
+import type { PeerDiscoveryService } from '../services/service.js';
 import { AlwaysTrueCircuitVerifier } from '../test-helpers/reqresp-nodes.js';
+import type { PubSubLibp2p } from '../util.js';
 
 // Simple mock implementation
 function mockTxPool(): TxPool {
   // Mock all methods
-  return {
-    addTxs: () => Promise.resolve(),
+  const pool: Omit<TxPool, keyof EventEmitter> = {
+    isEmpty: () => Promise.resolve(false),
+    addTxs: () => Promise.resolve(1),
     getTxByHash: () => Promise.resolve(undefined),
     getArchivedTxByHash: () => Promise.resolve(undefined),
     markAsMined: () => Promise.resolve(),
@@ -35,55 +48,159 @@ function mockTxPool(): TxPool {
     getAllTxs: () => Promise.resolve([]),
     getAllTxHashes: () => Promise.resolve([]),
     getPendingTxHashes: () => Promise.resolve([]),
+    getPendingTxCount: () => Promise.resolve(0),
     getMinedTxHashes: () => Promise.resolve([]),
     getTxStatus: () => Promise.resolve(TxStatus.PENDING),
+    getTxsByHash: () => Promise.resolve([]),
+    hasTxs: () => Promise.resolve([]),
+    hasTx: () => Promise.resolve(false),
+    updateConfig: () => {},
+    markTxsAsNonEvictable: () => Promise.resolve(),
+    cleanupDeletedMinedTxs: () => Promise.resolve(0),
   };
+  return Object.assign(new EventEmitter(), pool);
 }
 
 function mockAttestationPool(): AttestationPool {
   return {
+    isEmpty: () => Promise.resolve(false),
     addAttestations: () => Promise.resolve(),
     deleteAttestations: () => Promise.resolve(),
     deleteAttestationsOlderThan: () => Promise.resolve(),
     deleteAttestationsForSlot: () => Promise.resolve(),
     deleteAttestationsForSlotAndProposal: () => Promise.resolve(),
     getAttestationsForSlot: () => Promise.resolve([]),
+    getAttestationsForSlotAndProposal: () => Promise.resolve([]),
+    addBlockProposal: () => Promise.resolve(),
+    getBlockProposal: () => Promise.resolve(undefined),
+    hasBlockProposal: () => Promise.resolve(false),
+    hasAttestation: () => Promise.resolve(false),
+    canAddProposal: () => Promise.resolve(true),
+    canAddAttestation: () => Promise.resolve(true),
   };
 }
 
 function mockEpochCache(): EpochCacheInterface {
   return {
-    getCommittee: () => Promise.resolve([] as EthAddress[]),
+    getCommittee: () => Promise.resolve({ committee: [], seed: 1n, epoch: EpochNumber.ZERO }),
     getProposerIndexEncoding: () => '0x' as `0x${string}`,
-    getEpochAndSlotNow: () => ({ epoch: 0n, slot: 0n, ts: 0n }),
+    getEpochAndSlotNow: () => ({ epoch: EpochNumber.ZERO, slot: SlotNumber.ZERO, ts: 0n }),
     computeProposerIndex: () => 0n,
-    getProposerInCurrentOrNextSlot: () =>
+    getProposerAttesterAddressInCurrentOrNextSlot: () =>
       Promise.resolve({
         currentProposer: EthAddress.ZERO,
         nextProposer: EthAddress.ZERO,
-        currentSlot: 0n,
-        nextSlot: 0n,
+        currentSlot: SlotNumber.ZERO,
+        nextSlot: SlotNumber.ZERO,
       }),
+    getEpochAndSlotInNextL1Slot: () => ({ epoch: EpochNumber.ZERO, slot: SlotNumber.ZERO, ts: 0n, now: 0n }),
     isInCommittee: () => Promise.resolve(false),
+    getRegisteredValidators: () => Promise.resolve([]),
+    filterInCommittee: () => Promise.resolve([]),
   };
 }
 
+function mockWorldStateSynchronizer(): WorldStateSynchronizer {
+  return {
+    status: () =>
+      Promise.resolve({
+        syncSummary: {
+          latestBlockNumber: 0,
+          latestBlockHash: '',
+          finalizedBlockNumber: 0,
+          treesAreSynched: false,
+          oldestHistoricBlockNumber: 0,
+        },
+      }),
+  } as WorldStateSynchronizer;
+}
+
+class TestLibP2PService<T extends P2PClientType = P2PClientType.Full> extends LibP2PService<T> {
+  private disableTxValidation: boolean;
+  private gossipMessageCount: number = 0;
+
+  constructor(
+    clientType: T,
+    config: P2PConfig,
+    node: PubSubLibp2p,
+    peerDiscoveryService: PeerDiscoveryService,
+    reqresp: ReqResp,
+    peerManager: PeerManager,
+    mempools: MemPools<T>,
+    archiver: L2BlockSource & ContractDataSource,
+    epochCache: EpochCacheInterface,
+    proofVerifier: ClientProtocolCircuitVerifier,
+    worldStateSynchronizer: WorldStateSynchronizer,
+    telemetry: TelemetryClient,
+    logger = createLogger('p2p:test:libp2p_service'),
+    disableTxValidation = true,
+  ) {
+    super(
+      clientType,
+      config,
+      node,
+      peerDiscoveryService,
+      reqresp,
+      peerManager,
+      mempools,
+      archiver,
+      epochCache,
+      proofVerifier,
+      worldStateSynchronizer,
+      telemetry,
+      logger,
+    );
+    this.disableTxValidation = disableTxValidation;
+  }
+
+  public getGossipMessageCount(): number {
+    return this.gossipMessageCount;
+  }
+
+  public setDisableTxValidation(disable: boolean): void {
+    this.disableTxValidation = disable;
+  }
+
+  protected override async handleGossipedTx(payload: Buffer, msgId: string, source: PeerId) {
+    if (this.disableTxValidation) {
+      const p2pMessage = P2PMessage.fromMessageData(payload);
+      const tx = Tx.fromBuffer(p2pMessage.payload);
+      this.node.services.pubsub.reportMessageValidationResult(msgId, source.toString(), TopicValidatorResult.Accept);
+
+      const txHash = tx.getTxHash();
+      const txHashString = txHash.toString();
+      this.logger.verbose(`Received tx ${txHashString} from external peer ${source.toString()}.`);
+      await this.mempools.txPool.addTxs([tx]);
+    } else {
+      await super.handleGossipedTx(payload, msgId, source);
+    }
+  }
+
+  protected override async handleNewGossipMessage(msg: Message, msgId: string, source: PeerId) {
+    this.gossipMessageCount++;
+    process.send!({
+      type: 'GOSSIP_RECEIVED',
+      count: this.gossipMessageCount,
+    });
+    await super.handleNewGossipMessage(msg, msgId, source);
+  }
+}
+
 // eslint-disable-next-line @typescript-eslint/no-misused-promises
 process.on('message', async msg => {
   const { type, config, clientIndex } = msg as { type: string; config: P2PConfig; clientIndex: number };
-
   try {
     if (type === 'START') {
       const txPool = mockTxPool();
       const attestationPool = mockAttestationPool();
       const epochCache = mockEpochCache();
-      const worldState = {} as WorldStateSynchronizer;
+      const worldState = mockWorldStateSynchronizer();
       const l2BlockSource = new MockL2BlockSource();
-      await l2BlockSource.createBlocks(100);
 
       const proofVerifier = new AlwaysTrueCircuitVerifier();
       const kvStore = await openTmpStore(`test-${clientIndex}`);
       const logger = createLogger(`p2p:${clientIndex}`);
+      const telemetry = getTelemetryClient();
 
       const deps = {
         txPool,
@@ -99,23 +216,32 @@ process.on('message', async msg => {
         proofVerifier,
         worldState,
         epochCache,
+        'test-p2p-bench-worker',
         undefined,
+        telemetry,
         deps,
       );
 
-      // Create spy for gossip messages
-      let gossipMessageCount = 0;
-      (client as any).p2pService.handleNewGossipMessage = (msg: Message, msgId: string, source: PeerId) => {
-        gossipMessageCount++;
-        process.send!({
-          type: 'GOSSIP_RECEIVED',
-          count: gossipMessageCount,
-        });
-        return (client as any).p2pService.constructor.prototype.handleNewGossipMessage.apply(
-          (client as any).p2pService,
-          [msg, msgId, source],
-        );
-      };
+      // Create test service with validation disabled
+      const testService = new TestLibP2PService(
+        P2PClientType.Full,
+        config,
+        (client as any).p2pService.node,
+        (client as any).p2pService.peerDiscoveryService,
+        (client as any).p2pService.mempools,
+        (client as any).p2pService.reqresp,
+        (client as any).p2pService.peerManager,
+        (client as any).p2pService.archiver,
+        epochCache,
+        proofVerifier,
+        worldState,
+        telemetry,
+        logger,
+        true, // disable validation
+      );
+
+      // Replace the existing p2pService with our test version
+      (client as any).p2pService = testService;
 
       await client.start();
       // Wait until the client is ready

package/src/testbench/parse_log_file.ts

@@ -37,7 +37,7 @@ function getTimestamp(line: string): number | null {
 }
 
 /**
- * Parses a single log line. If the line contains an "rpc.from" event,
+ * Parses a single log line. If the line contains an "Received tx" event,
  * it extracts the timestamp and the peer ID.
  */
 function parseReceivedTx(line: string): LogEvent | null {
@@ -52,9 +52,9 @@ function parseReceivedTx(line: string): LogEvent | null {
     return null;
   }
 
-  // TODO: this is not correct - it is just the tx hash for now
-  // Extract the peer ID after "Received tx"
-  const peerIdMatch = line.match(/p2p:(\d+):/);
+  // Extract the peer ID from the log line
+  // Example format: "module":"p2p:1","msg":"Received tx 0x0feeafa65f25fd8d613fe4aca44fd65fe41c149ef1941e2019d40925c40748f9 from external peer 16Uiu2HAm8w4oxXF3TwDKoGL9U66thMXWqCgPnb2CgkYwmUqFCWbC."
+  const peerIdMatch = line.match(/"module":"p2p:(\d+)"/);
   if (!peerIdMatch) {
     logger.error('No peer Number found in received tx log');
     return null;

package/src/testbench/testbench.ts

@@ -1,6 +1,6 @@
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
-import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import { ChonkProof } from '@aztec/stdlib/proofs';
 import { mockTx } from '@aztec/stdlib/testing';
 
 import assert from 'assert';
@@ -21,7 +21,7 @@ async function main() {
     }
 
     const configPath = path.join(__dirname, '../../testbench/configurations', configFile);
-    const config = await import(configPath, { assert: { type: 'json' } });
+    const config = await import(configPath, { with: { type: 'json' } });
     const testConfig = { ...testChainConfig, ...config.default };
     const numberOfClients = config.default.numberOfClients;
 
@@ -35,14 +35,14 @@ async function main() {
 
     // Send tx from client 0
     const tx = await mockTx(1, {
-      clientIvcProof: ClientIvcProof.random(),
+      chonkProof: ChonkProof.random(),
     });
 
     workerClientManager.processes[0].send({ type: 'SEND_TX', tx: tx.toBuffer() });
     logger.info('Transaction sent from client 0');
 
     // Give time for message propagation
-    await sleep(30000);
+    await sleep(10000);
     logger.info('Checking message propagation results');
 
     // Check message propagation results