@aztec-labs/p2p 6.0.0-nightly.20260829

package/src/services/tx_provider_instrumentation.ts

@@ -0,0 +1,54 @@
+import {
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  createUpDownCounterWithDefault,
+} from '@aztec-labs/telemetry-client';
+
+export class TxProviderInstrumentation {
+  private txFromProposalCount: UpDownCounter;
+  private txFromMempoolCount: UpDownCounter;
+  private txFromP2PCount: UpDownCounter;
+  private missingTxsCount: UpDownCounter;
+
+  private fractionOfTxsRequestedFromP2P: Histogram;
+  private txsRequestDelay: Histogram;
+
+  constructor(client: TelemetryClient, name: string) {
+    const meter = client.getMeter(name);
+
+    this.txFromProposalCount = createUpDownCounterWithDefault(meter, Metrics.TX_PROVIDER_TXS_FROM_PROPOSALS_COUNT);
+
+    this.txFromMempoolCount = createUpDownCounterWithDefault(meter, Metrics.TX_PROVIDER_TXS_FROM_MEMPOOL_COUNT);
+
+    this.txFromP2PCount = createUpDownCounterWithDefault(meter, Metrics.TX_PROVIDER_TXS_FROM_P2P_COUNT);
+
+    this.missingTxsCount = createUpDownCounterWithDefault(meter, Metrics.TX_PROVIDER_MISSING_TXS_COUNT);
+
+    this.fractionOfTxsRequestedFromP2P = meter.createHistogram(Metrics.TX_PROVIDER_P2P_TXS_REQUESTED_FRACTION);
+
+    this.txsRequestDelay = meter.createHistogram(Metrics.TX_PROVIDER_P2P_TXS_REQUEST_DELAY);
+  }
+
+  incTxsFromProposals(count: number) {
+    this.txFromProposalCount.add(count);
+  }
+
+  incTxsFromMempool(count: number) {
+    this.txFromMempoolCount.add(count);
+  }
+
+  incTxsFromP2P(count: number, total: number) {
+    this.txFromP2PCount.add(count);
+    this.fractionOfTxsRequestedFromP2P.record(count / total);
+  }
+
+  recordTxsRequestDelay(delay: number) {
+    this.txsRequestDelay.record(delay);
+  }
+
+  incMissingTxs(count: number) {
+    this.missingTxsCount.add(count);
+  }
+}

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,8 @@
+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';
+export * from './mock-pubsub.js';
+export * from './test_tx_provider.js';
+export * from './testbench-utils.js';

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

@@ -0,0 +1,42 @@
+import type { ChainConfig } from '@aztec-labs/stdlib/config';
+import { multiaddr } from '@multiformats/multiaddr';
+import { SignableENR } from '@nethermindeth/enr';
+
+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 p2pIp = `127.0.0.1`;
+  const udpPublicAddr = multiaddr(convertToMultiaddr(p2pIp, port, 'udp'));
+  const tcpPublicAddr = multiaddr(convertToMultiaddr(p2pIp, port, '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,213 @@
+import { MockL2BlockSource } from '@aztec-labs/archiver/test';
+import type { EpochCache } from '@aztec-labs/epoch-cache';
+import { SecretValue } from '@aztec-labs/foundation/config';
+import { type Logger, createLogger } from '@aztec-labs/foundation/log';
+import { retryUntil } from '@aztec-labs/foundation/retry';
+import { sleep } from '@aztec-labs/foundation/sleep';
+import { openTmpStore } from '@aztec-labs/kv-store/lmdb-v2';
+import { GasFees } from '@aztec-labs/stdlib/gas';
+import type { WorldStateSynchronizer } from '@aztec-labs/stdlib/interfaces/server';
+import type { DataStoreConfig } from '@aztec-labs/stdlib/kv-store';
+
+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 { TxPoolV2 } from '../mem_pools/tx_pool_v2/interfaces.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 { type MockGossipSubNetwork, getMockPubSubP2PServiceFactory } from './mock-pubsub.js';
+import { AlwaysFalseCircuitVerifier, AlwaysTrueCircuitVerifier } from './reqresp-nodes.js';
+
+export interface MakeTestP2PClientOptions {
+  mockAttestationPool: AttestationPool;
+  mockTxPool: TxPoolV2;
+  mockEpochCache: EpochCache;
+  mockWorldState: WorldStateSynchronizer;
+  alwaysTrueVerifier?: boolean;
+  p2pBaseConfig: P2PConfig;
+  p2pConfigOverrides?: Partial<P2PConfig>;
+  logger?: Logger;
+  mockGossipSubNetwork?: MockGossipSubNetwork;
+}
+
+/**
+ * Creates a single P2P client and immediately starts it 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 and already started client.
+ */
+export async function makeAndStartTestP2PClient(
+  peerIdPrivateKey: string,
+  port: number,
+  peers: string[],
+  options: MakeTestP2PClientOptions,
+) {
+  const client = await makeTestP2PClient(peerIdPrivateKey, port, peers, options);
+
+  await client.start();
+  return client;
+}
+
+/**
+ * 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,
+    mockGossipSubNetwork,
+    logger = createLogger('p2p-test-client'),
+  }: MakeTestP2PClientOptions,
+) {
+  // Filter nodes so that we only dial active peers
+  const config: P2PConfig & DataStoreConfig = {
+    ...p2pBaseConfig,
+    p2pEnabled: true,
+    peerIdPrivateKey: new SecretValue(peerIdPrivateKey),
+    p2pIp: `127.0.0.1`,
+    listenAddress: `127.0.0.1`,
+    p2pPort: port,
+    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 client = await createP2PClient(
+    config,
+    l2BlockSource,
+    proofVerifier,
+    mockWorldState,
+    mockEpochCache,
+    { getCurrentMinFees: () => Promise.resolve(GasFees.empty()) },
+    'test-p2p-client',
+    undefined,
+    undefined,
+    {
+      txPool: mockTxPool as unknown as TxPoolV2,
+      attestationPool: mockAttestationPool as unknown as AttestationPool,
+      store: kvStore,
+      logger,
+      p2pServiceFactory: mockGossipSubNetwork && getMockPubSubP2PServiceFactory(mockGossipSubNetwork),
+    },
+    await l2BlockSource.getInitialHeader().hash(),
+  );
+
+  return client;
+}
+
+/**
+ * Creates a number of P2P clients and immediately starts them for testing purposes.
+ * @param numberOfPeers - The number of clients to create.
+ * @param options - The options for the clients.
+ * @returns The created and started clients.
+ */
+export async function makeAndStartTestP2PClients(numberOfPeers: number, testConfig: MakeTestP2PClientOptions) {
+  const clients: P2PClient[] = [];
+  const peerIdPrivateKeys = generatePeerIdPrivateKeys(numberOfPeers);
+
+  let ports = [];
+  while (true) {
+    try {
+      ports = await getPorts(numberOfPeers);
+      break;
+    } catch {
+      await sleep(1000);
+    }
+  }
+
+  const peerEnrs = await makeEnrs(peerIdPrivateKeys, ports, testConfig.p2pBaseConfig);
+
+  for (let i = 0; i < numberOfPeers; i++) {
+    const client = await makeAndStartTestP2PClient(peerIdPrivateKeys[i], ports[i], peerEnrs, {
+      ...testConfig,
+      logger: createLogger(`p2p:${i}`),
+    });
+    clients.push(client);
+  }
+
+  await retryUntil(() => clients.every(c => c.isReady()), 'p2p clients started', 10, 0.5);
+  testConfig.logger?.info(`Created and started ${clients.length} P2P clients at ports ${ports.join(',')}`, {
+    ports,
+    peerEnrs,
+    peerIdPrivateKeys,
+  });
+
+  return clients.map((client, index) => {
+    return {
+      client,
+      peerPrivateKey: peerIdPrivateKeys[index],
+      port: ports[index],
+      enr: peerEnrs[index],
+    };
+  });
+}
+
+/**
+ * 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);
+
+  let ports = [];
+  while (true) {
+    try {
+      ports = await getPorts(numberOfPeers);
+      break;
+    } catch {
+      await sleep(1000);
+    }
+  }
+
+  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);
+  }
+
+  return clients.map((client, index) => {
+    return {
+      client,
+      peerPrivateKey: peerIdPrivateKeys[index],
+      port: ports[index],
+      enr: peerEnrs[index],
+    };
+  });
+}
+
+export async function startTestP2PClients(clients: P2PClient[]) {
+  await Promise.all(clients.map(c => c.start()));
+  await retryUntil(() => clients.every(c => c.isReady()), 'p2p clients started', 10, 0.5);
+}

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

@@ -0,0 +1,325 @@
+import type { EpochCacheInterface } from '@aztec-labs/epoch-cache';
+import { type Logger, createLogger } from '@aztec-labs/foundation/log';
+import { sleep } from '@aztec-labs/foundation/sleep';
+import type { AztecAsyncKVStore } from '@aztec-labs/kv-store';
+import type { L2BlockSource } from '@aztec-labs/stdlib/block';
+import type { ContractDataSource } from '@aztec-labs/stdlib/contract';
+import type { BlockMinFeesProvider } from '@aztec-labs/stdlib/gas';
+import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec-labs/stdlib/interfaces/server';
+import type { TelemetryClient } from '@aztec-labs/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 { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
+
+import type { P2PConfig } from '../config.js';
+import type { MemPools } from '../mem_pools/interface.js';
+import { DummyPeerDiscoveryService, DummyPeerManager, LibP2PService } from '../services/index.js';
+import type { P2PReqRespConfig } from '../services/reqresp/config.js';
+import type { ConnectionSampler } from '../services/reqresp/connection-sampler/connection_sampler.js';
+import type {
+  ReqRespInterface,
+  ReqRespResponse,
+  ReqRespSubProtocol,
+  ReqRespSubProtocolHandler,
+  ReqRespSubProtocolHandlers,
+} from '../services/reqresp/interface.js';
+import { ReqRespStatus } from '../services/reqresp/status.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(
+  network: MockGossipSubNetwork,
+): (...args: Parameters<(typeof LibP2PService)['new']>) => Promise<LibP2PService> {
+  return (
+    config: P2PConfig,
+    peerId: PeerId,
+    deps: {
+      packageVersion: string;
+      mempools: MemPools;
+      l2BlockSource: L2BlockSource & ContractDataSource;
+      epochCache: EpochCacheInterface;
+      proofVerifier: ClientProtocolCircuitVerifier;
+      worldStateSynchronizer: WorldStateSynchronizer;
+      peerStore: AztecAsyncKVStore;
+      blockMinFeesProvider: BlockMinFeesProvider;
+      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 MockReqResp(peerId, network);
+    const peerDiscoveryService = new DummyPeerDiscoveryService();
+    const service = new LibP2PService(
+      config,
+      libp2p,
+      peerDiscoveryService,
+      reqresp,
+      peerManager,
+      deps.mempools,
+      deps.l2BlockSource,
+      deps.epochCache,
+      deps.proofVerifier,
+      deps.worldStateSynchronizer,
+      deps.blockMinFeesProvider,
+      deps.telemetry,
+      deps.logger,
+    );
+
+    return Promise.resolve(service);
+  };
+}
+
+/**
+ * Mock implementation of ReqRespInterface that routes requests to other peers' handlers through the mock network.
+ * When a peer calls sendRequestToPeer, the mock looks up the target peer's registered handler for the
+ * sub-protocol and invokes it, simulating the request-response protocol without actual libp2p streams.
+ */
+class MockReqResp implements ReqRespInterface {
+  private handlers: Partial<ReqRespSubProtocolHandlers> = {};
+  private logger = createLogger('p2p:test:mock-reqresp');
+
+  constructor(
+    private peerId: PeerId,
+    private network: MockGossipSubNetwork,
+  ) {
+    network.registerReqRespPeer(this);
+  }
+
+  updateConfig(_config: Partial<P2PReqRespConfig>): void {}
+  setShouldRejectPeer(): void {}
+
+  start(subProtocolHandlers: Partial<ReqRespSubProtocolHandlers>): Promise<void> {
+    Object.assign(this.handlers, subProtocolHandlers);
+    return Promise.resolve();
+  }
+
+  addSubProtocol(subProtocol: ReqRespSubProtocol, handler: ReqRespSubProtocolHandler): Promise<void> {
+    this.handlers[subProtocol] = handler;
+    return Promise.resolve();
+  }
+
+  stop(): Promise<void> {
+    this.handlers = {};
+    return Promise.resolve();
+  }
+
+  getHandler(subProtocol: ReqRespSubProtocol): ReqRespSubProtocolHandler | undefined {
+    return this.handlers[subProtocol];
+  }
+
+  async sendRequestToPeer(
+    peerId: PeerId,
+    subProtocol: ReqRespSubProtocol,
+    payload: Buffer,
+    _dialTimeout?: number,
+  ): Promise<ReqRespResponse> {
+    const peer = this.network.getReqRespPeers().find(p => p.peerId.equals(peerId));
+    const handler = peer?.getHandler(subProtocol);
+    if (!handler) {
+      return { status: ReqRespStatus.SUCCESS, data: Buffer.from([]) };
+    }
+    try {
+      const delayMs = this.network.getPropagationDelayMs();
+      if (delayMs > 0) {
+        await sleep(delayMs);
+      }
+      const data = await handler(this.peerId, payload);
+
+      return { status: ReqRespStatus.SUCCESS, data };
+    } catch {
+      return { status: ReqRespStatus.FAILURE };
+    }
+  }
+
+  getConnectionSampler(): Pick<ConnectionSampler, 'getPeerListSortedByConnectionCountAsc'> {
+    return {
+      getPeerListSortedByConnectionCountAsc: () =>
+        this.network
+          .getReqRespPeers()
+          .filter(p => !p.peerId.equals(this.peerId))
+          .map(p => p.peerId),
+    };
+  }
+}
+
+/**
+ * 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,
+      components: {
+        addressManager: {
+          addObservedAddr: () => {},
+          confirmObservedAddr: () => {},
+          removeObservedAddr: () => {},
+        },
+      },
+    };
+  }
+
+  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,
+  };
+
+  async publish(topic: TopicStr, data: Uint8Array, _opts?: PublishOpts): Promise<PublishResult> {
+    this.logger.debug(`Publishing message on topic ${topic}`, { topic, sender: this.peerId.toString() });
+    await this.network.publishToPeers(topic, data, this.peerId);
+    return { 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 },
+    );
+  }
+
+  getMeshPeers(topic?: TopicStr): PeerIdStr[] {
+    if (topic && !this.subscribedTopics.has(topic)) {
+      return [];
+    }
+    return this.network
+      .getPeers()
+      .filter(peer => !this.peerId.equals(peer))
+      .map(peer => peer.toString());
+  }
+}
+
+/**
+ * Mock gossip sub network used for testing.
+ * All instances of MockGossipSubService connected to the same network receive the same messages,
+ * optionally delayed by a configurable propagation time.
+ */
+export class MockGossipSubNetwork {
+  private peers: MockGossipSubService[] = [];
+  private reqRespPeers: MockReqResp[] = [];
+  private nextMsgId = 0;
+
+  private logger = createLogger('p2p:test:mock-gossipsub-network');
+
+  constructor(
+    /** Artificial propagation delay in milliseconds applied to each message delivery. */
+    private propagationDelayMs: number = 0,
+  ) {}
+
+  public getPropagationDelayMs(): number {
+    return this.propagationDelayMs;
+  }
+
+  public getPeers(): PeerId[] {
+    return this.peers.map(peer => peer.peerId);
+  }
+
+  public registerPeer(peer: MockGossipSubService): void {
+    this.peers.push(peer);
+  }
+
+  public registerReqRespPeer(peer: MockReqResp): void {
+    this.reqRespPeers.push(peer);
+  }
+
+  public getReqRespPeers(): MockReqResp[] {
+    return this.reqRespPeers;
+  }
+
+  public async publishToPeers(topic: TopicStr, data: Uint8Array, sender: PeerId): Promise<void> {
+    const msgId = (this.nextMsgId++).toString();
+    this.logger.debug(`Network is distributing message on topic ${topic}`, {
+      topic,
+      size: data.length,
+      sender: sender.toString(),
+      msgId,
+    });
+
+    if (this.propagationDelayMs > 0) {
+      await sleep(this.propagationDelayMs);
+    }
+
+    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);
+      }
+    }
+  }
+}
+
+/**
+ * Registers an extra peer on the mock gossip network that subscribes to nothing and drops every message
+ * delivered to it, and returns its peer id.
+ *
+ * Exists for single-node tests that run on a mock gossip bus: with a single member the node counts zero
+ * connected peers, and connectivity-gated behavior then kicks in even though the topology is intentional
+ * (the node rejects incoming txs since it has nobody to propagate them to, and a proposer under
+ * `minPeersToPropose` skips its slot). Registering one phantom peer keeps those gates satisfied.
+ */
+export async function registerPhantomGossipPeer(network: MockGossipSubNetwork): Promise<PeerId> {
+  const service = new MockGossipSubService(await createSecp256k1PeerId(), network);
+  return service.peerId;
+}

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

@@ -0,0 +1,24 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { getVKTreeRoot } from '@aztec-labs/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec-labs/protocol-contracts';
+import { mockTx } from '@aztec-labs/stdlib/testing';
+import { Tx } from '@aztec-labs/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,
+  });
+};