@aztec/p2p 0.75.0 → 0.76.0

package/src/services/reqresp/rate-limiter/rate_limiter.ts

@@ -200,9 +200,11 @@ export class RequestResponseRateLimiter {
 
     switch (rateLimitStatus) {
       case RateLimitStatus.DeniedPeer:
-        this.peerScoring.penalizePeer(peerId, PeerErrorSeverity.MidToleranceError);
+        // Hitting a peer specific limit, we should lightly penalise the peer
+        this.peerScoring.penalizePeer(peerId, PeerErrorSeverity.HighToleranceError);
         return false;
       case RateLimitStatus.DeniedGlobal:
+        // Hitting a global limit, we should not penalise the peer
         return false;
       default:
         return true;

package/src/services/reqresp/rate-limiter/rate_limits.ts

@@ -25,11 +25,11 @@ export const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits = {
   [ReqRespSubProtocol.TX]: {
     peerLimit: {
       quotaTimeMs: 1000,
-      quotaCount: 5,
+      quotaCount: 10,
     },
     globalLimit: {
       quotaTimeMs: 1000,
-      quotaCount: 10,
+      quotaCount: 20,
     },
   },
   [ReqRespSubProtocol.BLOCK]: {

package/src/services/reqresp/reqresp.ts

@@ -22,7 +22,8 @@ import { ConnectionSampler } from './connection-sampler/connection_sampler.js';
 import {
   DEFAULT_SUB_PROTOCOL_HANDLERS,
   DEFAULT_SUB_PROTOCOL_VALIDATORS,
-  type ReqRespSubProtocol,
+  type ReqRespResponse,
+  ReqRespSubProtocol,
   type ReqRespSubProtocolHandlers,
   type ReqRespSubProtocolValidators,
   type SubProtocolMap,
@@ -30,6 +31,7 @@ import {
 } from './interface.js';
 import { ReqRespMetrics } from './metrics.js';
 import { RequestResponseRateLimiter } from './rate-limiter/rate_limiter.js';
+import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqRespStatus } from './status.js';
 
 /**
  * The Request Response Service
@@ -190,10 +192,17 @@ export class ReqResp {
         this.logger.trace(`Sending request to peer: ${peer.toString()}`);
         const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffer);
 
+        if (response && response.status !== ReqRespStatus.SUCCESS) {
+          this.logger.debug(
+            `Request to peer ${peer.toString()} failed with status ${prettyPrintReqRespStatus(response.status)}`,
+          );
+          continue;
+        }
+
         // If we get a response, return it, otherwise we iterate onto the next peer
         // We do not consider it a success if we have an empty buffer
-        if (response && response.length > 0) {
-          const object = subProtocolMap[subProtocol].response.fromBuffer(response);
+        if (response && response.data.length > 0) {
+          const object = subProtocolMap[subProtocol].response.fromBuffer(response.data);
           // The response validator handles peer punishment within
           const isValid = await responseValidator(request, object, peer);
           if (!isValid) {
@@ -311,8 +320,22 @@ export class ReqResp {
               for (const index of indices) {
                 const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffers[index]);
 
-                if (response && response.length > 0) {
-                  const object = subProtocolMap[subProtocol].response.fromBuffer(response);
+                // Check the status of the response buffer
+                if (response && response.status !== ReqRespStatus.SUCCESS) {
+                  this.logger.debug(
+                    `Request to peer ${peer.toString()} failed with status ${prettyPrintReqRespStatus(
+                      response.status,
+                    )}`,
+                  );
+
+                  // If we hit a rate limit or some failure, we remove the peer and return the results,
+                  // they will be split among remaining peers and the new sampled peer
+                  batchSampler.removePeerAndReplace(peer);
+                  return { peer, results: peerResults };
+                }
+
+                if (response && response.data.length > 0) {
+                  const object = subProtocolMap[subProtocol].response.fromBuffer(response.data);
                   const isValid = await responseValidator(requests[index], object, peer);
 
                   if (isValid) {
@@ -394,7 +417,7 @@ export class ReqResp {
     peerId: PeerId,
     subProtocol: ReqRespSubProtocol,
     payload: Buffer,
-  ): Promise<Buffer | undefined> {
+  ): Promise<ReqRespResponse | undefined> {
     let stream: Stream | undefined;
     try {
       this.metrics.recordRequestSent(subProtocol);
@@ -402,8 +425,8 @@ export class ReqResp {
       stream = await this.connectionSampler.dialProtocol(peerId, subProtocol);
 
       // Open the stream with a timeout
-      const result = await executeTimeout<Buffer>(
-        (): Promise<Buffer> => pipe([payload], stream!, this.readMessage.bind(this)),
+      const result = await executeTimeout<ReqRespResponse>(
+        (): Promise<ReqRespResponse> => pipe([payload], stream!, this.readMessage.bind(this)),
         this.individualRequestTimeoutMs,
         () => new IndividualReqRespTimeoutError(),
       );
@@ -447,7 +470,15 @@ export class ReqResp {
    * Categorize the error and log it.
    */
   private categorizeError(e: any, peerId: PeerId, subProtocol: ReqRespSubProtocol): PeerErrorSeverity | undefined {
-    // Non pubishable errors
+    // Non punishable errors - we do not expect a response for goodbye messages
+    if (subProtocol === ReqRespSubProtocol.GOODBYE) {
+      this.logger.debug('Error encountered on goodbye sub protocol, no penalty', {
+        peerId: peerId.toString(),
+        subProtocol,
+      });
+      return undefined;
+    }
+
     // We do not punish a collective timeout, as the node triggers this interupt, independent of the peer's behaviour
     const logTags = {
       peerId: peerId.toString(),
@@ -492,14 +523,45 @@ export class ReqResp {
 
   /**
    * Read a message returned from a stream into a single buffer
+   *
+   * The message is split into two components
+   * - The first chunk should contain a control byte, indicating the status of the response see `ReqRespStatus`
+   * - The second chunk should contain the response data
    */
-  private async readMessage(source: AsyncIterable<Uint8ArrayList>): Promise<Buffer> {
+  private async readMessage(source: AsyncIterable<Uint8ArrayList>): Promise<ReqRespResponse> {
+    let statusBuffer: ReqRespStatus | undefined;
     const chunks: Uint8Array[] = [];
-    for await (const chunk of source) {
-      chunks.push(chunk.subarray());
+
+    try {
+      for await (const chunk of source) {
+        if (statusBuffer === undefined) {
+          const firstChunkBuffer = chunk.subarray();
+          statusBuffer = parseStatusChunk(firstChunkBuffer);
+        } else {
+          chunks.push(chunk.subarray());
+        }
+      }
+
+      const messageData = Buffer.concat(chunks);
+      const message: Buffer = this.snappyTransform.inboundTransformNoTopic(messageData);
+
+      return {
+        status: statusBuffer ?? ReqRespStatus.UNKNOWN,
+        data: message,
+      };
+    } catch (e: any) {
+      this.logger.debug(`Reading message failed: ${e.message}`);
+
+      let status = ReqRespStatus.UNKNOWN;
+      if (e instanceof ReqRespStatusError) {
+        status = e.status;
+      }
+
+      return {
+        status,
+        data: Buffer.from([]),
+      };
     }
-    const messageData = Buffer.concat(chunks);
-    return this.snappyTransform.inboundTransformNoTopic(messageData);
   }
 
   /**
@@ -525,35 +587,68 @@ export class ReqResp {
   private async streamHandler(protocol: ReqRespSubProtocol, { stream, connection }: IncomingStreamData) {
     this.metrics.recordRequestReceived(protocol);
 
-    // Store a reference to from this for the async generator
-    if (!this.rateLimiter.allow(protocol, connection.remotePeer)) {
-      this.logger.warn(`Rate limit exceeded for ${protocol} from ${connection.remotePeer}`);
+    try {
+      // Store a reference to from this for the async generator
+      if (!this.rateLimiter.allow(protocol, connection.remotePeer)) {
+        this.logger.warn(`Rate limit exceeded for ${protocol} from ${connection.remotePeer}`);
 
-      // TODO(#8483): handle changing peer scoring for failed rate limit, maybe differentiate between global and peer limits here when punishing
-      await stream.close();
-      return;
-    }
+        throw new ReqRespStatusError(ReqRespStatus.RATE_LIMIT_EXCEEDED);
+      }
 
-    const handler = this.subProtocolHandlers[protocol];
-    const transform = this.snappyTransform;
+      const handler = this.subProtocolHandlers[protocol];
+      const transform = this.snappyTransform;
+
+      this.logger.info(`Stream handler for ${protocol}`);
 
-    try {
       await pipe(
         stream,
         async function* (source: any) {
           for await (const chunkList of source) {
             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);
+
             yield new Uint8Array(transform.outboundTransformNoTopic(response));
           }
         },
         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
+      let errorStatus = ReqRespStatus.UNKNOWN;
+      if (e instanceof ReqRespStatusError) {
+        errorStatus = e.status;
+      }
+
+      const sendErrorChunk = this.sendErrorChunk(errorStatus);
+
+      // Return and yield the response chunk
+      await pipe(
+        stream,
+        async function* (_source: any) {
+          yield* sendErrorChunk;
+        },
+        stream,
+      );
     } finally {
       await stream.close();
     }
   }
+
+  private async *sendErrorChunk(error: ReqRespStatus): AsyncIterable<Uint8Array> {
+    const errorChunk = Buffer.from([error]);
+    yield new Uint8Array(errorChunk);
+  }
 }

package/src/services/reqresp/status.ts

@@ -0,0 +1,59 @@
+/**
+ * The error codes for the ReqResp protocol
+ */
+export enum ReqRespStatus {
+  SUCCESS = 0,
+  RATE_LIMIT_EXCEEDED = 1,
+  BADLY_FORMED_REQUEST = 2,
+  UNKNOWN = 127,
+}
+
+export class ReqRespStatusError extends Error {
+  /**
+   * The status code
+   */
+  status: ReqRespStatus;
+
+  constructor(status: ReqRespStatus) {
+    super(`ReqResp Error: ${prettyPrintReqRespStatus(status)}`);
+    this.status = status;
+  }
+}
+
+/**
+ * Parse the status chunk
+ * @param chunk
+ * @returns
+ *
+ * @throws ReqRespStatusError if the chunk is not valid
+ */
+export function parseStatusChunk(chunk: Uint8Array): ReqRespStatus {
+  if (chunk.length !== 1) {
+    throw new ReqRespStatusError(ReqRespStatus.UNKNOWN);
+  }
+
+  const status = chunk[0];
+  // Check if status is a valid ReqRespStatus value
+  if (!(status in ReqRespStatus)) {
+    throw new ReqRespStatusError(ReqRespStatus.UNKNOWN);
+  }
+  return status as ReqRespStatus;
+}
+
+/**
+ * Pretty print the ReqResp status
+ * @param status
+ * @returns
+ */
+export function prettyPrintReqRespStatus(status: ReqRespStatus) {
+  switch (status) {
+    case ReqRespStatus.SUCCESS:
+      return 'SUCCESS';
+    case ReqRespStatus.RATE_LIMIT_EXCEEDED:
+      return 'RATE_LIMIT_EXCEEDED';
+    case ReqRespStatus.BADLY_FORMED_REQUEST:
+      return 'BADLY_FORMED_REQUEST';
+    case ReqRespStatus.UNKNOWN:
+      return '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