@aztec/p2p 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2 → 0.76.0

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/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]));
   };
 }

package/src/services/reqresp/reqresp.ts

@@ -598,6 +598,8 @@ export class ReqResp {
       const handler = this.subProtocolHandlers[protocol];
       const transform = this.snappyTransform;
 
+      this.logger.info(`Stream handler for ${protocol}`);
+
       await pipe(
         stream,
         async function* (source: any) {
@@ -605,6 +607,12 @@ export class ReqResp {
             const msg = Buffer.from(chunkList.subarray());
             const response = await handler(connection.remotePeer, msg);
 
+            if (protocol === ReqRespSubProtocol.GOODBYE) {
+              // Don't respond
+              await stream.close();
+              return;
+            }
+
             // Send success code first, then the response
             const successChunk = Buffer.from([ReqRespStatus.SUCCESS]);
             yield new Uint8Array(successChunk);
@@ -615,7 +623,7 @@ export class ReqResp {
         stream,
       );
     } catch (e: any) {
-      this.logger.warn(e);
+      this.logger.warn('Reqresp Response error: ', e);
       this.metrics.recordResponseError(protocol);
 
       // If we receive a known error, we use the error status in the response chunk, otherwise we categorize as unknown

package/src/services/service.ts

@@ -106,4 +106,6 @@ export interface PeerDiscoveryService extends EventEmitter {
   getStatus(): PeerDiscoveryState;
 
   getEnr(): ENR | undefined;
+
+  bootstrapNodes: string[];
 }

package/src/services/types.ts

@@ -29,16 +29,8 @@ export enum GossipSubEvent {
 /***************************************************
  *                    Types
  ***************************************************/
+
 /**
  * Aztec network specific types
  */
-export const AZTEC_ENR_KEY = 'aztec_network';
-
-export enum AztecENR {
-  devnet = 0x01,
-  testnet = 0x02,
-  mainnet = 0x03,
-}
-
-// TODO: Make this an env var
-export const AZTEC_NET = AztecENR.devnet;
+export const AZTEC_ENR_KEY = 'aztec';

package/src/test-helpers/generate-peer-id-private-keys.ts

@@ -0,0 +1,15 @@
+import { generatePrivateKey } from 'viem/accounts';
+
+/**
+ * Generate a list of peer id private keys
+ * @param numberOfPeers - The number of peer id private keys to generate
+ * @returns A list of peer id private keys
+ */
+export function generatePeerIdPrivateKeys(numberOfPeers: number): string[] {
+  const peerIdPrivateKeys: string[] = [];
+  for (let i = 0; i < numberOfPeers; i++) {
+    // magic number is multiaddr prefix: https://multiformats.io/multiaddr/
+    peerIdPrivateKeys.push('08021220' + generatePrivateKey().slice(2, 68));
+  }
+  return peerIdPrivateKeys;
+}

package/src/test-helpers/get-ports.ts

@@ -0,0 +1,8 @@
+import getPort from 'get-port';
+
+/**
+ * Get a list of ports for a given number of peers
+ * @param numberOfPeers - The number of peers to get ports for
+ * @returns A list of ports
+ */
+export const getPorts = (numberOfPeers: number) => Promise.all(Array.from({ length: numberOfPeers }, () => getPort()));

package/src/test-helpers/index.ts

@@ -0,0 +1,5 @@
+export * from './generate-peer-id-private-keys.js';
+export * from './get-ports.js';
+export * from './make-enrs.js';
+export * from './make-test-p2p-clients.js';
+export * from './reqresp-nodes.js';

package/src/test-helpers/make-enrs.ts

@@ -0,0 +1,44 @@
+import { type ChainConfig } from '@aztec/circuit-types/config';
+
+import { SignableENR } from '@chainsafe/enr';
+import { multiaddr } from '@multiformats/multiaddr';
+
+import { convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js';
+import { setAztecEnrKey } from '../versioning.js';
+
+/**
+ * Make a list of ENRs for a given list of p2p private keys and ports
+ * @param p2pPrivateKeys - The private keys of the p2p nodes
+ * @param ports - The ports of the p2p nodes
+ * @returns A list of ENRs
+ */
+export async function makeEnrs(p2pPrivateKeys: string[], ports: number[], config: ChainConfig) {
+  return await Promise.all(
+    p2pPrivateKeys.map((pk, i) => {
+      return makeEnr(pk, ports[i], config);
+    }),
+  );
+}
+
+/**
+ * Make an ENR for a given p2p private key and port
+ * @param p2pPrivateKey - The private key of the p2p node
+ * @param port - The port of the p2p node
+ * @returns The ENR of the p2p node
+ */
+export async function makeEnr(p2pPrivateKey: string, port: number, config: ChainConfig) {
+  const peerId = await createLibP2PPeerIdFromPrivateKey(p2pPrivateKey);
+  const enr = SignableENR.createFromPeerId(peerId);
+
+  const udpAnnounceAddress = `127.0.0.1:${port}`;
+  const tcpAnnounceAddress = `127.0.0.1:${port}`;
+  const udpPublicAddr = multiaddr(convertToMultiaddr(udpAnnounceAddress, 'udp'));
+  const tcpPublicAddr = multiaddr(convertToMultiaddr(tcpAnnounceAddress, 'tcp'));
+
+  // ENRS must include the network and a discoverable address (udp for discv5)
+  setAztecEnrKey(enr, config);
+  enr.setLocationMultiaddr(udpPublicAddr);
+  enr.setLocationMultiaddr(tcpPublicAddr);
+
+  return enr.encodeTxt();
+}

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

@@ -0,0 +1,124 @@
+import { MockL2BlockSource } from '@aztec/archiver/test';
+import { P2PClientType, type WorldStateSynchronizer } from '@aztec/circuit-types';
+import { type EpochCache } from '@aztec/epoch-cache';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { type DataStoreConfig } from '@aztec/kv-store/config';
+import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
+
+import { createP2PClient } from '../client/index.js';
+import { type P2PClient } from '../client/p2p_client.js';
+import { type P2PConfig } from '../config.js';
+import { type AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
+import { type EpochProofQuotePool } from '../mem_pools/epoch_proof_quote_pool/epoch_proof_quote_pool.js';
+import { type TxPool } from '../mem_pools/tx_pool/index.js';
+import { generatePeerIdPrivateKeys } from '../test-helpers/generate-peer-id-private-keys.js';
+import { getPorts } from './get-ports.js';
+import { makeEnrs } from './make-enrs.js';
+import { AlwaysFalseCircuitVerifier, AlwaysTrueCircuitVerifier } from './reqresp-nodes.js';
+
+interface MakeTestP2PClientOptions {
+  mockAttestationPool: AttestationPool;
+  mockEpochProofQuotePool: EpochProofQuotePool;
+  mockTxPool: TxPool;
+  mockEpochCache: EpochCache;
+  mockWorldState: WorldStateSynchronizer;
+  alwaysTrueVerifier?: boolean;
+  p2pBaseConfig: P2PConfig;
+  p2pConfigOverrides?: Partial<P2PConfig>;
+  logger?: Logger;
+}
+
+/**
+ * Creates a single P2P client for testing purposes.
+ * @param peerIdPrivateKey - The private key of the peer.
+ * @param port - The port to run the client on.
+ * @param peers - The peers to connect to.
+ * @param options - The options for the client.
+ * @returns The created client.
+ */
+export async function makeTestP2PClient(
+  peerIdPrivateKey: string,
+  port: number,
+  peers: string[],
+  {
+    alwaysTrueVerifier = true,
+    p2pBaseConfig,
+    p2pConfigOverrides = {},
+    mockAttestationPool,
+    mockEpochProofQuotePool,
+    mockTxPool,
+    mockEpochCache,
+    mockWorldState,
+    logger = createLogger('p2p-test-client'),
+  }: MakeTestP2PClientOptions,
+) {
+  const addr = `127.0.0.1:${port}`;
+  const listenAddr = `0.0.0.0:${port}`;
+
+  // Filter nodes so that we only dial active peers
+
+  const config: P2PConfig & DataStoreConfig = {
+    ...p2pBaseConfig,
+    p2pEnabled: true,
+    peerIdPrivateKey,
+    tcpListenAddress: listenAddr, // run on port 0
+    udpListenAddress: listenAddr,
+    tcpAnnounceAddress: addr,
+    udpAnnounceAddress: addr,
+    bootstrapNodes: peers,
+    peerCheckIntervalMS: 1000,
+    maxPeerCount: 10,
+    ...p2pConfigOverrides,
+  } as P2PConfig & DataStoreConfig;
+
+  const l2BlockSource = new MockL2BlockSource();
+  await l2BlockSource.createBlocks(100);
+
+  const proofVerifier = alwaysTrueVerifier ? new AlwaysTrueCircuitVerifier() : new AlwaysFalseCircuitVerifier();
+  const kvStore = await openTmpStore('test');
+  const deps = {
+    txPool: mockTxPool as unknown as TxPool,
+    attestationPool: mockAttestationPool as unknown as AttestationPool,
+    epochProofQuotePool: mockEpochProofQuotePool as unknown as EpochProofQuotePool,
+    store: kvStore,
+    logger,
+  };
+  const client = await createP2PClient(
+    P2PClientType.Full,
+    config,
+    l2BlockSource,
+    proofVerifier,
+    mockWorldState,
+    mockEpochCache,
+    undefined,
+    deps,
+  );
+  await client.start();
+
+  return client;
+}
+
+/**
+ * Creates a number of P2P clients for testing purposes.
+ * @param numberOfPeers - The number of clients to create.
+ * @param options - The options for the clients.
+ * @returns The created clients.
+ */
+export async function makeTestP2PClients(numberOfPeers: number, testConfig: MakeTestP2PClientOptions) {
+  const clients: P2PClient[] = [];
+  const peerIdPrivateKeys = generatePeerIdPrivateKeys(numberOfPeers);
+
+  const ports = await getPorts(numberOfPeers);
+  const peerEnrs = await makeEnrs(peerIdPrivateKeys, ports, testConfig.p2pBaseConfig);
+
+  for (let i = 0; i < numberOfPeers; i++) {
+    const client = await makeTestP2PClient(peerIdPrivateKeys[i], ports[i], peerEnrs, {
+      ...testConfig,
+      logger: createLogger(`p2p:${i}`),
+    });
+    clients.push(client);
+  }
+
+  await Promise.all(clients.map(client => client.isReady()));
+  return clients;
+}

package/src/{mocks/index.ts → test-helpers/reqresp-nodes.ts}

@@ -5,6 +5,7 @@ import {
   type Tx,
   type WorldStateSynchronizer,
 } from '@aztec/circuit-types';
+import { type ChainConfig, emptyChainConfig } from '@aztec/circuit-types/config';
 import { type EpochCache } from '@aztec/epoch-cache';
 import { timesParallel } from '@aztec/foundation/collection';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
@@ -105,6 +106,7 @@ export async function createTestLibP2PService<T extends P2PClientType>(
   telemetry: TelemetryClient,
   port: number = 0,
   peerId?: PeerId,
+  chainConfig: ChainConfig = emptyChainConfig,
 ) {
   peerId = peerId ?? (await createSecp256k1PeerId());
   const config = {
@@ -114,10 +116,11 @@ export async function createTestLibP2PService<T extends P2PClientType>(
     udpListenAddress: `0.0.0.0:${port}`,
     bootstrapNodes: boostrapAddrs,
     peerCheckIntervalMS: 1000,
-    minPeerCount: 1,
     maxPeerCount: 5,
     p2pEnabled: true,
     peerIdPrivateKey: Buffer.from(peerId.privateKey!).toString('hex'),
+    bootstrapNodeEnrVersionCheck: false,
+    ...chainConfig,
   } as P2PConfig & DataStoreConfig;
   const discoveryService = new DiscV5Service(peerId, config, telemetry);
   const proofVerifier = new AlwaysTrueCircuitVerifier();
@@ -230,15 +233,15 @@ export class AlwaysFalseCircuitVerifier implements ClientProtocolCircuitVerifier
 }
 
 // Bootnodes
-export function createBootstrapNodeConfig(privateKey: string, port: number): BootnodeConfig {
+export function createBootstrapNodeConfig(privateKey: string, port: number, chainConfig: ChainConfig): BootnodeConfig {
   return {
     udpListenAddress: `0.0.0.0:${port}`,
     udpAnnounceAddress: `127.0.0.1:${port}`,
     peerIdPrivateKey: privateKey,
-    minPeerCount: 10,
     maxPeerCount: 100,
     dataDirectory: undefined,
     dataStoreMapSizeKB: 0,
+    ...chainConfig,
   };
 }
 
@@ -246,17 +249,19 @@ export function createBootstrapNodeFromPrivateKey(
   privateKey: string,
   port: number,
   telemetry: TelemetryClient = getTelemetryClient(),
+  chainConfig: ChainConfig = emptyChainConfig,
 ): Promise<BootstrapNode> {
-  const config = createBootstrapNodeConfig(privateKey, port);
+  const config = createBootstrapNodeConfig(privateKey, port, chainConfig);
   return startBootstrapNode(config, telemetry);
 }
 
 export async function createBootstrapNode(
   port: number,
   telemetry: TelemetryClient = getTelemetryClient(),
+  chainConfig: ChainConfig = emptyChainConfig,
 ): Promise<BootstrapNode> {
   const peerId = await createSecp256k1PeerId();
-  const config = createBootstrapNodeConfig(Buffer.from(peerId.privateKey!).toString('hex'), port);
+  const config = createBootstrapNodeConfig(Buffer.from(peerId.privateKey!).toString('hex'), port, chainConfig);
 
   return startBootstrapNode(config, telemetry);
 }

package/src/testbench/README.md

@@ -0,0 +1,20 @@
+## P2P Test bench
+
+A testbench that runs only the P2P client on a number of worker threads, with the purpose of monitoring and testing the performance of the P2P client.
+
+### Running the testbench
+
+```bash
+./run_testbench.sh <outputfile>
+```
+
+This will produce a LONG series of logs that can be used for further analysis.
+
+## TODO
+
+- Strongly parameterizing the testbench scripts
+- Add traffic shaping options to the testbench
+- Add log parsing step that can categorize a report in json of the propoagation of the message
+- Add multiple different tx sizes
+- Create ci pipeline that can run analysis on the logs and compare against previous runs
+- Create a series of markdown reports detailing what each parameter change does and include graphs to compare performance

package/src/testbench/p2p_client_testbench_worker.ts

@@ -0,0 +1,156 @@
+/**
+ * A testbench worker that creates a p2p client and listens for commands from the parent.
+ *
+ * Used when running testbench commands
+ */
+import { MockL2BlockSource } from '@aztec/archiver/test';
+import { P2PClientType, Tx, TxStatus, type WorldStateSynchronizer } from '@aztec/circuit-types';
+import { type EpochCacheInterface } from '@aztec/epoch-cache';
+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 P2PConfig } from '../config.js';
+import { createP2PClient } from '../index.js';
+import { type AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
+import { type EpochProofQuotePool } from '../mem_pools/epoch_proof_quote_pool/epoch_proof_quote_pool.js';
+import { type TxPool } from '../mem_pools/tx_pool/index.js';
+import { AlwaysTrueCircuitVerifier } from '../test-helpers/reqresp-nodes.js';
+
+// Simple mock implementation
+function mockTxPool(): TxPool {
+  // Mock all methods
+  return {
+    addTxs: () => Promise.resolve(),
+    getTxByHash: () => Promise.resolve(undefined),
+    getArchivedTxByHash: () => Promise.resolve(undefined),
+    markAsMined: () => Promise.resolve(),
+    markMinedAsPending: () => Promise.resolve(),
+    deleteTxs: () => Promise.resolve(),
+    getAllTxs: () => Promise.resolve([]),
+    getAllTxHashes: () => Promise.resolve([]),
+    getPendingTxHashes: () => Promise.resolve([]),
+    getMinedTxHashes: () => Promise.resolve([]),
+    getTxStatus: () => Promise.resolve(TxStatus.PENDING),
+  };
+}
+
+function mockAttestationPool(): AttestationPool {
+  return {
+    addAttestations: () => Promise.resolve(),
+    deleteAttestations: () => Promise.resolve(),
+    deleteAttestationsOlderThan: () => Promise.resolve(),
+    deleteAttestationsForSlot: () => Promise.resolve(),
+    deleteAttestationsForSlotAndProposal: () => Promise.resolve(),
+    getAttestationsForSlot: () => Promise.resolve([]),
+  };
+}
+
+function mockEpochProofQuotePool(): EpochProofQuotePool {
+  return {
+    addQuote: () => {},
+    getQuotes: () => [],
+    deleteQuotesToEpoch: () => {},
+  };
+}
+
+function mockEpochCache(): EpochCacheInterface {
+  return {
+    getCommittee: () => Promise.resolve([] as EthAddress[]),
+    getProposerIndexEncoding: () => '0x' as `0x${string}`,
+    getEpochAndSlotNow: () => ({ epoch: 0n, slot: 0n, ts: 0n }),
+    computeProposerIndex: () => 0n,
+    getProposerInCurrentOrNextSlot: () =>
+      Promise.resolve({
+        currentProposer: EthAddress.ZERO,
+        nextProposer: EthAddress.ZERO,
+        currentSlot: 0n,
+        nextSlot: 0n,
+      }),
+    isInCommittee: () => Promise.resolve(false),
+  };
+}
+
+// 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 epochProofQuotePool = mockEpochProofQuotePool();
+      const epochCache = mockEpochCache();
+      const worldState = {} as WorldStateSynchronizer;
+      const l2BlockSource = new MockL2BlockSource();
+      await l2BlockSource.createBlocks(100);
+
+      const proofVerifier = new AlwaysTrueCircuitVerifier();
+      const kvStore = await openTmpStore(`test-${clientIndex}`);
+      const logger = createLogger(`p2p:${clientIndex}`);
+
+      const deps = {
+        txPool,
+        attestationPool,
+        epochProofQuotePool,
+        store: kvStore,
+        logger,
+      };
+
+      const client = await createP2PClient(
+        P2PClientType.Full,
+        config as P2PConfig & DataStoreConfig,
+        l2BlockSource,
+        proofVerifier,
+        worldState,
+        epochCache,
+        undefined,
+        deps,
+      );
+
+      // Create spy for gossip messages
+      let gossipMessageCount = 0;
+      (client as any).p2pService.handleNewGossipMessage = (...args: any[]) => {
+        gossipMessageCount++;
+        process.send!({ type: 'GOSSIP_RECEIVED', count: gossipMessageCount });
+        return (client as any).p2pService.constructor.prototype.handleNewGossipMessage.apply(
+          (client as any).p2pService,
+          args,
+        );
+      };
+
+      await client.start();
+      // Wait until the client is ready
+      for (let i = 0; i < 100; i++) {
+        const isReady = client.isReady();
+        logger.debug(`Client ${clientIndex} isReady: ${isReady}`);
+        if (isReady) {
+          break;
+        }
+        await sleep(1000);
+      }
+
+      // Listen for commands from parent
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
+      process.on('message', async (cmd: any) => {
+        switch (cmd.type) {
+          case 'STOP':
+            await client.stop();
+            process.exit(0);
+            break;
+          case 'SEND_TX':
+            await client.sendTx(Tx.fromBuffer(Buffer.from(cmd.tx)));
+            process.send!({ type: 'TX_SENT' });
+            break;
+        }
+      });
+
+      process.send!({ type: 'READY' });
+    }
+  } catch (err: any) {
+    process.send!({ type: 'ERROR', error: err.message });
+    process.exit(1);
+  }
+});