@aztec/p2p 0.0.1-commit.f5d02921e → 0.0.1-commit.f650c0a5c

package/src/test-helpers/reqresp-nodes.ts

@@ -187,7 +187,6 @@ export const MOCK_SUB_PROTOCOL_HANDLERS: ReqRespSubProtocolHandlers = {
   [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')),
 };
@@ -199,7 +198,6 @@ export const MOCK_SUB_PROTOCOL_VALIDATORS: ReqRespSubProtocolValidators = {
   [ReqRespSubProtocol.STATUS]: noopValidator,
   [ReqRespSubProtocol.TX]: noopValidator,
   [ReqRespSubProtocol.GOODBYE]: noopValidator,
-  [ReqRespSubProtocol.BLOCK]: noopValidator,
   [ReqRespSubProtocol.AUTH]: noopValidator,
   [ReqRespSubProtocol.BLOCK_TXS]: noopValidator,
 };

package/src/test-helpers/testbench-utils.ts

@@ -287,6 +287,7 @@ export function createMockEpochCache(): EpochCacheInterface {
       nowMs: 0n,
     }),
     isProposerPipeliningEnabled: () => false,
+    pipeliningOffset: () => 0,
     computeProposerIndex: () => 0n,
     getCurrentAndNextSlot: () => ({ currentSlot: SlotNumber.ZERO, nextSlot: SlotNumber.ZERO }),
     getTargetAndNextSlot: () => ({ targetSlot: SlotNumber.ZERO, nextSlot: SlotNumber.ZERO }),

package/src/testbench/p2p_client_testbench_worker.ts

@@ -204,6 +204,25 @@ function installUnlimitedRateLimits(client: P2PClient): void {
   rateLimiter.allow = () => RateLimitStatus.Allowed;
 }
 
+/** Resets peer scores to prevent cross-case contamination in benchmarks. */
+function resetPeerScores(client: P2PClient): void {
+  const peerManager = (client as any).p2pService.peerManager;
+  const peerScoring = peerManager?.peerScoring;
+  if (peerScoring?.resetAllScores) {
+    peerScoring.resetAllScores();
+  }
+}
+
+/** Returns the number of connected peers for connectivity checks. */
+function getConnectedPeerCount(client: P2PClient): number {
+  const p2pService = (client as any).p2pService;
+  const connectionSampler = p2pService?.reqresp?.getConnectionSampler?.();
+  if (connectionSampler?.getPeerListSortedByConnectionCountAsc) {
+    return connectionSampler.getPeerListSortedByConnectionCountAsc().length;
+  }
+  return 0;
+}
+
 async function runAggregatorBenchmark(
   client: P2PClient,
   blockProposal: BlockProposal,
@@ -452,6 +471,13 @@ process.on('message', async msg => {
         }
         break;
 
+      case 'GET_PEER_COUNT':
+        process.send!({
+          type: 'PEER_COUNT',
+          count: workerClient ? getConnectedPeerCount(workerClient) : 0,
+        });
+        break;
+
       case 'BENCH_REQRESP': {
         const benchCmd = cmd as BenchReqRespCommand;
         if (!workerClient || !workerTxPool || !workerAttestationPool || !workerConfig || !workerLogger) {
@@ -468,6 +494,7 @@ process.on('message', async msg => {
         // Reset state before each benchmark run to avoid cross-run contamination
         workerTxPool.resetState();
         workerAttestationPool.resetState();
+        resetPeerScores(workerClient);
 
         installUnlimitedRateLimits(workerClient);
 

package/src/testbench/worker_client_manager.ts

@@ -424,6 +424,61 @@ class WorkerClientManager {
     this.logger.info('All worker processes cleaned up');
   }
 
+  /**
+   * Checks that the aggregator (client 0) has sufficient peer connections before running a benchmark.
+   * This prevents benchmark cases from starting with degraded connectivity after a previous case
+   * caused connection failures.
+   */
+  async waitForConnectivity(minPeers: number, timeoutMs: number = 15_000): Promise<number> {
+    const waitInterval = 1000;
+    let waited = 0;
+
+    while (waited < timeoutMs) {
+      const count = await this.getPeerCount(0, 5000);
+      if (count >= minPeers) {
+        this.logger.info(`Connectivity check passed: ${count}/${minPeers} peers connected`);
+        return count;
+      }
+      this.logger.debug(`Waiting for connectivity: ${count}/${minPeers} (waited ${waited}ms)`);
+      await sleep(waitInterval);
+      waited += waitInterval;
+    }
+
+    const finalCount = await this.getPeerCount(0, 5000);
+    this.logger.warn(`Connectivity check: only ${finalCount}/${minPeers} peers after ${timeoutMs}ms`);
+    return finalCount;
+  }
+
+  private getPeerCount(clientIndex: number, timeoutMs: number): Promise<number> {
+    return new Promise<number>(resolve => {
+      let resolved = false;
+
+      const handler = (msg: any) => {
+        if (resolved) {
+          return;
+        }
+        if (msg.type === 'PEER_COUNT') {
+          resolved = true;
+          clearTimeout(timeout);
+          this.processes[clientIndex].off('message', handler);
+          resolve(msg.count as number);
+        }
+      };
+
+      const timeout = setTimeout(() => {
+        if (resolved) {
+          return;
+        }
+        resolved = true;
+        this.processes[clientIndex].off('message', handler);
+        resolve(0);
+      }, timeoutMs);
+
+      this.processes[clientIndex].on('message', handler);
+      this.processes[clientIndex].send({ type: 'GET_PEER_COUNT' });
+    });
+  }
+
   /**
    * Run a req/resp benchmark across all worker clients.
    *

package/dest/services/reqresp/protocols/block.d.ts

@@ -1,9 +0,0 @@
-import type { L2BlockSource } from '@aztec/stdlib/block';
-import type { ReqRespSubProtocolHandler } from '../interface.js';
-/**
- * Handler for L2 Block requests
- * @param l2BlockSource - source for L2 blocks
- * @returns the Block request handler
- * */
-export declare function reqRespBlockHandler(l2BlockSource: L2BlockSource): ReqRespSubProtocolHandler;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvY2suZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9zZXJ2aWNlcy9yZXFyZXNwL3Byb3RvY29scy9ibG9jay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUl6RCxPQUFPLEtBQUssRUFBRSx5QkFBeUIsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBR2pFOzs7O0tBSUs7QUFDTCx3QkFBZ0IsbUJBQW1CLENBQUMsYUFBYSxFQUFFLGFBQWEsR0FBRyx5QkFBeUIsQ0FzQjNGIn0=

package/dest/services/reqresp/protocols/block.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/protocols/block.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAGjE;;;;KAIK;AACL,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,aAAa,GAAG,yBAAyB,CAsB3F"}

package/dest/services/reqresp/protocols/block.js

@@ -1,32 +0,0 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { ReqRespStatus, ReqRespStatusError } from '../status.js';
-/**
- * Handler for L2 Block requests
- * @param l2BlockSource - source for L2 blocks
- * @returns the Block request handler
- * */ export function reqRespBlockHandler(l2BlockSource) {
-    /**
-   * @param peerId - the peer ID of the requester
-   * @param msg - the block request message, which is expected to contain valid block number as a Buffer
-   * @returns a Buffer containing the requested block data, or an empty Buffer if the block is not found
-   * @throws  ReqRespStatusError if the input msg is not a valid block number
-   * */ return async (_peerId, msg)=>{
-        let blockNumber;
-        try {
-            blockNumber = Fr.fromBuffer(msg);
-        } catch (err) {
-            throw new ReqRespStatusError(ReqRespStatus.BADLY_FORMED_REQUEST, {
-                cause: err
-            });
-        }
-        try {
-            const foundBlock = await l2BlockSource.getBlock(BlockNumber(Number(blockNumber)));
-            return foundBlock ? foundBlock.toBuffer() : Buffer.alloc(0);
-        } catch (err) {
-            throw new ReqRespStatusError(ReqRespStatus.INTERNAL_ERROR, {
-                cause: err
-            });
-        }
-    };
-}

package/src/services/reqresp/protocols/block.ts

@@ -1,37 +0,0 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import type { L2BlockSource } from '@aztec/stdlib/block';
-
-import type { PeerId } from '@libp2p/interface';
-
-import type { ReqRespSubProtocolHandler } from '../interface.js';
-import { ReqRespStatus, ReqRespStatusError } from '../status.js';
-
-/**
- * Handler for L2 Block requests
- * @param l2BlockSource - source for L2 blocks
- * @returns the Block request handler
- * */
-export function reqRespBlockHandler(l2BlockSource: L2BlockSource): ReqRespSubProtocolHandler {
-  /**
-   * @param peerId - the peer ID of the requester
-   * @param msg - the block request message, which is expected to contain valid block number as a Buffer
-   * @returns a Buffer containing the requested block data, or an empty Buffer if the block is not found
-   * @throws  ReqRespStatusError if the input msg is not a valid block number
-   * */
-  return async (_peerId: PeerId, msg: Buffer) => {
-    let blockNumber: Fr;
-    try {
-      blockNumber = Fr.fromBuffer(msg);
-    } catch (err: any) {
-      throw new ReqRespStatusError(ReqRespStatus.BADLY_FORMED_REQUEST, { cause: err });
-    }
-
-    try {
-      const foundBlock = await l2BlockSource.getBlock(BlockNumber(Number(blockNumber)));
-      return foundBlock ? foundBlock.toBuffer() : Buffer.alloc(0);
-    } catch (err: any) {
-      throw new ReqRespStatusError(ReqRespStatus.INTERNAL_ERROR, { cause: err });
-    }
-  };
-}