@aztec/p2p 0.0.0-test.0

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

@@ -0,0 +1,112 @@
+import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
+import type { BlockAttestation, BlockProposal, Gossipable } from '@aztec/stdlib/p2p';
+
+import type { ENR } from '@chainsafe/enr';
+import type { PeerId } from '@libp2p/interface';
+import type EventEmitter from 'events';
+
+import type { ReqRespSubProtocol, SubProtocolMap } from './reqresp/interface.js';
+
+export enum PeerDiscoveryState {
+  RUNNING = 'running',
+  STOPPED = 'stopped',
+}
+
+/**
+ * The interface for a P2P service implementation.
+ */
+export interface P2PService {
+  /**
+   * Starts the service.
+   * @returns An empty promise.
+   */
+  start(): Promise<void>;
+
+  /**
+   * Stops the service.
+   * @returns An empty promise.
+   */
+  stop(): Promise<void>;
+
+  /**
+   * Called to have the given transaction propagated through the P2P network.
+   * @param message - The message to be propagated.
+   */
+  propagate<T extends Gossipable>(message: T): void;
+
+  /**
+   * Request information from peers via the request response protocol.
+   *
+   * @param protocol - The request response protocol to use
+   * @param request - The request type, corresponding to the protocol
+   * @returns The response type, corresponding to the protocol
+   */
+  sendRequest<Protocol extends ReqRespSubProtocol>(
+    protocol: Protocol,
+    request: InstanceType<SubProtocolMap[Protocol]['request']>,
+  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']> | undefined>;
+
+  /**
+   * Send a batch of requests to peers, and return the responses
+   *
+   * @param protocol - The request response protocol to use
+   * @param requests - The requests to send to the peers
+   * @returns The responses to the requests
+   */
+  sendBatchRequest<Protocol extends ReqRespSubProtocol>(
+    protocol: Protocol,
+    requests: InstanceType<SubProtocolMap[Protocol]['request']>[],
+  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']>[] | undefined>;
+
+  // Leaky abstraction: fix https://github.com/AztecProtocol/aztec-packages/issues/7963
+  registerBlockReceivedCallback(callback: (block: BlockProposal) => Promise<BlockAttestation | undefined>): void;
+
+  getEnr(): ENR | undefined;
+
+  getPeers(includePending?: boolean): PeerInfo[];
+}
+
+/**
+ * The interface for a peer discovery service implementation.
+ */
+export interface PeerDiscoveryService extends EventEmitter {
+  /**
+   * Starts the service.
+   * */
+  start(): Promise<void>;
+
+  /**
+   * Stops the service.
+   * */
+  stop(): Promise<void>;
+
+  /**
+   * Gets all peers.
+   * @returns An array of peer ENRs.
+   */
+  getAllPeers(): ENR[];
+
+  /**
+   * Runs findRandomNode query.
+   */
+  runRandomNodesQuery(): Promise<void>;
+
+  /**
+   * Checks if the given peer is a bootstrap peer.
+   * @param peerId - The peer ID to check.
+   * @returns True if the peer is a bootstrap peer.
+   */
+  isBootstrapPeer(peerId: PeerId): boolean;
+
+  /**
+   * Event emitted when a new peer is discovered.
+   */
+  on(event: 'peer:discovered', listener: (enr: ENR) => void): this;
+  emit(event: 'peer:discovered', enr: ENR): boolean;
+
+  getStatus(): PeerDiscoveryState;
+
+  getEnr(): ENR | undefined;
+
+  bootstrapNodes: string[];
+}

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/stdlib/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,122 @@
+import { MockL2BlockSource } from '@aztec/archiver/test';
+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 type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { P2PClientType } from '@aztec/stdlib/p2p';
+
+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 { 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;
+  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,
+    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,
+    bootstrapNodesAsFullPeers: true,
+    ...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,
+    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/test-helpers/reqresp-nodes.ts

@@ -0,0 +1,289 @@
+import type { EpochCache } from '@aztec/epoch-cache';
+import { timesParallel } from '@aztec/foundation/collection';
+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 { P2PClientType } from '@aztec/stdlib/p2p';
+import type { Tx } from '@aztec/stdlib/tx';
+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';
+import { bootstrap } from '@libp2p/bootstrap';
+import { identify } from '@libp2p/identify';
+import type { PeerId } from '@libp2p/interface';
+import { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
+import { tcp } from '@libp2p/tcp';
+import { multiaddr } from '@multiformats/multiaddr';
+import getPort from 'get-port';
+import { type Libp2p, type Libp2pOptions, createLibp2p } from 'libp2p';
+
+import { BootstrapNode } from '../bootstrap/bootstrap.js';
+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 type { P2PReqRespConfig } from '../services/reqresp/config.js';
+import {
+  ReqRespSubProtocol,
+  type ReqRespSubProtocolHandlers,
+  type ReqRespSubProtocolValidators,
+  noopValidator,
+} from '../services/reqresp/interface.js';
+import { pingHandler, statusHandler } from '../services/reqresp/protocols/index.js';
+import { ReqResp } from '../services/reqresp/reqresp.js';
+import { type PubSubLibp2p, convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js';
+
+/**
+ * Creates a libp2p node, pre configured.
+ * @param boostrapAddrs - an optional list of bootstrap addresses
+ * @returns Lip2p node
+ */
+export async function createLibp2pNode(
+  boostrapAddrs: string[] = [],
+  peerId?: PeerId,
+  port?: number,
+  enableGossipSub: boolean = false,
+  start: boolean = true,
+): Promise<Libp2p> {
+  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}`],
+    },
+    connectionEncryption: [noise()],
+    streamMuxers: [yamux()],
+    transports: [tcp()],
+    services: {
+      identify: identify({
+        protocolPrefix: 'aztec',
+      }),
+    },
+  };
+
+  if (boostrapAddrs.length > 0) {
+    options.peerDiscovery = [
+      bootstrap({
+        list: boostrapAddrs,
+      }),
+    ];
+  }
+
+  if (peerId) {
+    options.peerId = peerId;
+  }
+
+  if (enableGossipSub) {
+    options.services!.pubsub = gossipsub({
+      allowPublishToZeroTopicPeers: true,
+    });
+  }
+
+  return await createLibp2p(options);
+}
+
+/**
+ * Test Libp2p service
+ * P2P functionality is operational, however everything else is default
+ *
+ *
+ */
+export async function createTestLibP2PService<T extends P2PClientType>(
+  clientType: T,
+  boostrapAddrs: string[] = [],
+  l2BlockSource: L2BlockSource,
+  worldStateSynchronizer: WorldStateSynchronizer,
+  epochCache: EpochCache,
+  mempools: MemPools<T>,
+  telemetry: TelemetryClient,
+  port: number = 0,
+  peerId?: PeerId,
+  chainConfig: ChainConfig = emptyChainConfig,
+) {
+  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}`,
+    bootstrapNodes: boostrapAddrs,
+    peerCheckIntervalMS: 1000,
+    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();
+
+  // 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);
+
+  return new LibP2PService<T>(
+    clientType,
+    config,
+    p2pNode as PubSubLibp2p,
+    discoveryService,
+    mempools,
+    l2BlockSource,
+    epochCache,
+    proofVerifier,
+    worldStateSynchronizer,
+    telemetry,
+  );
+}
+
+/**
+ * A p2p / req resp node pairing the req node will always contain the p2p node.
+ * they are provided as a pair to allow access the p2p node directly
+ */
+export type ReqRespNode = {
+  p2p: Libp2p;
+  req: ReqResp;
+};
+
+// Mock sub protocol handlers
+export const MOCK_SUB_PROTOCOL_HANDLERS: ReqRespSubProtocolHandlers = {
+  [ReqRespSubProtocol.PING]: pingHandler,
+  [ReqRespSubProtocol.STATUS]: statusHandler,
+  [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')),
+};
+
+// By default, all requests are valid
+// If you want to test an invalid response, you can override the validator
+export const MOCK_SUB_PROTOCOL_VALIDATORS: ReqRespSubProtocolValidators = {
+  [ReqRespSubProtocol.PING]: noopValidator,
+  [ReqRespSubProtocol.STATUS]: noopValidator,
+  [ReqRespSubProtocol.TX]: noopValidator,
+  [ReqRespSubProtocol.GOODBYE]: noopValidator,
+  [ReqRespSubProtocol.BLOCK]: 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 startNodes = async (
+  nodes: ReqRespNode[],
+  subProtocolHandlers = MOCK_SUB_PROTOCOL_HANDLERS,
+  subProtocolValidators = MOCK_SUB_PROTOCOL_VALIDATORS,
+) => {
+  for (const node of nodes) {
+    await node.req.start(subProtocolHandlers, subProtocolValidators);
+  }
+};
+
+export const stopNodes = async (nodes: ReqRespNode[]): Promise<void> => {
+  const stopPromises = nodes.flatMap(node => [node.req.stop(), node.p2p.stop()]);
+  await Promise.all(stopPromises);
+};
+
+// Create a req resp node, exposing the underlying p2p node
+export const createReqResp = async (peerScoring: PeerScoring): Promise<ReqRespNode> => {
+  const p2p = await createLibp2pNode();
+  const config: P2PReqRespConfig = {
+    overallRequestTimeoutMs: 4000,
+    individualRequestTimeoutMs: 2000,
+  };
+  const req = new ReqResp(config, p2p, peerScoring);
+  return {
+    p2p,
+    req,
+  };
+};
+
+// Given a node list; hand shake all of the nodes with each other
+export const connectToPeers = async (nodes: ReqRespNode[]): Promise<void> => {
+  for (const node of nodes) {
+    for (const otherNode of nodes) {
+      if (node === otherNode) {
+        continue;
+      }
+      const addr = otherNode.p2p.getMultiaddrs()[0];
+      await node.p2p.dial(addr);
+    }
+  }
+};
+
+// 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);
+  }
+}
+export class AlwaysFalseCircuitVerifier implements ClientProtocolCircuitVerifier {
+  verifyProof(_tx: Tx): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+}
+
+// Bootnodes
+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,
+    dataDirectory: undefined,
+    dataStoreMapSizeKB: 0,
+    bootstrapNodes: [],
+  };
+}
+
+export function createBootstrapNodeFromPrivateKey(
+  privateKey: string,
+  port: number,
+  telemetry: TelemetryClient = getTelemetryClient(),
+  chainConfig: ChainConfig = emptyChainConfig,
+): Promise<BootstrapNode> {
+  const config = createBootstrapNodeConfig(privateKey, port, chainConfig);
+  return startBootstrapNode(config, telemetry);
+}
+
+/**
+ * Create a bootstrap node ENR
+ * @param privateKey - the private key of the bootstrap node
+ * @param port - the port of the bootstrap node
+ * @returns the bootstrap node ENR
+ */
+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'));
+  enr.setLocationMultiaddr(listenAddrUdp);
+
+  return enr;
+}
+
+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, chainConfig);
+
+  return startBootstrapNode(config, telemetry);
+}
+
+async function startBootstrapNode(config: BootnodeConfig, telemetry: TelemetryClient) {
+  // Open an ephemeral store that will only exist in memory
+  const store = await openTmpStore('bootstrap-node', true);
+  const bootstrapNode = new BootstrapNode(store, telemetry);
+  await bootstrapNode.start(config);
+  return bootstrapNode;
+}

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