@aztec/p2p 0.0.0-test.0 → 0.0.1-commit.023c3e5

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

@@ -0,0 +1,188 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { P2PClientType } from '@aztec/stdlib/p2p';
+import type { TelemetryClient } from '@aztec/telemetry-client';
+
+import type { GossipsubEvents, GossipsubMessage } from '@chainsafe/libp2p-gossipsub';
+import type { MsgIdStr, PeerIdStr, PublishOpts, TopicStr } from '@chainsafe/libp2p-gossipsub/types';
+import {
+  type Libp2pStatus,
+  type PeerId,
+  type PublishResult,
+  type TopicValidatorResult,
+  TypedEventEmitter,
+} from '@libp2p/interface';
+
+import type { P2PConfig } from '../config.js';
+import type { MemPools } from '../mem_pools/interface.js';
+import { DummyPeerDiscoveryService, DummyPeerManager, DummyReqResp, LibP2PService } from '../services/index.js';
+import type { ReqRespInterface } from '../services/reqresp/interface.js';
+import { GossipSubEvent } from '../types/index.js';
+import type { PubSubLibp2p } from '../util.js';
+
+type GossipSubService = PubSubLibp2p['services']['pubsub'];
+
+/**
+ * Given a mock gossip sub network, returns a factory function that creates an instance LibP2PService connected to it.
+ * Designed to be used in tests in P2PClientDeps.p2pServiceFactory.
+ */
+export function getMockPubSubP2PServiceFactory<T extends P2PClientType>(
+  network: MockGossipSubNetwork,
+): (...args: Parameters<(typeof LibP2PService<T>)['new']>) => Promise<LibP2PService<T>> {
+  return (
+    clientType: P2PClientType,
+    config: P2PConfig,
+    peerId: PeerId,
+    deps: {
+      packageVersion: string;
+      mempools: MemPools;
+      l2BlockSource: L2BlockSource & ContractDataSource;
+      epochCache: EpochCacheInterface;
+      proofVerifier: ClientProtocolCircuitVerifier;
+      worldStateSynchronizer: WorldStateSynchronizer;
+      peerStore: AztecAsyncKVStore;
+      telemetry: TelemetryClient;
+      logger: Logger;
+    },
+  ) => {
+    deps.logger.verbose('Creating mock PubSub service');
+    const libp2p = new MockPubSub(peerId, network);
+    const peerManager = new DummyPeerManager(peerId, network);
+    const reqresp: ReqRespInterface = new DummyReqResp();
+    const peerDiscoveryService = new DummyPeerDiscoveryService();
+    const service = new LibP2PService<T>(
+      clientType as T,
+      config,
+      libp2p,
+      peerDiscoveryService,
+      reqresp,
+      peerManager,
+      deps.mempools,
+      deps.l2BlockSource,
+      deps.epochCache,
+      deps.proofVerifier,
+      deps.worldStateSynchronizer,
+      deps.telemetry,
+      deps.logger,
+    );
+
+    return Promise.resolve(service);
+  };
+}
+
+/**
+ * Implementation of PubSub services that relies on a mock gossip sub network.
+ * This is used in tests to simulate a gossip sub network without needing a real P2P network.
+ * All messages are sent to the mock network which then distributes them to subscribed peers.
+ */
+export class MockPubSub implements PubSubLibp2p {
+  public status: Libp2pStatus = 'stopped';
+
+  private gossipSub: GossipSubService;
+
+  constructor(
+    public peerId: PeerId,
+    network: MockGossipSubNetwork,
+  ) {
+    this.gossipSub = new MockGossipSubService(peerId, network);
+  }
+
+  get services() {
+    return {
+      pubsub: this.gossipSub,
+    };
+  }
+
+  start(): void | Promise<void> {
+    this.status = 'started';
+    return Promise.resolve();
+  }
+  stop(): void | Promise<void> {
+    this.status = 'stopped';
+    return Promise.resolve();
+  }
+}
+
+class MockGossipSubService extends TypedEventEmitter<GossipsubEvents> implements GossipSubService {
+  private logger = createLogger('p2p:test:mock-gossipsub');
+  public subscribedTopics: Set<TopicStr> = new Set();
+  public readonly direct = new Set<string>();
+
+  constructor(
+    public peerId: PeerId,
+    private network: MockGossipSubNetwork,
+  ) {
+    super();
+    network.registerPeer(this);
+  }
+
+  score = {
+    score: (_peerId: PeerIdStr) => 0,
+  };
+
+  publish(topic: TopicStr, data: Uint8Array, _opts?: PublishOpts): Promise<PublishResult> {
+    this.logger.debug(`Publishing message on topic ${topic}`, { topic, sender: this.peerId.toString() });
+    this.network.publishToPeers(topic, data, this.peerId);
+    return Promise.resolve({ recipients: this.network.getPeers().filter(peer => !this.peerId.equals(peer)) });
+  }
+
+  receive(msg: GossipsubMessage) {
+    if (msg.propagationSource.equals(this.peerId)) {
+      return; // Ignore messages from self
+    }
+    this.logger.debug(`Received message on topic ${msg.msg.topic}`, { ...msg });
+    this.safeDispatchEvent<GossipsubMessage>(GossipSubEvent.MESSAGE, { detail: msg });
+  }
+
+  subscribe(topic: TopicStr): void {
+    this.logger.debug(`Subscribed to topic ${topic}`, { topic });
+    this.subscribedTopics.add(topic);
+  }
+
+  reportMessageValidationResult(msgId: MsgIdStr, propagationSource: PeerIdStr, acceptance: TopicValidatorResult): void {
+    this.logger.debug(
+      `Reported message validation result ${acceptance} for msgId ${msgId} from source ${propagationSource}`,
+      { msgId, propagationSource, acceptance },
+    );
+  }
+}
+
+/**
+ * Mock gossip sub network used for testing.
+ * All instances of MockGossipSubService connected to the same network will instantly receive the same messages.
+ */
+export class MockGossipSubNetwork {
+  private peers: MockGossipSubService[] = [];
+  private nextMsgId = 0;
+
+  private logger = createLogger('p2p:test:mock-gossipsub-network');
+
+  public getPeers(): PeerId[] {
+    return this.peers.map(peer => peer.peerId);
+  }
+
+  public registerPeer(peer: MockGossipSubService): void {
+    this.peers.push(peer);
+  }
+
+  public publishToPeers(topic: TopicStr, data: Uint8Array, sender: PeerId): void {
+    const msgId = (this.nextMsgId++).toString();
+    this.logger.debug(`Network is distributing message on topic ${topic}`, {
+      topic,
+      size: data.length,
+      sender: sender.toString(),
+      msgId,
+    });
+
+    const gossipSubMsg: GossipsubMessage = { msgId, msg: { type: 'unsigned', topic, data }, propagationSource: sender };
+    for (const peer of this.peers) {
+      if (peer.subscribedTopics.has(topic)) {
+        peer.receive(gossipSubMsg);
+      }
+    }
+  }
+}

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

@@ -0,0 +1,24 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+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,10 +109,10 @@ 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>,
+  mempools: MemPools,
   telemetry: TelemetryClient,
   port: number = 0,
   peerId?: PeerId,
@@ -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/test-helpers/test_tx_provider.ts

@@ -0,0 +1,64 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { L2Block } from '@aztec/stdlib/block';
+import type { ITxProvider } from '@aztec/stdlib/interfaces/server';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
+import { type Tx, TxHash } from '@aztec/stdlib/tx';
+
+import type { PeerId } from '@libp2p/interface';
+
+/**
+ * Test transaction provider that can be seeded with transactions.
+ * Returns seeded txs when requested by hash, useful for testing block
+ * proposal handling without requiring a full P2P network.
+ */
+export class TestTxProvider implements ITxProvider {
+  private txs: Map<string, Tx> = new Map();
+
+  /** Seed transactions that will be returned when requested. */
+  seed(txs: Tx[]) {
+    for (const tx of txs) {
+      this.txs.set(tx.getTxHash().toString(), tx);
+    }
+  }
+
+  /** Clear all seeded transactions. */
+  clear() {
+    this.txs.clear();
+  }
+
+  /** Returns txs from the seeded collection given their hashes. */
+  getAvailableTxs(txHashes: TxHash[]): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    return this.getTxsByHashes(txHashes);
+  }
+
+  /** Get txs for a block proposal, returning any seeded txs that match the requested hashes. */
+  getTxsForBlockProposal(
+    blockProposal: BlockProposal,
+    _blockNumber: BlockNumber,
+    _opts: { pinnedPeer: PeerId | undefined; deadline: Date },
+  ): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    return this.getTxsByHashes(blockProposal.txHashes);
+  }
+
+  /** Get txs for a block, returning any seeded txs that match the tx effects in the block. */
+  getTxsForBlock(block: L2Block, _opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    const txHashes = block.body.txEffects.map(txEffect => txEffect.txHash);
+    return this.getTxsByHashes(txHashes);
+  }
+
+  private getTxsByHashes(txHashes: TxHash[]): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    const txs: Tx[] = [];
+    const missingTxs: TxHash[] = [];
+
+    for (const txHash of txHashes) {
+      const tx = this.txs.get(txHash.toString());
+      if (tx) {
+        txs.push(tx);
+      } else {
+        missingTxs.push(txHash);
+      }
+    }
+
+    return Promise.resolve({ txs, missingTxs });
+  }
+}