@aztec/p2p 0.0.1-commit.b655e406 → 0.0.1-commit.c2595eba

package/src/services/peer-manager/metrics.ts

@@ -1,20 +1,27 @@
 import {
   Attributes,
   type Gauge,
+  type Histogram,
   Metrics,
   type TelemetryClient,
   type Tracer,
   type UpDownCounter,
-  ValueType,
+  createUpDownCounterWithDefault,
   getTelemetryClient,
 } from '@aztec/telemetry-client';
 
-import { type GoodByeReason, prettyGoodbyeReason } from '../reqresp/protocols/index.js';
+import type { PeerId } from '@libp2p/interface';
+
+import { GoodByeReason, prettyGoodbyeReason } from '../reqresp/protocols/index.js';
 
 export class PeerManagerMetrics {
   private sentGoodbyes: UpDownCounter;
   private receivedGoodbyes: UpDownCounter;
   private peerCount: Gauge;
+  private lowScoreDisconnects: UpDownCounter;
+  private peerConnectionDuration: Histogram;
+
+  private peerConnectedAt: Map<string, number> = new Map<string, number>();
 
   public readonly tracer: Tracer;
 
@@ -25,21 +32,27 @@ export class PeerManagerMetrics {
     this.tracer = telemetryClient.getTracer(name);
 
     const meter = telemetryClient.getMeter(name);
-    this.sentGoodbyes = meter.createUpDownCounter(Metrics.PEER_MANAGER_GOODBYES_SENT, {
-      description: 'Number of goodbyes sent to peers',
-      unit: 'peers',
-      valueType: ValueType.INT,
-    });
-    this.receivedGoodbyes = meter.createUpDownCounter(Metrics.PEER_MANAGER_GOODBYES_RECEIVED, {
-      description: 'Number of goodbyes received from peers',
-      unit: 'peers',
-      valueType: ValueType.INT,
-    });
-    this.peerCount = meter.createGauge(Metrics.PEER_MANAGER_PEER_COUNT, {
-      description: 'Number of peers',
-      unit: 'peers',
-      valueType: ValueType.INT,
+    const goodbyeReasonAttrs = {
+      [Attributes.P2P_GOODBYE_REASON]: [
+        prettyGoodbyeReason(GoodByeReason.SHUTDOWN),
+        prettyGoodbyeReason(GoodByeReason.MAX_PEERS),
+        prettyGoodbyeReason(GoodByeReason.LOW_SCORE),
+        prettyGoodbyeReason(GoodByeReason.BANNED),
+        prettyGoodbyeReason(GoodByeReason.WRONG_NETWORK),
+        prettyGoodbyeReason(GoodByeReason.UNKNOWN),
+      ],
+    };
+    this.sentGoodbyes = createUpDownCounterWithDefault(meter, Metrics.PEER_MANAGER_GOODBYES_SENT, goodbyeReasonAttrs);
+    this.receivedGoodbyes = createUpDownCounterWithDefault(
+      meter,
+      Metrics.PEER_MANAGER_GOODBYES_RECEIVED,
+      goodbyeReasonAttrs,
+    );
+    this.peerCount = meter.createGauge(Metrics.PEER_MANAGER_PEER_COUNT);
+    this.lowScoreDisconnects = createUpDownCounterWithDefault(meter, Metrics.PEER_MANAGER_LOW_SCORE_DISCONNECTS, {
+      [Attributes.P2P_PEER_SCORE_STATE]: ['Banned', 'Disconnect'],
     });
+    this.peerConnectionDuration = meter.createHistogram(Metrics.PEER_MANAGER_PEER_CONNECTION_DURATION);
   }
 
   public recordGoodbyeSent(reason: GoodByeReason) {
@@ -53,4 +66,19 @@ export class PeerManagerMetrics {
   public recordPeerCount(count: number) {
     this.peerCount.record(count);
   }
+
+  public recordLowScoreDisconnect(scoreState: 'Banned' | 'Disconnect') {
+    this.lowScoreDisconnects.add(1, { [Attributes.P2P_PEER_SCORE_STATE]: scoreState });
+  }
+
+  public peerConnected(id: PeerId) {
+    this.peerConnectedAt.set(id.toString(), Date.now());
+  }
+
+  public peerDisconnected(id: PeerId) {
+    const connectedAt = this.peerConnectedAt.get(id.toString());
+    if (connectedAt) {
+      this.peerConnectionDuration.record(Date.now() - connectedAt);
+    }
+  }
 }

package/src/services/peer-manager/peer_manager.ts

@@ -1,13 +1,13 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { makeEthSignDigest, tryRecoverAddress } from '@aztec/foundation/crypto';
+import { makeEthSignDigest, tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { bufferToHex } from '@aztec/foundation/string';
 import { DateProvider } from '@aztec/foundation/timer';
 import type { PeerInfo, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import type { PeerErrorSeverity } from '@aztec/stdlib/p2p';
-import { type TelemetryClient, trackSpan } from '@aztec/telemetry-client';
+import type { TelemetryClient } from '@aztec/telemetry-client';
 
 import type { Connection, PeerId } from '@libp2p/interface';
 import { peerIdFromString } from '@libp2p/peer-id';
@@ -161,7 +161,6 @@ export class PeerManager implements PeerManagerInterface {
     return this.metrics.tracer;
   }
 
-  @trackSpan('PeerManager.heartbeat')
   public async heartbeat() {
     this.heartbeatCounter++;
     this.peerScoring.decayAllScores();
@@ -278,6 +277,7 @@ export class PeerManager implements PeerManagerInterface {
   private handleConnectedPeerEvent(e: CustomEvent<PeerId>) {
     const peerId = e.detail;
     this.logger.verbose(`Connected to peer ${peerId.toString()}`);
+    this.metrics.peerConnected(peerId);
     if (this.config.p2pDisableStatusHandshake) {
       return;
     }
@@ -303,6 +303,7 @@ export class PeerManager implements PeerManagerInterface {
    */
   private handleDisconnectedPeerEvent(e: CustomEvent<PeerId>) {
     const peerId = e.detail;
+    this.metrics.peerDisconnected(peerId);
     this.logger.verbose(`Disconnected from peer ${peerId.toString()}`);
     const validatorAddress = this.authenticatedPeerIdToValidatorAddress.get(peerId.toString());
     if (validatorAddress !== undefined) {
@@ -577,9 +578,11 @@ export class PeerManager implements PeerManagerInterface {
       const score = this.peerScoring.getScoreState(peer.remotePeer.toString());
       switch (score) {
         case PeerScoreState.Banned:
+          this.metrics.recordLowScoreDisconnect('Banned');
           void this.goodbyeAndDisconnectPeer(peer.remotePeer, GoodByeReason.BANNED);
           break;
         case PeerScoreState.Disconnect:
+          this.metrics.recordLowScoreDisconnect('Disconnect');
           void this.goodbyeAndDisconnectPeer(peer.remotePeer, GoodByeReason.LOW_SCORE);
           break;
         case PeerScoreState.Healthy:

package/src/services/peer-manager/peer_scoring.ts

@@ -1,6 +1,14 @@
 import { median } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
 import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import {
+  Attributes,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  createUpDownCounterWithDefault,
+  getTelemetryClient,
+} from '@aztec/telemetry-client';
 
 import type { PeerId } from '@libp2p/interface';
 
@@ -30,7 +38,9 @@ export class PeerScoring {
   private decayFactor = 0.9;
   peerPenalties: { [key in PeerErrorSeverity]: number };
 
-  constructor(config: P2PConfig) {
+  private peerStateCounter: UpDownCounter;
+
+  constructor(config: P2PConfig, telemetry: TelemetryClient = getTelemetryClient()) {
     const orderedValues = config.peerPenaltyValues?.sort((a, b) => a - b);
     this.peerPenalties = {
       [PeerErrorSeverity.HighToleranceError]:
@@ -40,6 +50,12 @@ export class PeerScoring {
       [PeerErrorSeverity.LowToleranceError]:
         orderedValues?.[2] ?? DefaultPeerPenalties[PeerErrorSeverity.LowToleranceError],
     };
+
+    const meter = telemetry.getMeter('PeerScoring');
+
+    this.peerStateCounter = createUpDownCounterWithDefault(meter, Metrics.P2P_PEER_STATE_COUNT, {
+      [Attributes.P2P_PEER_SCORE_STATE]: ['Healthy', 'Disconnect', 'Banned'],
+    });
   }
 
   public penalizePeer(peerId: PeerId, penalty: PeerErrorSeverity) {
@@ -99,7 +115,33 @@ export class PeerScoring {
     return PeerScoreState.Healthy;
   }
 
-  getStats(): { medianScore: number } {
-    return { medianScore: median(Array.from(this.scores.values())) ?? 0 };
+  getStats(): { medianScore: number; healthyCount: number; disconnectCount: number; bannedCount: number } {
+    const stateCounts = { healthy: 0, disconnect: 0, banned: 0 };
+
+    for (const peerId of this.scores.keys()) {
+      const state = this.getScoreState(peerId);
+      switch (state) {
+        case PeerScoreState.Healthy:
+          stateCounts.healthy++;
+          break;
+        case PeerScoreState.Disconnect:
+          stateCounts.disconnect++;
+          break;
+        case PeerScoreState.Banned:
+          stateCounts.banned++;
+          break;
+      }
+    }
+
+    this.peerStateCounter.add(stateCounts.healthy, { [Attributes.P2P_PEER_SCORE_STATE]: 'Healthy' });
+    this.peerStateCounter.add(stateCounts.disconnect, { [Attributes.P2P_PEER_SCORE_STATE]: 'Disconnect' });
+    this.peerStateCounter.add(stateCounts.banned, { [Attributes.P2P_PEER_SCORE_STATE]: 'Banned' });
+
+    return {
+      medianScore: median(Array.from(this.scores.values())) ?? 0,
+      healthyCount: stateCounts.healthy,
+      disconnectCount: stateCounts.disconnect,
+      bannedCount: stateCounts.banned,
+    };
   }
 }

package/src/services/reqresp/batch-tx-requester/README.md

@@ -0,0 +1,305 @@
+# BatchTxRequester
+
+The `BatchTxRequester` is a specialized P2P service that aggressively fetches missing transactions from peers when a node receives a block proposal but lacks some of the referenced transactions. This is critical for validators who need all transactions to attest to a proposal.
+
+## Overview
+
+When a validator receives a block proposal, they must verify all transactions in the block. If some transactions are missing from the local mempool (e.g., due to gossip delays), the `BatchTxRequester` kicks in to fetch them via direct peer-to-peer requests before the attestation deadline.
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                           Block Proposal Received                           │
+│                     (contains hashes of N transactions)                     │
+└─────────────────────────────────────────────────────────────────────────────┘
+                                      │
+                                      ▼
+                    ┌─────────────────────────────────┐
+                    │   Check local mempool for txs   │
+                    └─────────────────────────────────┘
+                                      │
+                    ┌─────────────────┴─────────────────┐
+                    │                                   │
+                    ▼                                   ▼
+          ┌─────────────────┐                 ┌─────────────────┐
+          │   All txs found │                 │  Missing M txs  │
+          │   → Attest now  │                 │                 │
+          └─────────────────┘                 └─────────────────┘
+                                                       │
+                                                       ▼
+                                    ┌───────────────────────────────┐
+                                    │      BatchTxRequester.run()   │
+                                    │   Fetch missing txs until     │
+                                    │   deadline or all collected   │
+                                    └───────────────────────────────┘
+```
+
+## Architecture
+
+### Peer Classification
+
+The requester classifies peers into three categories to optimize fetching:
+
+```
+                              ┌─────────────────────────────┐
+                              │        All Known Peers      │
+                              └─────────────────────────────┘
+                                           │
+              ┌────────────────────────────┼────────────────────────────┐
+              │                            │                            │
+              ▼                            ▼                            ▼
+    ┌─────────────────┐          ┌─────────────────┐          ┌─────────────────┐
+    │   Pinned Peer   │          │   Dumb Peers    │          │   Smart Peers   │
+    │                 │          │                 │          │                 │
+    │ The peer who    │          │ Peers we query  │          │ Peers that have │
+    │ sent us the     │          │ blindly - we    │          │ told us which   │
+    │ block proposal. │          │ don't know what │          │ txs they have   │
+    │ Should have ALL │          │ txs they have.  │          │ via BitVector   │
+    │ transactions.   │          │                 │          │ responses.      │
+    └─────────────────┘          └─────────────────┘          └─────────────────┘
+           │                            │                            │
+           │                            │                            │
+           ▼                            ▼                            ▼
+    ┌─────────────────┐          ┌─────────────────┐          ┌─────────────────┐
+    │ Queried in      │          │ Queried with    │          │ Queried with    │
+    │ dedicated loop, │          │ full tx hashes  │          │ BitVector only  │
+    │ prioritizes     │          │ (peer may not   │          │ (peer has the   │
+    │ least-requested │          │ have proposal)  │          │ block proposal) │
+    │ transactions    │          │                 │          │                 │
+    └─────────────────┘          └─────────────────┘          └─────────────────┘
+```
+
+### Blind Phase → Smart Phase Transition
+
+Peers transition from "dumb" to "smart" when they respond with a valid `BlockTxsResponse` containing:
+1. A matching `blockHash`
+2. A non-empty `txIndices` BitVector indicating which transactions they have
+3. At least one transaction we're still missing
+
+```
+┌──────────────────────────────────────────────────────────────────────────────┐
+│                              BLIND PHASE                                     │
+│  ┌────────────────────────────────────────────────────────────────────────┐  │
+│  │  Initial State: All peers are "dumb" (except pinned peer)              │  │
+│  │                                                                        │  │
+│  │  Request: [blockHash, txHashes (full list), txIndices (BitVector)]     │  │
+│  │           └─ Include full hashes because peer may not have proposal    │  │
+│  │                                                                        │  │
+│  │  Response: [blockHash, txs[], txIndices (what peer has)]               │  │
+│  │            └─ Tells us exactly which txs this peer can provide         │  │
+│  └────────────────────────────────────────────────────────────────────────┘  │
+└──────────────────────────────────────────────────────────────────────────────┘
+                                      │
+                                      │ Peer responds with valid txIndices
+                                      │ AND has txs we're missing
+                                      ▼
+┌──────────────────────────────────────────────────────────────────────────────┐
+│                              SMART PHASE                                     │
+│  ┌────────────────────────────────────────────────────────────────────────┐  │
+│  │  Peer promoted to "smart" - we know exactly what they have             │  │
+│  │                                                                        │  │
+│  │  Request: [blockHash, txIndices (BitVector only)]                      │  │
+│  │           └─ No need for full hashes, peer has the proposal            │  │
+│  │                                                                        │  │
+│  │  Response: [blockHash, txs[], txIndices (updated availability)]        │  │
+│  │            └─ May have received more txs since last response           │  │
+│  └────────────────────────────────────────────────────────────────────────┘  │
+└──────────────────────────────────────────────────────────────────────────────┘
+```
+
+## Concurrent Worker Architecture
+
+The `BatchTxRequester` runs three types of workers concurrently:
+
+```
+                         ┌─────────────────────────────────────┐
+                         │         BatchTxRequester.run()      │
+                         │                                     │
+                         │  ┌─────────────────────────────┐    │
+                         │  │    txQueue (FifoMemoryQueue)│◄───┼──── Yields Tx objects
+                         │  └─────────────────────────────┘    │     to caller
+                         └─────────────────────────────────────┘
+                                          ▲
+                                          │ put(tx)
+           ┌──────────────────────────────┼────────────────────────────┐
+           │                              │                            │
+           │                              │                            │
+┌──────────┴──────────┐       ┌───────────┴─────────┐       ┌──────────┴──────────┐
+│ pinnedPeerRequester │       │    dumbRequester    │       │   smartRequester    │
+│                     │       │                     │       │                     │
+│ Single dedicated    │       │ N parallel workers  │       │ M parallel workers  │
+│ loop for pinned     │       │ (default: 10)       │       │ (default: 10)       │
+│ peer                │       │                     │       │                     │
+│                     │       │ Round-robin through │       │ Wait on semaphore   │
+│ Prioritizes txs     │       │ available dumb      │       │ until peers become  │
+│ that have been      │       │ peers               │       │ smart               │
+│ requested least     │       │                     │       │                     │
+└─────────────────────┘       └─────────────────────┘       └─────────────────────┘
+           │                              │                              │
+           └──────────────────────────────┼──────────────────────────────┘
+                                          │
+                                          ▼
+                              ┌───────────────────────┐
+                              │    requestTxBatch()   │
+                              │                       │
+                              │  sendRequestToPeer()  │
+                              │  via libp2p ReqResp   │
+                              └───────────────────────┘
+```
+
+## Wire Protocol
+
+### BlockTxsRequest
+
+```typescript
+class BlockTxsRequest {
+  blockHash: Fr;           // 32-byte hash of the proposed block header
+  txHashes: TxHashArray;   // Full tx hashes (for dumb peers without proposal)
+  txIndices: BitVector;    // Which txs from proposal we're requesting (1 = want)
+}
+```
+
+### BlockTxsResponse
+
+```typescript
+class BlockTxsResponse {
+  blockHash: Fr;           // Echo back the block hash
+  txs: TxArray;            // Actual transaction data
+  txIndices: BitVector;    // Which txs the peer has available (1 = have)
+}
+```
+
+The `BitVector` is a compact representation where each bit corresponds to a transaction index in the block proposal. This allows efficient capability advertisement without repeating full hashes.
+
+## Key Files
+
+| File | Description |
+|------|-------------|
+| `batch_tx_requester.ts` | Main orchestrator with worker loops |
+| `missing_txs.ts` | Tracks metadata for each missing tx (request count, in-flight status, which peers have it) |
+| `peer_collection.ts` | Manages peer classification (dumb/smart/bad) and rate limiting |
+| `interface.ts` | Type definitions for dependencies |
+| `../protocols/block_txs/` | Wire protocol definitions (`BlockTxsRequest`, `BlockTxsResponse`, `BitVector`) |
+
+## Stopping Conditions
+
+The `BatchTxRequester` stops when any of these conditions are met:
+
+1. **All transactions fetched** - Success!
+2. **Deadline exceeded** - Timeout configured by caller
+3. **Abort signal** - External cancellation
+4. **No transactions to fetch** - Nothing was missing
+
+## Configuration
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `batchTxRequesterSmartParallelWorkerCount` | 10 | Max concurrent requests to smart peers |
+| `batchTxRequesterDumbParallelWorkerCount` | 10 | Max concurrent requests to dumb peers |
+| `batchTxRequesterTxBatchSize` | 8 | Max transactions per request |
+| `batchTxRequesterBadPeerThreshold` | 2 | Penalties before marking peer as bad (see > threshold logic) |
+| `RATE_LIMIT_EXCEEDED_PEER_CACHE_TTL` | 1000ms | Cooldown after rate limit hit |
+
+## Error Handling
+
+### Peer States
+
+- **Bad Peer**: After `batchTxRequesterBadPeerThreshold` penalties, peer is excluded from queries
+- **Bad Peer Penalties**: A penalty is applied on `FAILURE`/`UNKNOWN` responses or when transaction validation fails
+- **Rate Limited**: On `RATE_LIMIT_EXCEEDED` response, peer is temporarily excluded
+- **Redemption**: A peer is removed from the bad set only after a successful response with all transactions valid (this clears the penalty counter)
+- **Peer Scoring**: Each penalty is forwarded to the injected `peerScoring` service with a severity
+
+### Failure Recovery
+
+```
+Request to peer fails
+        │
+        ├── RATE_LIMIT_EXCEEDED → Mark peer rate-limited, sleep, retry later
+        │
+        ├── FAILURE/UNKNOWN → Penalise peer (severity), increment penalty counter
+        │                     │
+        │                     ├── Counter < threshold → Continue querying
+        │                     │
+        │                     └── Counter ≥ threshold → Exclude peer
+        │
+        └── SUCCESS → Process response, if all transactions are valid clear penalties
+```
+
+## Usage Example
+
+```typescript
+const requester = new BatchTxRequester(
+  missingTxHashes,      // TxHash[] - what we need
+  blockProposal,        // BlockProposal - the proposal we're attesting to
+  pinnedPeer,           // PeerId | undefined - who sent us the proposal
+  timeoutMs,            // number - how long to try
+  p2pService,           // BatchTxRequesterLibP2PService
+);
+
+// Async generator yields transactions as they arrive
+for await (const tx of requester.run()) {
+  // Process each transaction as it's fetched and validated
+  mempool.addTx(tx);
+}
+
+// Or collect all at once
+const txs = await BatchTxRequester.collectAllTxs(requester.run());
+```
+
+## Integration with Broader Codebase
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                                P2PClient                                    │
+│                                                                             │
+│  Receives block proposals via gossipsub                                     │
+│  Triggers transaction collection when needed                                │
+└───────────────────────────────────┬─────────────────────────────────────────┘
+                                    │
+                                    ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                              TxCollection                                   │
+│                                                                             │
+│  Coordinates Fast and Slow collection strategies                            │
+│  Manages lifecycle of collection requests                                   │
+└───────────────────┬─────────────────────────────────┬───────────────────────┘
+                    │                                 │
+                    ▼                                 ▼
+┌───────────────────────────────────┐   ┌─────────────────────────────────────┐
+│        FastTxCollection           │   │         SlowTxCollection            │
+│                                   │   │                                     │
+│  Time-critical: attestations      │   │  Background: unproven blocks        │
+│                                   │   │                                     │
+│  1. Try RPC nodes first (fast)    │   │  Periodic polling of RPC nodes      │
+│  2. Fall back to BatchTxRequester │   │  and peers for missing txs          │
+│                                   │   │                                     │
+└───────────────────┬───────────────┘   └─────────────────────────────────────┘
+                    │
+                    │ For 'proposal' requests
+                    ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                           BatchTxRequester                                  │
+│                                                                             │
+│  Aggressive parallel fetching from multiple peers                           │
+│  Uses BLOCK_TXS sub-protocol for efficient batching                         │
+└───────────────────┬─────────────────────────────────────────────────────────┘
+                    │
+                    ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                         ReqResp (libp2p)                                    │
+│                                                                             │
+│  Low-level stream management                                                │
+│  sendRequestToPeer() → opens stream → sends request → awaits response       │
+└───────────────────┬─────────────────────────────────────────────────────────┘
+                    │
+                    ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                    reqRespBlockTxsHandler (on peer)                         │
+│                                                                             │
+│  1. Parse BlockTxsRequest                                                   │
+│  2. Look up block proposal in AttestationPool                               │
+│  3. Check TxPool for available transactions                                 │
+│  4. Build BitVector of available tx indices                                 │
+│  5. Return BlockTxsResponse with txs + availability info                    │
+└─────────────────────────────────────────────────────────────────────────────┘
+```