@aztec/p2p 0.0.1-commit.42ee6df9b → 0.0.1-commit.431c48d

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

@@ -1,4 +1,5 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { compactArray } from '@aztec/foundation/collection';
 import { makeEthSignDigest, tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
@@ -35,6 +36,8 @@ const MAX_CACHED_PEER_AGE_MS = 5 * 60 * 1000; // 5 minutes
 const DEFAULT_FAILED_PEER_BAN_TIME_MS = 5 * 60 * 1000; // 5 minutes timeout after failing MAX_DIAL_ATTEMPTS
 const GOODBYE_DIAL_TIMEOUT_MS = 1000;
 const FAILED_AUTH_HANDSHAKE_EXPIRY_MS = 60 * 60 * 1000; // 1 hour
+const ZERO_PEER_WARNING_THRESHOLD_HEARTBEATS = 3; // tolerate transient dips, such as at startup
+const ZERO_PEER_WARNING_REPEAT_INTERVAL_MS = 60 * 1000;
 
 type CachedPeer = {
   peerId: PeerId;
@@ -70,6 +73,10 @@ export class PeerManager implements PeerManagerInterface {
   private failedAuthHandshakes: Map<string, FailedAuthHandshakeEntry> = new Map();
   private validatorAddresses: EthAddress[] = [];
   private initializedPreferredPeers: boolean = false;
+  private consecutiveZeroPeerHeartbeats: number = 0;
+  private zeroPeerWarningHeartbeats: number = 0;
+  private zeroPeerWarningIssued: boolean = false;
+  private lastConnectedPeerAtMs: number | undefined;
 
   private metrics: PeerManagerMetrics;
   private handlers: {
@@ -114,6 +121,10 @@ export class PeerManager implements PeerManagerInterface {
 
     // Display peer counts every 60 seconds
     this.displayPeerCountsPeerHeartbeat = Math.floor(60_000 / this.config.peerCheckIntervalMS);
+    this.zeroPeerWarningHeartbeats = Math.max(
+      1,
+      Math.floor(ZERO_PEER_WARNING_REPEAT_INTERVAL_MS / this.config.peerCheckIntervalMS),
+    );
   }
   /**
    * Initializes the trusted peers.
@@ -164,6 +175,7 @@ export class PeerManager implements PeerManagerInterface {
   public async heartbeat() {
     this.heartbeatCounter++;
     this.peerScoring.decayAllScores();
+    this.peerScoring.pruneExpiredBans();
     this.cleanupExpiredTimeouts();
 
     await this.setupDirectPeersIfValidator();
@@ -171,6 +183,45 @@ export class PeerManager implements PeerManagerInterface {
     await this.processScheduledDisconnects();
 
     this.discover();
+    this.checkPeerConnectivity();
+  }
+
+  /**
+   * Flags a node that has been left without any connected peers, since it can neither gossip nor propagate txs.
+   *
+   * Warnings only start after a few consecutive zero-peer heartbeats so that startup or a transient dip stays quiet,
+   * and then repeat roughly once a minute instead of on every heartbeat. Recovery is logged once.
+   */
+  private checkPeerConnectivity() {
+    const connectedPeerCount = this.libP2PNode.getPeers().length;
+    const now = this.dateProvider.now();
+
+    if (connectedPeerCount > 0) {
+      if (this.zeroPeerWarningIssued) {
+        this.logger.info(`Peer connectivity restored with ${connectedPeerCount} connected peers`, {
+          connectedPeerCount,
+          zeroPeerHeartbeats: this.consecutiveZeroPeerHeartbeats,
+        });
+      }
+      this.consecutiveZeroPeerHeartbeats = 0;
+      this.zeroPeerWarningIssued = false;
+      this.lastConnectedPeerAtMs = now;
+      return;
+    }
+
+    this.consecutiveZeroPeerHeartbeats++;
+    const heartbeatsSinceThreshold = this.consecutiveZeroPeerHeartbeats - ZERO_PEER_WARNING_THRESHOLD_HEARTBEATS;
+    if (heartbeatsSinceThreshold < 0 || heartbeatsSinceThreshold % this.zeroPeerWarningHeartbeats !== 0) {
+      return;
+    }
+
+    this.zeroPeerWarningIssued = true;
+    this.logger.warn('Node has no connected peers; gossip and tx propagation are unavailable', {
+      zeroPeerHeartbeats: this.consecutiveZeroPeerHeartbeats,
+      peerCheckIntervalMS: this.config.peerCheckIntervalMS,
+      msSinceLastConnectedPeer: this.lastConnectedPeerAtMs === undefined ? undefined : now - this.lastConnectedPeerAtMs,
+      cachedPeers: this.cachedPeers.size,
+    });
   }
 
   /*
@@ -198,21 +249,27 @@ export class PeerManager implements PeerManagerInterface {
       .then(peerIds => peerIds.forEach(peerId => this.preferredPeers.add(peerId.toString())))
       .catch(e => this.logger.error('Error initializing preferred peers', e));
 
-    const directPeers = (
+    const directPeers = compactArray(
       await Promise.all(
         preferredPeersEnrs.map(async enr => {
-          const peerId = await enr.peerId();
-          const address = enr.getLocationMultiaddr('tcp');
-          if (address === undefined) {
-            throw new Error(`Direct peer ${peerId.toString()} has no TCP address, ENR: ${enr.encodeTxt()}`);
+          try {
+            const peerId = await enr.peerId();
+            const address = enr.getLocationMultiaddr('tcp');
+            if (address === undefined) {
+              throw new Error(`Direct peer ${peerId.toString()} has no TCP address, ENR: ${enr.encodeTxt()}`);
+            }
+            return {
+              id: peerId,
+              addrs: [address],
+            };
+          } catch (err) {
+            // A malformed configured ENR shouldn't abort preferred-peer setup — skip it and log.
+            this.logger.warn(`Skipping preferred peer with invalid ENR`, { err });
+            return undefined;
           }
-          return {
-            id: peerId,
-            addrs: [address],
-          };
         }),
-      )
-    ).filter(peer => peer !== undefined);
+      ),
+    );
 
     await Promise.all(
       directPeers.map(peer => {
@@ -494,15 +551,38 @@ export class PeerManager implements PeerManagerInterface {
    *
    * @returns: True if node is allowed to connect, otherwise false
    * */
-  public isNodeAllowedToConnect(id: string | PeerId): boolean {
-    const entry = this.failedAuthHandshakes.get(id.toString());
+  /**
+   * Whether a peer is allowed to connect, given its peer id. Rejects peers serving an active ban and
+   * peers that have exceeded the failed auth-handshake limit. Use this once the peer id is known —
+   * i.e. for the encrypted-inbound gater and when dialing.
+   */
+  public isPeerAllowedToConnect(peerId: string | PeerId): boolean {
+    const id = peerId.toString();
+    if (this.peerScoring.getScoreState(id) === PeerScoreState.Banned) {
+      return false;
+    }
+    return this.isWithinFailedAuthLimit(id);
+  }
+
+  /**
+   * Whether a connection from an address is allowed. Bans are keyed by peer id, which isn't known at
+   * the raw-inbound layer, so only the failed auth-handshake limit (also tracked per address) is
+   * enforced here; the ban is applied once the peer id is known via {@link isPeerAllowedToConnect}.
+   */
+  public isAddressAllowedToConnect(address: string): boolean {
+    return this.isWithinFailedAuthLimit(address);
+  }
+
+  /** Whether the failed auth-handshake count for a peer id or address is below the configured limit. */
+  private isWithinFailedAuthLimit(key: string): boolean {
+    const entry = this.failedAuthHandshakes.get(key);
     if (!entry) {
       return true;
     }
 
     // In case entry is too old, remove it and allow connection
     if (this.dateProvider.now() - entry.lastFailureTimestamp > FAILED_AUTH_HANDSHAKE_EXPIRY_MS) {
-      this.failedAuthHandshakes.delete(id.toString());
+      this.failedAuthHandshakes.delete(key);
       return true;
     }
 
@@ -527,6 +607,7 @@ export class PeerManager implements PeerManagerInterface {
       protectedConnections: protectedPeerCount,
       maxPeerCount: this.config.maxPeerCount,
       cachedPeers: this.cachedPeers.size,
+      discv5KadPeers: this.peerDiscoveryService.getKadValues().length,
       ...this.peerScoring.getStats(),
     });
 
@@ -728,6 +809,12 @@ export class PeerManager implements PeerManagerInterface {
       return;
     }
 
+    // Don't dial banned peers or those that have exceeded the auth failure threshold
+    if (!this.isPeerAllowedToConnect(peerId)) {
+      this.logger.trace(`Skipping peer ${peerId} due to ban or failed auth handshake attempts`);
+      return;
+    }
+
     const [multiaddrTcp] = await Promise.all([enr.getFullMultiaddr('tcp')]);
 
     this.logger.trace(`Handling discovered peer ${peerId} at ${multiaddrTcp?.toString() ?? 'undefined address'}`);
@@ -985,14 +1072,14 @@ export class PeerManager implements PeerManagerInterface {
     const peerIdStr = peerId.toString();
 
     const existingEntry = this.failedAuthHandshakes.get(peerIdStr);
+    const failureCount = (existingEntry?.count || 0) + 1;
     this.failedAuthHandshakes.set(peerIdStr, {
-      count: (existingEntry?.count || 0) + 1,
+      count: failureCount,
       lastFailureTimestamp: now,
     });
 
     const connections = this.libP2PNode.getConnections(peerId);
     connections.forEach(conn => {
-      // We mark the IP address
       const address = conn.remoteAddr.nodeAddress().address;
       const existingAddressEntry = this.failedAuthHandshakes.get(address);
       this.failedAuthHandshakes.set(address, {
@@ -1000,6 +1087,15 @@ export class PeerManager implements PeerManagerInterface {
         lastFailureTimestamp: now,
       });
     });
+
+    // Ban the peer from being re-dialed for a cooldown period (exponential backoff)
+    const banTimeMs = this.config.peerFailedBanTimeMs ?? DEFAULT_FAILED_PEER_BAN_TIME_MS;
+    const backoffMs = banTimeMs * Math.pow(2, Math.min(failureCount - 1, 5));
+    this.timedOutPeers.set(peerIdStr, {
+      peerId: peerIdStr,
+      timeoutUntilMs: now + backoffMs,
+    });
+    this.cachedPeers.delete(peerIdStr);
   }
 
   /*

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

@@ -57,6 +57,9 @@ const MIN_SCORE_BEFORE_BAN = -100;
 const MIN_SCORE_BEFORE_DISCONNECT = -50;
 const SCORE_CLEANUP_THRESHOLD = 0.1;
 
+/** An active ban: the score the peer held when banned, and the timestamp at which the ban lifts. */
+type BanRecord = { score: number; expiry: number };
+
 export class PeerScoring {
   private logger = createLogger('p2p:peer-scoring');
   private scores: Map<string, number> = new Map();
@@ -67,11 +70,21 @@ export class PeerScoring {
 
   private peerStateCounter: UpDownCounter;
 
+  /** Active bans, keyed by peer id. Held in memory only, so they are cleared on restart. */
+  private bannedPeers: Map<string, BanRecord> = new Map();
+  /**
+   * How long a peer remains banned once its score crosses MIN_SCORE_BEFORE_BAN. While banned, the
+   * peer's ban score is returned by getScore regardless of decay, so it cannot recover its way out
+   * of the ban early. After the ban expires the live (decayed) score takes over again.
+   */
+  private readonly banDurationMs: number;
+
   constructor(
     config: P2PConfig,
     telemetry: TelemetryClient = getTelemetryClient(),
     private readonly dateProvider: DateProvider = new DateProvider(),
   ) {
+    this.banDurationMs = config.peerBanDurationSeconds * 1000;
     const orderedValues = config.peerPenaltyValues?.sort((a, b) => a - b);
     this.peerPenalties = {
       [PeerErrorSeverity.HighToleranceError]:
@@ -113,9 +126,31 @@ export class PeerScoring {
 
     this.scores.set(peerId, currentScore);
     this.lastUpdateTime.set(peerId, currentTime);
+
+    this.maybeBanPeer(peerId, currentScore);
+
     return currentScore;
   }
 
+  /**
+   * Records a ban for a peer whose score has crossed the ban threshold, with an expiry banDurationMs
+   * in the future. No-op if the score is above the threshold or the peer is already serving an active
+   * ban (an existing ban is not extended; the original window stands). A previously expired ban does
+   * not block a fresh one — getActiveBanScore prunes it first.
+   */
+  private maybeBanPeer(peerId: string, score: number): void {
+    if (score >= MIN_SCORE_BEFORE_BAN || this.getActiveBanScore(peerId) !== undefined) {
+      return;
+    }
+    const record: BanRecord = { score, expiry: this.dateProvider.now() + this.banDurationMs };
+    this.bannedPeers.set(peerId, record);
+    this.logger.verbose(`Banning peer ${peerId} until ${new Date(record.expiry).toISOString()}`, {
+      peerId,
+      score,
+      expiry: record.expiry,
+    });
+  }
+
   decayAllScores(): void {
     const currentTime = this.dateProvider.now();
     for (const [peerId, lastUpdate] of this.lastUpdateTime.entries()) {
@@ -135,17 +170,58 @@ export class PeerScoring {
     }
   }
 
+  /**
+   * Removes bans whose window has elapsed. Expired bans are otherwise only pruned lazily when their
+   * peer's score is next queried, so a banned peer that disconnects and is never queried again would
+   * linger in the map. Called periodically (per heartbeat) to bound the ban map's size.
+   */
+  pruneExpiredBans(): void {
+    const now = this.dateProvider.now();
+    const expired = [...this.bannedPeers.entries()].filter(([, ban]) => ban.expiry <= now).map(([peerId]) => peerId);
+    for (const peerId of expired) {
+      this.bannedPeers.delete(peerId);
+    }
+  }
+
+  /** Resets all peer scores. Useful for benchmarks to prevent cross-case contamination. */
+  resetAllScores(): void {
+    this.scores.clear();
+    this.lastUpdateTime.clear();
+    this.bannedPeers.clear();
+  }
+
   removePeer(peerId: string): void {
     this.scores.delete(peerId);
     this.lastUpdateTime.delete(peerId);
   }
 
+  /**
+   * The single source of truth for whether a peer is banned. Returns the ban score while the ban is
+   * active, or undefined if the peer is not banned. A ban that has expired is lazily lifted before
+   * returning undefined, so callers never see a stale ban.
+   */
+  private getActiveBanScore(peerId: string): number | undefined {
+    const ban = this.bannedPeers.get(peerId);
+    if (ban === undefined) {
+      return undefined;
+    }
+    if (ban.expiry > this.dateProvider.now()) {
+      return ban.score;
+    }
+    // Ban expired: lift it so the peer can recover.
+    this.bannedPeers.delete(peerId);
+    return undefined;
+  }
+
   getScore(peerId: string): number {
-    return this.scores.get(peerId) || 0;
+    // While a ban is active its ban score is returned regardless of how the live score has decayed,
+    // so the peer stays banned for the full duration.
+    return this.getActiveBanScore(peerId) ?? this.scores.get(peerId) ?? 0;
   }
 
   public getScoreState(peerId: string): PeerScoreState {
-    // TODO(#11329): permanently store banned peers?
+    // A banned peer stays banned for the full ban duration regardless of score decay (see getScore /
+    // maybeBanPeer), rather than silently recovering once its decayed score is cleaned up.
     const score = this.getScore(peerId);
     if (score < MIN_SCORE_BEFORE_BAN) {
       return PeerScoreState.Banned;
@@ -159,7 +235,9 @@ export class PeerScoring {
   getStats(): { medianScore: number; healthyCount: number; disconnectCount: number; bannedCount: number } {
     const stateCounts = { healthy: 0, disconnect: 0, banned: 0 };
 
-    for (const peerId of this.scores.keys()) {
+    // Include banned peers whose live score may have been decayed away but whose ban is still active.
+    const peerIds = new Set([...this.scores.keys(), ...this.bannedPeers.keys()]);
+    for (const peerId of peerIds) {
       const state = this.getScoreState(peerId);
       switch (state) {
         case PeerScoreState.Healthy:

package/src/services/reqresp/README.md

@@ -14,9 +14,8 @@ Applied before the protocol handler runs.
 | STATUS | 5/s | 10/s | same |
 | AUTH | 5/s | 10/s | same |
 | GOODBYE | 5/s | 10/s | same |
-| BLOCK | 2/s | 5/s | same |
 | BLOCK_TXS | 10/s | 200/s | same |
-| TX | (see rate limits file) | (see rate limits file) | same |
+| TX | 10/s | 200/s | same |
 
 - Per-peer limit exceeded: `HighToleranceError` penalty + `RATE_LIMIT_EXCEEDED` status. Penalty fires inside `RequestResponseRateLimiter.allow()`, not the stream handler.
 - Global limit exceeded: `RATE_LIMIT_EXCEEDED` status only (no peer penalty).
@@ -46,7 +45,6 @@ Per-protocol size limits checked via preamble before decompression.
 | Error Type | Severity |
 |------------|----------|
 | GOODBYE subprotocol errors | None |
-| `CollectiveReqRespTimeoutError` / `InvalidResponseError` | None |
 | `AbortError` / connection close / muxer closed | None |
 | `ECONNRESET` / `EPIPE` / `ECONNREFUSED` / `ERR_UNEXPECTED_EOF` | HighToleranceError |
 | `ERR_UNSUPPORTED_PROTOCOL` | HighToleranceError |
@@ -150,26 +148,6 @@ Protected peers (private/trusted/preferred) are always considered "authenticated
 
 ## Block Data Protocols
 
-### BLOCK Protocol (`/aztec/req/block/1.0.0`)
-
-**Server side**:
-
-| Rule | Consequence | File |
-|------|-------------|------|
-| Request must parse as `Fr` | `BADLY_FORMED_REQUEST` + LowToleranceError | `protocols/block.ts` |
-| Block lookup throws | `INTERNAL_ERROR` status | same |
-| Block not found | SUCCESS + empty buffer (design choice; no `NOT_FOUND` status used) | same |
-
-**Requester side** (Snappy limit: 3 MB):
-
-| Rule | Consequence | File |
-|------|-------------|------|
-| Response block number must match requested | LowToleranceError; rejected | `libp2p_service.ts` (`validateRequestedBlock`) |
-| Local block must exist for hash verification | Rejected (no penalty) | same |
-| Response block hash must equal local block hash | MidToleranceError; rejected | same |
-
-**Limitation**: the local-block requirement means BLOCK req/resp is unusable for initial P2P-only sync (before L1 sync provides local copies for verification). A TODO in the code acknowledges this.
-
 ### BLOCK_TXS Protocol (`/aztec/req/block_txs/1.0.0`)
 
 **Server side**:
@@ -179,23 +157,10 @@ Protected peers (private/trusted/preferred) are always considered "authenticated
 | Request must parse as `BlockTxsRequest` (Fr + TxHashArray + BitVector) | `BADLY_FORMED_REQUEST` + LowToleranceError | `protocols/block_txs/block_txs_handler.ts` |
 | BitVector length: non-negative and <= `MAX_TXS_PER_BLOCK` (65536) | Deserialization throws -> `BADLY_FORMED_REQUEST` | `protocols/block_txs/bitvector.ts` |
 | Archive root not found and no explicit txHashes | `NOT_FOUND` status | handler |
-| Internal error during lookup | Unhandled exception -> stream abort (no `INTERNAL_ERROR` status, unlike BLOCK) | handler |
+| Internal error during lookup | Unhandled exception -> stream abort (no `INTERNAL_ERROR` status) | handler |
 
 Conditional registration: BLOCK_TXS handler only registered when `config.disableTransactions` is false. Otherwise peers get `ERR_UNSUPPORTED_PROTOCOL`.
 
-**Requester side via `sendBatchRequest`** (Snappy limit: `max(N, 1) * 512 + 1` KB):
-
-| Rule | Consequence | File |
-|------|-------------|------|
-| Archive root must match request | MidToleranceError | `libp2p_service.ts` (`validateRequestedBlockTxs`) |
-| BitVector length must match request | MidToleranceError | same |
-| No duplicate tx hashes | MidToleranceError | same |
-| Tx count within bounds | MidToleranceError | same |
-| Local block proposal must exist for archive root | Rejected (no penalty) | same |
-| All tx hashes must be in proposal's tx list at allowed indices | LowToleranceError | same |
-| Txs in strictly increasing index order | LowToleranceError | same |
-| Each tx passes well-formedness (Metadata [4 fields], Size, Data, Proof) | LowToleranceError | same |
-
 **Requester side via `BatchTxRequester`** (separate validation path):
 
 | Rule | Consequence | File |

package/src/services/reqresp/batch-tx-requester/batch_tx_requester.ts

@@ -4,9 +4,10 @@ import { FifoMemoryQueue, type ISemaphore, Semaphore } from '@aztec/foundation/q
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider } from '@aztec/foundation/timer';
 import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
-import { Tx, TxArray, TxHash } from '@aztec/stdlib/tx';
+import { Tx, TxArray, TxHash, type TxValidator } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
+import { strict as assert } from 'assert';
 
 import type { IRequestTracker } from '../../tx_collection/request_tracker.js';
 import { ReqRespSubProtocol } from '.././interface.js';
@@ -21,7 +22,7 @@ import {
 import type { BatchTxRequesterLibP2PService, BatchTxRequesterOptions, ITxMetadataCollection } from './interface.js';
 import { MissingTxMetadataCollection } from './missing_txs.js';
 import { type IPeerCollection, PeerCollection } from './peer_collection.js';
-import { BatchRequestTxValidator, type IBatchRequestTxValidator } from './tx_validator.js';
+import { createBatchRequestTxValidator } from './tx_validator.js';
 
 /*
  * Tries to fetch all missing transaction until deadline is hit.
@@ -51,7 +52,7 @@ export class BatchTxRequester {
   private readonly txsMetadata: ITxMetadataCollection;
   private readonly smartRequesterSemaphore: ISemaphore;
   private readonly txQueue: FifoMemoryQueue<Tx>;
-  private readonly txValidator: IBatchRequestTxValidator;
+  private readonly txValidator: TxValidator;
   private readonly smartParallelWorkerCount: number;
   private readonly dumbParallelWorkerCount: number;
   private readonly txBatchSize: number;
@@ -78,7 +79,7 @@ export class BatchTxRequester {
       this.opts.dumbParallelWorkerCount ?? DEFAULT_BATCH_TX_REQUESTER_DUMB_PARALLEL_WORKER_COUNT;
     this.txBatchSize = this.opts.txBatchSize ?? DEFAULT_BATCH_TX_REQUESTER_TX_BATCH_SIZE;
     this.txQueue = new FifoMemoryQueue(this.logger);
-    this.txValidator = this.opts.txValidator ?? new BatchRequestTxValidator(this.p2pService.txValidatorConfig);
+    this.txValidator = this.opts.txValidator ?? createBatchRequestTxValidator(this.p2pService.txValidatorConfig);
 
     if (this.opts.peerCollection) {
       this.peers = this.opts.peerCollection;
@@ -97,7 +98,7 @@ export class BatchTxRequester {
   }
 
   /*
-   * Fetches all missing transactions and yields them  one by one
+   * Fetches all missing transactions and yields them one by one
    * */
   public async *run(): AsyncGenerator<Tx, Tx | undefined, unknown> {
     try {
@@ -428,6 +429,15 @@ export class BatchTxRequester {
       }
 
       const blockResponse = BlockTxsResponse.fromBuffer(response.data);
+
+      // Validate response. Peers will be penalised by the validator if they send invalid response.
+      const isValid = await this.p2pService.validateRequestedBlockTxsConsistency(request, blockResponse, peerId);
+      if (!isValid) {
+        this.logger.debug(`Peer ${peerId.toString()} sent invalid response`);
+        this.handleFailResponseFromPeer(peerId, ReqRespStatus.INTERNAL_ERROR);
+        return;
+      }
+
       await this.handleSuccessResponseFromPeer(peerId, blockResponse);
     } catch (err: any) {
       this.logger.error(`Failed to get valid response from peer ${peerId.toString()}: ${err.message}`, {
@@ -445,27 +455,24 @@ export class BatchTxRequester {
    * Handles failed response form the peer
    * There are 3 scenarios
    * - RATE_LIMIT_EXCEEDED: We mark this and don't query this peer again for some_time
+   * - INTERNAL_ERROR: We use this to cover cases where the request-response consistency validation fails.
    * - FAILURE and UNKNOWN: We penalise this, if peer has been penalised this way N times they are not queried again
    *   this implies we will query these peers couple of more times and give them a chance to "redeem" themselves before completely ignoring them
    */
   private handleFailResponseFromPeer(peerId: PeerId, responseStatus: ReqRespStatus) {
-    if (responseStatus === ReqRespStatus.FAILURE || responseStatus === ReqRespStatus.UNKNOWN) {
-      this.peers.penalisePeer(peerId, PeerErrorSeverity.HighToleranceError);
-      this.peers.markPeerDumb(peerId);
-      this.txsMetadata.clearPeerData(peerId);
-      return;
-    }
-
-    // NOT_FOUND means the peer pruned its block proposal — it can no longer serve
-    // index-based requests, but this is a legitimate state so we don't penalize.
-    if (responseStatus === ReqRespStatus.NOT_FOUND) {
-      this.peers.markPeerDumb(peerId);
-      this.txsMetadata.clearPeerData(peerId);
-      return;
-    }
-
-    if (responseStatus === ReqRespStatus.RATE_LIMIT_EXCEEDED) {
-      this.peers.markPeerRateLimitExceeded(peerId);
+    switch (responseStatus) {
+      case ReqRespStatus.RATE_LIMIT_EXCEEDED:
+        this.peers.markPeerRateLimitExceeded(peerId);
+        return;
+      case ReqRespStatus.INTERNAL_ERROR:
+        this.peers.markPeerDumb(peerId);
+        this.txsMetadata.clearPeerData(peerId);
+        return;
+      default: // includes FAILURE, UNKNOWN
+        this.peers.penalisePeer(peerId, PeerErrorSeverity.HighToleranceError);
+        this.peers.markPeerDumb(peerId);
+        this.txsMetadata.clearPeerData(peerId);
+        return;
     }
   }
 
@@ -485,7 +492,7 @@ export class BatchTxRequester {
    * Handles received txs.
    * Transactions are validated and then put on async queue
    * to be yielded by main running loop
-   * */
+   */
   private async handleReceivedTxs(peerId: PeerId, txs: TxArray) {
     const newTxs = txs.filter(tx => !this.txsMetadata.alreadyFetched(tx.txHash));
 
@@ -493,12 +500,12 @@ export class BatchTxRequester {
       return;
     }
 
-    //TODO: this validation can be slow, maybe spawn worker just for validation
+    // TODO: this validation can be slow, maybe spawn worker just for validation
     // We could use the async queue for communication.
     const validationResults = await Promise.allSettled(
       newTxs.map(async tx => ({
         tx,
-        isValid: (await this.txValidator.validateRequestedTx(tx)).result === 'valid',
+        isValid: (await this.txValidator.validateTx(tx)).result === 'valid',
       })),
     );
 
@@ -553,9 +560,10 @@ export class BatchTxRequester {
       return;
     }
 
-    const hasArchiveRootMismatch = this.blockTxsSource.archive.toString() !== response.archiveRoot.toString();
-    if (hasArchiveRootMismatch) {
-      this.handleArchiveRootMismatch(peerId, response);
+    // If the peer doesn't have the block, we mark them as dumb.
+    if (!response.peerHasBlock()) {
+      this.peers.markPeerDumb(peerId);
+      this.txsMetadata.clearPeerData(peerId);
       return;
     }
 
@@ -573,21 +581,6 @@ export class BatchTxRequester {
     this.smartRequesterSemaphore.release();
   }
 
-  /**
-   * Handles an archive root mismatch between local state and peer response.
-   *
-   * - Response archive is Fr.ZERO (peer pruned proposal, legitimate): marks peer dumb.
-   * - Non-zero archive mismatch (malicious response): penalises + marks dumb.
-   */
-  private handleArchiveRootMismatch(peerId: PeerId, response: BlockTxsResponse): void {
-    if (!response.archiveRoot.isZero()) {
-      this.peers.penalisePeer(peerId, PeerErrorSeverity.LowToleranceError);
-    }
-
-    this.peers.markPeerDumb(peerId);
-    this.txsMetadata.clearPeerData(peerId);
-  }
-
   private peerHasSomeTxsWeAreMissing(_peerId: PeerId, response: BlockTxsResponse): boolean {
     if (response.txIndices.isEmpty()) {
       return false;
@@ -603,15 +596,9 @@ export class BatchTxRequester {
   }
 
   private extractHashesPeerHasFromResponse(response: BlockTxsResponse): Array<TxHash> {
-    const hashes: TxHash[] = [];
-    const indicesOfHashesPeerHas = new Set(response.txIndices.getTrueIndices());
-    this.blockTxsSource.txHashes.forEach((hash, idx) => {
-      if (indicesOfHashesPeerHas.has(idx)) {
-        hashes.push(hash);
-      }
-    });
-
-    return hashes;
+    // Should already have been validated, but just in case.
+    assert(response.txIndices.getLength() === this.blockTxsSource.txHashes.length);
+    return response.txIndices.getTrueIndices().map(idx => this.blockTxsSource.txHashes[idx]);
   }
 
   /*

package/src/services/reqresp/batch-tx-requester/interface.ts

@@ -1,13 +1,14 @@
 import type { ISemaphore } from '@aztec/foundation/queue';
 import type { PeerErrorSeverity } from '@aztec/stdlib/p2p';
-import type { Tx, TxHash } from '@aztec/stdlib/tx';
+import type { Tx, TxHash, TxValidator } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 
 import type { ConnectionSampler } from '../connection-sampler/connection_sampler.js';
+import type { BlockTxsRequest, BlockTxsResponse } from '../index.js';
 import type { ReqRespInterface } from '../interface.js';
 import type { IPeerCollection } from './peer_collection.js';
-import type { BatchRequestTxValidatorConfig, IBatchRequestTxValidator } from './tx_validator.js';
+import type { BatchRequestTxValidatorConfig } from './tx_validator.js';
 
 export interface IPeerPenalizer {
   penalizePeer(peerId: PeerId, penalty: PeerErrorSeverity): void;
@@ -32,13 +33,19 @@ export interface ITxMetadataCollection {
  */
 export interface BatchTxRequesterLibP2PService {
   /** ReqResp interface for sending requests to peers */
-  reqResp: Pick<ReqRespInterface, 'sendBatchRequest' | 'sendRequestToPeer'>;
+  reqResp: Pick<ReqRespInterface, 'sendRequestToPeer'>;
   /** Connection sampler for getting peer lists */
   connectionSampler: Pick<ConnectionSampler, 'getPeerListSortedByConnectionCountAsc'>;
   /** Configuration needed for transaction validation */
   txValidatorConfig: BatchRequestTxValidatorConfig;
   /** Peer scoring for penalizing peers */
   peerScoring: IPeerPenalizer;
+  /** Validate the requested block transactions request-response consistency */
+  validateRequestedBlockTxsConsistency: (
+    request: BlockTxsRequest,
+    response: BlockTxsResponse,
+    peerId: PeerId,
+  ) => Promise<boolean>;
 }
 
 export interface BatchTxRequesterOptions {
@@ -50,5 +57,5 @@ export interface BatchTxRequesterOptions {
   semaphore?: ISemaphore;
   peerCollection?: IPeerCollection;
   /** Optional tx validator for testing - if not provided, one is created from p2pService.txValidatorConfig */
-  txValidator?: IBatchRequestTxValidator;
+  txValidator?: TxValidator;
 }