@aztec/p2p 0.0.1-commit.29c6b1a3 → 0.0.1-commit.2eb6648a

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

@@ -6,12 +6,13 @@ import {
   type TelemetryClient,
   type Tracer,
   type UpDownCounter,
+  createUpDownCounterWithDefault,
   getTelemetryClient,
 } from '@aztec/telemetry-client';
 
 import type { PeerId } from '@libp2p/interface';
 
-import { type GoodByeReason, prettyGoodbyeReason } from '../reqresp/protocols/index.js';
+import { GoodByeReason, prettyGoodbyeReason } from '../reqresp/protocols/index.js';
 
 export class PeerManagerMetrics {
   private sentGoodbyes: UpDownCounter;
@@ -31,10 +32,26 @@ export class PeerManagerMetrics {
     this.tracer = telemetryClient.getTracer(name);
 
     const meter = telemetryClient.getMeter(name);
-    this.sentGoodbyes = meter.createUpDownCounter(Metrics.PEER_MANAGER_GOODBYES_SENT);
-    this.receivedGoodbyes = meter.createUpDownCounter(Metrics.PEER_MANAGER_GOODBYES_RECEIVED);
+    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 = meter.createUpDownCounter(Metrics.PEER_MANAGER_LOW_SCORE_DISCONNECTS);
+    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);
   }
 

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

@@ -6,6 +6,7 @@ import {
   Metrics,
   type TelemetryClient,
   type UpDownCounter,
+  createUpDownCounterWithDefault,
   getTelemetryClient,
 } from '@aztec/telemetry-client';
 
@@ -52,7 +53,9 @@ export class PeerScoring {
 
     const meter = telemetry.getMeter('PeerScoring');
 
-    this.peerStateCounter = meter.createUpDownCounter(Metrics.P2P_PEER_STATE_COUNT);
+    this.peerStateCounter = createUpDownCounterWithDefault(meter, Metrics.P2P_PEER_STATE_COUNT, {
+      [Attributes.P2P_PEER_SCORE_STATE]: ['Healthy', 'Disconnect', 'Banned'],
+    });
   }
 
   public penalizePeer(peerId: PeerId, penalty: PeerErrorSeverity) {

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

@@ -1,14 +1,14 @@
 # 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.
+The `BatchTxRequester` is a specialized P2P service that aggressively fetches missing transactions from peers when a node lacks some of the referenced transactions. It serves two pathways: (1) block proposals, where validators need all transactions to attest, and (2) block proving, where provers need all transactions to generate proofs.
 
 ## 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.
+When a validator receives a block proposal or a prover needs to prove a block, they must have all transactions. 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 deadline.
 
 ```
 ┌─────────────────────────────────────────────────────────────────────────────┐
-│                           Block Proposal Received                           │
+│                      Block Proposal or Block Received                       │
 │                     (contains hashes of N transactions)                     │
 └─────────────────────────────────────────────────────────────────────────────┘
                                       │
@@ -71,7 +71,7 @@ The requester classifies peers into three categories to optimize fetching:
 ### Blind Phase → Smart Phase Transition
 
 Peers transition from "dumb" to "smart" when they respond with a valid `BlockTxsResponse` containing:
-1. A matching `blockHash`
+1. A matching `archiveRoot`
 2. A non-empty `txIndices` BitVector indicating which transactions they have
 3. At least one transaction we're still missing
 
@@ -81,10 +81,10 @@ Peers transition from "dumb" to "smart" when they respond with a valid `BlockTxs
 │  ┌────────────────────────────────────────────────────────────────────────┐  │
 │  │  Initial State: All peers are "dumb" (except pinned peer)              │  │
 │  │                                                                        │  │
-│  │  Request: [blockHash, txHashes (full list), txIndices (BitVector)]     │  │
+│  │  Request: [archiveRoot, txHashes (full list), txIndices (BitVector)]   │  │
 │  │           └─ Include full hashes because peer may not have proposal    │  │
 │  │                                                                        │  │
-│  │  Response: [blockHash, txs[], txIndices (what peer has)]               │  │
+│  │  Response: [archiveRoot, txs[], txIndices (what peer has)]             │  │
 │  │            └─ Tells us exactly which txs this peer can provide         │  │
 │  └────────────────────────────────────────────────────────────────────────┘  │
 └──────────────────────────────────────────────────────────────────────────────┘
@@ -97,10 +97,10 @@ Peers transition from "dumb" to "smart" when they respond with a valid `BlockTxs
 │  ┌────────────────────────────────────────────────────────────────────────┐  │
 │  │  Peer promoted to "smart" - we know exactly what they have             │  │
 │  │                                                                        │  │
-│  │  Request: [blockHash, txIndices (BitVector only)]                      │  │
+│  │  Request: [archiveRoot, txIndices (BitVector only)]                    │  │
 │  │           └─ No need for full hashes, peer has the proposal            │  │
 │  │                                                                        │  │
-│  │  Response: [blockHash, txs[], txIndices (updated availability)]        │  │
+│  │  Response: [archiveRoot, txs[], txIndices (updated availability)]      │  │
 │  │            └─ May have received more txs since last response           │  │
 │  └────────────────────────────────────────────────────────────────────────┘  │
 └──────────────────────────────────────────────────────────────────────────────┘
@@ -152,7 +152,7 @@ The `BatchTxRequester` runs three types of workers concurrently:
 
 ```typescript
 class BlockTxsRequest {
-  blockHash: Fr;           // 32-byte hash of the proposed block header
+  archiveRoot: Fr;         // Archive root after the proposed block is applied
   txHashes: TxHashArray;   // Full tx hashes (for dumb peers without proposal)
   txIndices: BitVector;    // Which txs from proposal we're requesting (1 = want)
 }
@@ -162,7 +162,7 @@ class BlockTxsRequest {
 
 ```typescript
 class BlockTxsResponse {
-  blockHash: Fr;           // Echo back the block hash
+  archiveRoot: Fr;         // Echo back the proposal archive root
   txs: TxArray;            // Actual transaction data
   txIndices: BitVector;    // Which txs the peer has available (1 = have)
 }
@@ -230,8 +230,8 @@ Request to peer fails
 ```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
+  blockTxsSource,       // BlockTxsSource - the proposal or block we need txs for
+  pinnedPeer,           // PeerId | undefined - peer expected to have the txs
   timeoutMs,            // number - how long to try
   p2pService,           // BatchTxRequesterLibP2PService
 );
@@ -268,14 +268,14 @@ const txs = await BatchTxRequester.collectAllTxs(requester.run());
 ┌───────────────────────────────────┐   ┌─────────────────────────────────────┐
 │        FastTxCollection           │   │         SlowTxCollection            │
 │                                   │   │                                     │
-│  Time-critical: attestations      │   │  Background: unproven blocks        │
+│  Time-critical: proposals/proving │   │  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
+                    │ For 'proposal' and 'block' requests
                     ▼
 ┌─────────────────────────────────────────────────────────────────────────────┐
 │                           BatchTxRequester                                  │

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

@@ -4,14 +4,14 @@ import { type Logger, createLogger } from '@aztec/foundation/log';
 import { FifoMemoryQueue, type ISemaphore, Semaphore } from '@aztec/foundation/queue';
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider, executeTimeout } from '@aztec/foundation/timer';
-import { type BlockProposal, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import { Tx, TxArray, TxHash } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 import { peerIdFromString } from '@libp2p/peer-id';
 
 import { ReqRespSubProtocol } from '.././interface.js';
-import { BlockTxsRequest, BlockTxsResponse } from '.././protocols/index.js';
+import { BlockTxsRequest, BlockTxsResponse, type BlockTxsSource } from '.././protocols/index.js';
 import { ReqRespStatus } from '.././status.js';
 import {
   DEFAULT_BATCH_TX_REQUESTER_BAD_PEER_THRESHOLD,
@@ -42,7 +42,7 @@ import { BatchRequestTxValidator, type IBatchRequestTxValidator } from './tx_val
  *    - Is the peer which was unable to send us successful response N times in a row
  * */
 export class BatchTxRequester {
-  private readonly blockProposal: BlockProposal;
+  private readonly blockTxsSource: BlockTxsSource;
   private readonly pinnedPeer: PeerId | undefined;
   private readonly timeoutMs: number;
   private readonly p2pService: BatchTxRequesterLibP2PService;
@@ -61,7 +61,7 @@ export class BatchTxRequester {
 
   constructor(
     missingTxs: TxHash[],
-    blockProposal: BlockProposal,
+    blockTxsSource: BlockTxsSource,
     pinnedPeer: PeerId | undefined,
     timeoutMs: number,
     p2pService: BatchTxRequesterLibP2PService,
@@ -69,7 +69,7 @@ export class BatchTxRequester {
     dateProvider?: DateProvider,
     opts?: BatchTxRequesterOptions,
   ) {
-    this.blockProposal = blockProposal;
+    this.blockTxsSource = blockTxsSource;
     this.pinnedPeer = pinnedPeer;
     this.timeoutMs = timeoutMs;
     this.p2pService = p2pService;
@@ -205,7 +205,7 @@ export class BatchTxRequester {
         return;
       }
 
-      const request = BlockTxsRequest.fromBlockProposalAndMissingTxs(this.blockProposal, txs);
+      const request = BlockTxsRequest.fromTxsSourceAndMissingTxs(this.blockTxsSource, txs);
       if (!request) {
         return;
       }
@@ -249,8 +249,8 @@ export class BatchTxRequester {
       // If peer is dumb peer, we don't know yet if they received full blockProposal
       // there is solid chance that peer didn't receive proposal yet, thus we must send full hashes
       const includeFullHashesInRequestNotJustIndices = true;
-      const blockRequest = BlockTxsRequest.fromBlockProposalAndMissingTxs(
-        this.blockProposal,
+      const blockRequest = BlockTxsRequest.fromTxsSourceAndMissingTxs(
+        this.blockTxsSource,
         txs,
         includeFullHashesInRequestNotJustIndices,
       );
@@ -342,7 +342,7 @@ export class BatchTxRequester {
 
     const makeRequest = (pid: PeerId) => {
       const txs = this.txsMetadata.getTxsToRequestFromThePeer(pid);
-      const blockRequest = BlockTxsRequest.fromBlockProposalAndMissingTxs(this.blockProposal, txs);
+      const blockRequest = BlockTxsRequest.fromTxsSourceAndMissingTxs(this.blockTxsSource, txs);
       if (!blockRequest) {
         return undefined;
       }
@@ -605,9 +605,9 @@ export class BatchTxRequester {
   }
 
   private isBlockResponseValid(response: BlockTxsResponse): boolean {
-    const blockIdsMatch = this.blockProposal.archive.toString() === response.blockHash.toString();
+    const archiveRootsMatch = this.blockTxsSource.archive.toString() === response.archiveRoot.toString();
     const peerHasSomeTxsFromProposal = !response.txIndices.isEmpty();
-    return blockIdsMatch && peerHasSomeTxsFromProposal;
+    return archiveRootsMatch && peerHasSomeTxsFromProposal;
   }
 
   private peerHasSomeTxsWeAreMissing(_peerId: PeerId, response: BlockTxsResponse): boolean {
@@ -624,7 +624,7 @@ export class BatchTxRequester {
   private extractHashesPeerHasFromResponse(response: BlockTxsResponse): Array<TxHash> {
     const hashes: TxHash[] = [];
     const indicesOfHashesPeerHas = new Set(response.txIndices.getTrueIndices());
-    this.blockProposal.txHashes.forEach((hash, idx) => {
+    this.blockTxsSource.txHashes.forEach((hash, idx) => {
       if (indicesOfHashesPeerHas.has(idx)) {
         hashes.push(hash);
       }

package/src/services/reqresp/metrics.ts

@@ -1,7 +1,9 @@
 // Request response metrics
-import { Attributes, Metrics } from '@aztec/telemetry-client';
+import { Attributes, Metrics, createUpDownCounterWithDefault } from '@aztec/telemetry-client';
 import type { TelemetryClient, Tracer, UpDownCounter } from '@aztec/telemetry-client';
 
+import { ReqRespSubProtocol } from './interface.js';
+
 export class ReqRespMetrics {
   public readonly tracer: Tracer;
 
@@ -18,27 +20,50 @@ export class ReqRespMetrics {
     this.tracer = telemetryClient.getTracer(name);
 
     const meter = telemetryClient.getMeter(name);
-    this.sentRequests = meter.createUpDownCounter(Metrics.P2P_REQ_RESP_SENT_REQUESTS);
-    this.receivedRequests = meter.createUpDownCounter(Metrics.P2P_REQ_RESP_RECEIVED_REQUESTS);
+    const protocolAttrs = {
+      [Attributes.P2P_REQ_RESP_PROTOCOL]: [
+        ReqRespSubProtocol.PING,
+        ReqRespSubProtocol.STATUS,
+        ReqRespSubProtocol.GOODBYE,
+        ReqRespSubProtocol.TX,
+        ReqRespSubProtocol.BLOCK,
+        ReqRespSubProtocol.AUTH,
+        ReqRespSubProtocol.BLOCK_TXS,
+      ],
+    };
+    this.sentRequests = createUpDownCounterWithDefault(meter, Metrics.P2P_REQ_RESP_SENT_REQUESTS, protocolAttrs);
+    this.receivedRequests = createUpDownCounterWithDefault(
+      meter,
+      Metrics.P2P_REQ_RESP_RECEIVED_REQUESTS,
+      protocolAttrs,
+    );
 
-    this.failedOutboundRequests = meter.createUpDownCounter(Metrics.P2P_REQ_RESP_FAILED_OUTBOUND_REQUESTS);
+    this.failedOutboundRequests = createUpDownCounterWithDefault(
+      meter,
+      Metrics.P2P_REQ_RESP_FAILED_OUTBOUND_REQUESTS,
+      protocolAttrs,
+    );
 
-    this.failedInboundRequests = meter.createUpDownCounter(Metrics.P2P_REQ_RESP_FAILED_INBOUND_REQUESTS);
+    this.failedInboundRequests = createUpDownCounterWithDefault(
+      meter,
+      Metrics.P2P_REQ_RESP_FAILED_INBOUND_REQUESTS,
+      protocolAttrs,
+    );
   }
 
-  public recordRequestSent(protocol: string) {
+  public recordRequestSent(protocol: ReqRespSubProtocol) {
     this.sentRequests.add(1, { [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol });
   }
 
-  public recordRequestReceived(protocol: string) {
+  public recordRequestReceived(protocol: ReqRespSubProtocol) {
     this.receivedRequests.add(1, { [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol });
   }
 
-  public recordRequestError(protocol: string) {
+  public recordRequestError(protocol: ReqRespSubProtocol) {
     this.failedOutboundRequests.add(1, { [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol });
   }
 
-  public recordResponseError(protocol: string) {
+  public recordResponseError(protocol: ReqRespSubProtocol) {
     this.failedInboundRequests.add(1, { [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol });
   }
 }

package/src/services/reqresp/protocols/block_txs/block_txs_handler.ts

@@ -1,9 +1,10 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
+import type { L2BlockSource } from '@aztec/stdlib/block';
 import { TxArray } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 
-import type { AttestationPool } from '../../../../mem_pools/attestation_pool/attestation_pool.js';
+import type { AttestationPoolApi } from '../../../../mem_pools/attestation_pool/attestation_pool.js';
 import type { TxPool } from '../../../../mem_pools/index.js';
 import type { ReqRespSubProtocolHandler } from '../../interface.js';
 import { ReqRespStatus, ReqRespStatusError } from '../../status.js';
@@ -13,10 +14,15 @@ import { BlockTxsRequest, BlockTxsResponse } from './block_txs_reqresp.js';
 /**
  * Handler for block txs requests
  * @param attestationPool - the attestation pool to check for block proposals
- * @param mempools - the mempools containing the tx pool
+ * @param archiver - the archiver to look up blocks by archive root
+ * @param txPool - the tx pool to fetch transactions from
  * @returns the BlockTxs request handler
  */
-export function reqRespBlockTxsHandler(attestationPool: AttestationPool, txPool: TxPool): ReqRespSubProtocolHandler {
+export function reqRespBlockTxsHandler(
+  attestationPool: AttestationPoolApi,
+  archiver: L2BlockSource,
+  txPool: TxPool,
+): ReqRespSubProtocolHandler {
   /**
    * Handler for block txs requests
    * @param msg - the block txs request message
@@ -30,37 +36,40 @@ export function reqRespBlockTxsHandler(attestationPool: AttestationPool, txPool:
     } catch (err: any) {
       throw new ReqRespStatusError(ReqRespStatus.BADLY_FORMED_REQUEST, { cause: err });
     }
-
-    const blockProposal = await attestationPool.getBlockProposal(request.blockHash.toString());
+    // First try attestation pool, then fall back to archiver
+    let txHashes = (await attestationPool.getBlockProposal(request.archiveRoot.toString()))?.txHashes;
+    if (!txHashes) {
+      txHashes = (await archiver.getL2BlockByArchive(request.archiveRoot))?.body.txEffects.map(effect => effect.txHash);
+    }
 
     let requestedTxsHashes;
     if (request.txHashes.length > 0) {
       requestedTxsHashes = request.txHashes;
     }
 
-    // This is scenario in which we don't have this block proposal the peer is requesting from us
+    // This is scenario in which we don't have this block the peer is requesting from us
     // But peer has sent requested tx hashes, so we can send them the transactions
-    if (!blockProposal && requestedTxsHashes !== undefined) {
+    if (!txHashes && requestedTxsHashes !== undefined) {
       const responseTxs = (await txPool.getTxsByHash(requestedTxsHashes)).filter(tx => !!tx);
       const response = new BlockTxsResponse(Fr.zero(), new TxArray(...responseTxs), BitVector.init(0, []));
       return response.toBuffer();
     }
 
-    // If don't have this block proposal and peer has not sent requested tx hashes
-    if (!blockProposal) {
+    // If we don't have this block and peer has not sent requested tx hashes
+    if (!txHashes) {
       throw new ReqRespStatusError(ReqRespStatus.NOT_FOUND);
     }
 
-    const txsAvailableInPool = await txPool.hasTxs(blockProposal.txHashes);
-    //Map txs in the pool to their indices in the block proposal
+    const txsAvailableInPool = await txPool.hasTxs(txHashes);
+    // Map txs in the pool to their indices in the block
     const availableIndices = txsAvailableInPool.map((hasTx, idx) => (hasTx ? idx : -1)).filter(idx => idx !== -1);
-    const responseBitVector = BitVector.init(blockProposal.txHashes.length, availableIndices);
+    const responseBitVector = BitVector.init(txHashes.length, availableIndices);
 
     const requestedIndices = new Set(request.txIndices.getTrueIndices());
-    requestedTxsHashes = blockProposal.txHashes.filter((_, idx) => requestedIndices.has(idx));
+    requestedTxsHashes = txHashes.filter((_, idx) => requestedIndices.has(idx));
 
     const responseTxs = (await txPool.getTxsByHash(requestedTxsHashes)).filter(tx => !!tx);
-    const response = new BlockTxsResponse(request.blockHash, new TxArray(...responseTxs), responseBitVector);
+    const response = new BlockTxsResponse(request.archiveRoot, new TxArray(...responseTxs), responseBitVector);
 
     return response.toBuffer();
   };

package/src/services/reqresp/protocols/block_txs/block_txs_reqresp.ts

@@ -1,17 +1,22 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import type { BlockProposal } from '@aztec/stdlib/p2p';
-import { TxArray, TxHash, TxHashArray } from '@aztec/stdlib/tx';
+import { TxArray, type TxHash, TxHashArray } from '@aztec/stdlib/tx';
 
 import { BitVector } from './bitvector.js';
 
+/** Minimal interface for a block source that provides tx hashes and an archive root. */
+export interface BlockTxsSource {
+  txHashes: TxHash[];
+  archive: Fr;
+}
+
 /**
  * Request message for requesting specific transactions from a block
  */
 export class BlockTxsRequest {
   constructor(
-    // 32 byte hash of the proposed block header
-    readonly blockHash: Fr,
+    // Archive root after the proposed block is applied (proposal identifier)
+    readonly archiveRoot: Fr,
     // Hashes of txs we are requesting
     readonly txHashes: TxHashArray,
     // BitVector indicating which txs from the proposal we are requesting
@@ -22,16 +27,17 @@ export class BlockTxsRequest {
   ) {}
 
   /**
-   * Crates new BlockTxsRequest given proposal and missing tx hashes
+   * Creates new BlockTxsRequest given a block txs source and missing tx hashes.
    *
-   * @param: blockProposal - The block proposal for which we are making request
-   * @param: missingTxHashes - Tx hashes from the proposal we are missing
-   * @param: includeFullTxHashes - Whether to include full list of missing tx hashes in the request or just Bitvector indices
+   * @param blockTxsSource - The block or proposal for which we are making the request
+   * @param missingTxHashes - Tx hashes from the source we are missing
+   * @param includeFullTxHashes - Whether to include full list of missing tx hashes in the request or just Bitvector indices
    *
-   * @returns undefined if there were no missingTxHashes matching BlockProposal hashes, otherwise
-   * returns new BlockTxsRequest*/
-  static fromBlockProposalAndMissingTxs(
-    blockProposal: BlockProposal,
+   * @returns undefined if there were no missingTxHashes matching the source hashes, otherwise
+   * returns new BlockTxsRequest
+   */
+  static fromTxsSourceAndMissingTxs(
+    blockTxsSource: BlockTxsSource,
     missingTxHashes: TxHash[],
     includeFullTxHashes = false,
   ): BlockTxsRequest | undefined {
@@ -41,19 +47,19 @@ export class BlockTxsRequest {
 
     const missingHashesSet = new Set(missingTxHashes.map(t => t.toString()));
 
-    // We cannot request txs that are not part of the block proposal
-    if (!missingHashesSet.isSubsetOf(new Set(blockProposal.txHashes.map(t => t.toString())))) {
+    // We cannot request txs that are not part of the block
+    if (!missingHashesSet.isSubsetOf(new Set(blockTxsSource.txHashes.map(t => t.toString())))) {
       return undefined;
     }
 
-    const missingIndices = blockProposal.txHashes
+    const missingIndices = blockTxsSource.txHashes
       .map((hash, idx) => (missingHashesSet.has(hash.toString()) ? idx : -1))
       .filter(i => i != -1);
 
-    const requestBitVector = BitVector.init(blockProposal.txHashes.length, missingIndices);
+    const requestBitVector = BitVector.init(blockTxsSource.txHashes.length, missingIndices);
     const hashes = includeFullTxHashes ? new TxHashArray(...missingTxHashes) : new TxHashArray();
 
-    return new BlockTxsRequest(blockProposal.archive, hashes, requestBitVector);
+    return new BlockTxsRequest(blockTxsSource.archive, hashes, requestBitVector);
   }
 
   /**
@@ -63,11 +69,11 @@ export class BlockTxsRequest {
    */
   static fromBuffer(buffer: Buffer | BufferReader): BlockTxsRequest {
     const reader = BufferReader.asReader(buffer);
-    const blockHash = Fr.fromBuffer(reader);
+    const archiveRoot = Fr.fromBuffer(reader);
     const txHashes = TxHashArray.fromBuffer(reader);
     const txIndices = BitVector.fromBuffer(reader);
 
-    return new BlockTxsRequest(blockHash, txHashes, txIndices);
+    return new BlockTxsRequest(archiveRoot, txHashes, txIndices);
   }
 
   /**
@@ -75,7 +81,7 @@ export class BlockTxsRequest {
    * @returns Buffer representation of the BlockTxRequest object
    */
   toBuffer(): Buffer {
-    return serializeToBuffer([this.blockHash, this.txHashes.toBuffer(), this.txIndices.toBuffer()]);
+    return serializeToBuffer([this.archiveRoot, this.txHashes.toBuffer(), this.txIndices.toBuffer()]);
   }
 }
 
@@ -84,7 +90,7 @@ export class BlockTxsRequest {
  */
 export class BlockTxsResponse {
   constructor(
-    readonly blockHash: Fr,
+    readonly archiveRoot: Fr,
     readonly txs: TxArray, // List of transactions we requested and peer has
     // BitVector indicating which txs from the proposal are available at the peer
     // 1 means the tx is available, 0 means it is not
@@ -98,11 +104,11 @@ export class BlockTxsResponse {
    */
   static fromBuffer(buffer: Buffer | BufferReader): BlockTxsResponse {
     const reader = BufferReader.asReader(buffer);
-    const blockHash = Fr.fromBuffer(reader);
+    const archiveRoot = Fr.fromBuffer(reader);
     const txs = TxArray.fromBuffer(reader);
     const txIndices = BitVector.fromBuffer(reader);
 
-    return new BlockTxsResponse(blockHash, txs, txIndices);
+    return new BlockTxsResponse(archiveRoot, txs, txIndices);
   }
 
   /**
@@ -112,7 +118,7 @@ export class BlockTxsResponse {
    * @returns Buffer representation of the BlockTxResponse object
    */
   toBuffer(): Buffer {
-    return serializeToBuffer([this.blockHash, this.txs.toBuffer(), this.txIndices.toBuffer()]);
+    return serializeToBuffer([this.archiveRoot, this.txs.toBuffer(), this.txIndices.toBuffer()]);
   }
 
   static empty(): BlockTxsResponse {

package/src/services/service.ts

@@ -1,3 +1,4 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
 import type { BlockProposal, CheckpointAttestation, CheckpointProposalCore, Gossipable } from '@aztec/stdlib/p2p';
@@ -43,6 +44,19 @@ export type P2PCheckpointReceivedCallback = (
 
 export type AuthReceivedCallback = (peerId: PeerId, authRequest: AuthRequest) => Promise<AuthResponse | undefined>;
 
+/** Minimal info passed to the duplicate proposal callback. */
+export type DuplicateProposalInfo = {
+  slot: SlotNumber;
+  proposer: EthAddress;
+  type: 'checkpoint' | 'block';
+};
+
+/**
+ * Callback for when a duplicate proposal is detected (equivocation).
+ * Invoked on the first duplicate (when count goes from 1 to 2).
+ */
+export type P2PDuplicateProposalCallback = (info: DuplicateProposalInfo) => void;
+
 /**
  * The interface for a P2P service implementation.
  */
@@ -86,6 +100,12 @@ export interface P2PService {
 
   registerCheckpointReceivedCallback(callback: P2PCheckpointReceivedCallback): void;
 
+  /**
+   * Registers a callback invoked when a duplicate proposal is detected (equivocation).
+   * The callback is triggered on the first duplicate (when count goes from 1 to 2).
+   */
+  registerDuplicateProposalCallback(callback: P2PDuplicateProposalCallback): void;
+
   getEnr(): ENR | undefined;
 
   getPeers(includePending?: boolean): PeerInfo[];

package/src/services/tx_collection/config.ts

@@ -6,7 +6,7 @@ import {
 } from '@aztec/foundation/config';
 import { MAX_RPC_TXS_LEN } from '@aztec/stdlib/interfaces/api-limit';
 
-export type ProposalTxCollectorType = 'new' | 'old';
+export type MissingTxsCollectorType = 'new' | 'old';
 
 export type TxCollectionConfig = {
   /** How long to wait before starting reqresp for fast collection  */
@@ -29,8 +29,8 @@ export type TxCollectionConfig = {
   txCollectionFastMaxParallelRequestsPerNode: number;
   /** Maximum number of transactions to request from a node in a single batch */
   txCollectionNodeRpcMaxBatchSize: number;
-  /** Which collector implementation to use for proposal tx collection */
-  txCollectionProposalTxCollectorType: ProposalTxCollectorType;
+  /** Which collector implementation to use for missing txs collection */
+  txCollectionMissingTxsCollectorType: MissingTxsCollectorType;
 };
 
 export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig> = {
@@ -90,9 +90,9 @@ export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig>
     description: 'Maximum number of transactions to request from a node in a single batch',
     ...numberConfigHelper(MAX_RPC_TXS_LEN),
   },
-  txCollectionProposalTxCollectorType: {
-    env: 'TX_COLLECTION_PROPOSAL_TX_COLLECTOR_TYPE',
-    description: 'Which collector implementation to use for proposal tx collection (new or old)',
+  txCollectionMissingTxsCollectorType: {
+    env: 'TX_COLLECTION_MISSING_TXS_COLLECTOR_TYPE',
+    description: 'Which collector implementation to use for missing txs collection (new or old)',
     ...enumConfigHelper(['new', 'old'] as const, 'new'),
   },
 };