@aztec/p2p 1.2.1 → 2.0.0-nightly.20250813

package/src/services/reqresp/config.ts

@@ -1,8 +1,8 @@
 import { type ConfigMapping, booleanConfigHelper, numberConfigHelper } from '@aztec/foundation/config';
 
-export const DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS = 2000;
-export const DEFAULT_OVERALL_REQUEST_TIMEOUT_MS = 4000;
-export const DEFAULT_REQRESP_DIAL_TIMEOUT_MS = 1000;
+export const DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS = 10_000;
+export const DEFAULT_OVERALL_REQUEST_TIMEOUT_MS = 10_000; // Not currently used
+export const DEFAULT_REQRESP_DIAL_TIMEOUT_MS = 5_000;
 export const DEFAULT_OPTIMISTIC_NEGOTIATION = false;
 
 // For use in tests.

package/src/services/reqresp/connection-sampler/connection_sampler.ts

@@ -1,6 +1,5 @@
-import { AbortError, TimeoutError } from '@aztec/foundation/error';
+import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
-import { SerialQueue } from '@aztec/foundation/queue';
 
 import type { Libp2p, PeerId, Stream } from '@libp2p/interface';
 
@@ -21,13 +20,14 @@ export class RandomSampler {
  */
 export class ConnectionSampler {
   private cleanupInterval: NodeJS.Timeout;
-  private dialAttempts: AbortController[] = [];
 
-  private readonly activeConnectionsCount: Map<PeerId, number> = new Map();
-  private readonly streams: Set<Stream> = new Set();
+  // Map from stringified peer id to number of active connections
+  protected readonly activeConnectionsCount: Map<string, number> = new Map();
 
-  // Serial queue to ensure that we only dial one peer at a time
-  private dialQueue: SerialQueue = new SerialQueue();
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+  protected readonly streams: Set<Stream> = new Set();
+
+  private abortOnStop: AbortController = new AbortController();
 
   constructor(
     private readonly libp2p: Libp2p,
@@ -39,8 +39,6 @@ export class ConnectionSampler {
       () => void this.cleanupStaleConnections(),
       this.opts.cleanupIntervalMs ?? 60_000,
     );
-
-    this.dialQueue.start();
   }
 
   /**
@@ -48,14 +46,9 @@ export class ConnectionSampler {
    */
   async stop() {
     this.logger.info('Stopping connection sampler');
+    this.abortOnStop.abort(new AbortError('Connection sampler stopped'));
     clearInterval(this.cleanupInterval);
 
-    for (const attempt of this.dialAttempts) {
-      attempt.abort(new AbortError('Connection sampler stopped'));
-    }
-    this.dialAttempts = [];
-    await this.dialQueue.end();
-
     // Close all active streams
     const closePromises = Array.from(this.streams.values()).map(stream => this.close(stream));
     await Promise.all(closePromises);
@@ -103,7 +96,7 @@ export class ConnectionSampler {
     for (let attempts = 0; attempts < MAX_SAMPLE_ATTEMPTS && peers.length > 0; attempts++) {
       const randomIndex = this.sampler.random(peers.length);
       const peer = peers[randomIndex];
-      const hasActiveConnections = (this.activeConnectionsCount.get(peer) ?? 0) > 0;
+      const hasActiveConnections = (this.activeConnectionsCount.get(peer.toString()) ?? 0) > 0;
       const isExcluded = excluding?.get(peer.toString()) ?? false;
 
       // Remove this peer from consideration
@@ -147,6 +140,7 @@ export class ConnectionSampler {
     numberToSample = Math.min(numberToSample, peers.length);
 
     const batch: PeerId[] = [];
+    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
     const withActiveConnections: Set<PeerId> = new Set();
     for (let i = 0; i < numberToSample; i++) {
       const { peer, sampledPeers } = this.getPeerFromList(peers, excluding);
@@ -189,54 +183,33 @@ export class ConnectionSampler {
    * @returns The stream
    */
   async dialProtocol(peerId: PeerId, protocol: string, timeout?: number): Promise<Stream> {
-    // Dialling at the same time can cause race conditions where two different streams
-    // end up with the same id, hence a serial queue
-    this.logger.debug(`Dial queue length: ${this.dialQueue.length()}`);
-
-    const abortController = new AbortController();
-    this.dialAttempts.push(abortController);
-    let timeoutHandle: NodeJS.Timeout | undefined;
-    if (timeout) {
-      timeoutHandle = setTimeout(() => abortController.abort(new TimeoutError('Dial protocol timeout')), timeout);
-    }
-
-    try {
-      const stream = await this.dialQueue.put(() =>
-        this.libp2p.dialProtocol(peerId, protocol, {
-          signal: abortController.signal,
-          negotiateFully: !this.opts.p2pOptimisticNegotiation,
-        }),
-      );
-      stream.metadata.peerId = peerId;
-      this.streams.add(stream);
-
-      const updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerId) ?? 0) + 1;
-      this.activeConnectionsCount.set(peerId, updatedActiveConnectionsCount);
-
-      this.logger.trace('Dialed protocol', {
-        streamId: stream.id,
-        protocol,
-        peerId: peerId.toString(),
-        activeConnectionsCount: updatedActiveConnectionsCount,
-      });
-      return stream;
-    } finally {
-      if (timeoutHandle) {
-        clearTimeout(timeoutHandle);
-      }
-
-      const idx = this.dialAttempts.indexOf(abortController);
-      if (idx > -1) {
-        this.dialAttempts.splice(idx, 1);
-      }
-    }
+    const stream = await this.libp2p.dialProtocol(peerId, protocol, {
+      signal: AbortSignal.any(
+        timeout ? [this.abortOnStop.signal, AbortSignal.timeout(timeout!)] : [this.abortOnStop.signal],
+      ),
+      negotiateFully: !this.opts.p2pOptimisticNegotiation,
+    });
+    stream.metadata.peerId = peerId;
+    this.streams.add(stream);
+
+    const peerIdString = peerId.toString();
+    const updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerIdString) ?? 0) + 1;
+    this.activeConnectionsCount.set(peerIdString, updatedActiveConnectionsCount);
+
+    this.logger.trace('Dialed protocol', {
+      streamId: stream.id,
+      protocol,
+      peerId: peerIdString,
+      activeConnectionsCount: updatedActiveConnectionsCount,
+    });
+    return stream;
   }
 
   /**
    * Closes a stream and updates the active connections count
    */
   async close(stream: Stream): Promise<void> {
-    let peerId = undefined;
+    let peerId: PeerId | undefined = undefined;
 
     try {
       peerId = stream.metadata.peerId;
@@ -245,13 +218,13 @@ export class ConnectionSampler {
       if (!peerId) {
         this.logger.warn(`Stream ${stream.id} does not have a peerId set`);
       } else {
-        updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerId) ?? 1) - 1;
-        this.activeConnectionsCount.set(peerId, updatedActiveConnectionsCount);
+        updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerId.toString()) ?? 1) - 1;
+        this.activeConnectionsCount.set(peerId.toString(), updatedActiveConnectionsCount);
       }
 
       this.logger.trace('Closing connection', {
         streamId: stream.id,
-        peerId: peerId.toString(),
+        peerId: peerId?.toString(),
         protocol: stream.protocol,
         activeConnectionsCount: updatedActiveConnectionsCount,
       });
@@ -263,6 +236,8 @@ export class ConnectionSampler {
       await stream.close();
     } catch (error) {
       this.logger.error(`Failed to close connection to peer ${peerId ?? 'unknown'} with stream id ${stream.id}`, error);
+      // graceful close failed, abort the stream
+      stream.abort(new AbortError('Failed to close stream gracefully'));
     } finally {
       this.streams.delete(stream);
     }
@@ -277,10 +252,10 @@ export class ConnectionSampler {
     for (const stream of this.streams.values()) {
       try {
         // Check if we have lost track of accounting
-        const peerId = stream.metadata.peerId;
+        const peerId: PeerId = stream.metadata.peerId;
         if (!peerId) {
           this.logger.warn(`Stream ${stream.id} does not have a peerId set`);
-        } else if (this.activeConnectionsCount.get(peerId) === 0) {
+        } else if (this.activeConnectionsCount.get(peerId.toString()) === 0) {
           await this.close(stream);
           this.logger.debug('Cleaned up stale connection', { streamId: stream.id, peerId: peerId.toString() });
         }

package/src/services/reqresp/index.ts

@@ -2,3 +2,5 @@
  * Request Response protocol allows nodes to ask their peers for data
  * that they missed via the traditional gossip protocol.
  */
+export * from './protocols/index.js';
+export * from './interface.js';

package/src/services/reqresp/interface.ts

@@ -1,10 +1,12 @@
 import { Fr } from '@aztec/foundation/fields';
 import { L2Block } from '@aztec/stdlib/block';
-import { Tx, TxHash } from '@aztec/stdlib/tx';
+import { TxArray, TxHashArray } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 
 import type { P2PReqRespConfig } from './config.js';
+import { AuthRequest, AuthResponse } from './protocols/auth.js';
+import { BlockTxsRequest, BlockTxsResponse } from './protocols/block_txs/block_txs_reqresp.js';
 import { StatusMessage } from './protocols/status.js';
 import type { ReqRespStatus } from './status.js';
 
@@ -16,6 +18,8 @@ export const STATUS_PROTOCOL = '/aztec/req/status/0.1.0';
 export const GOODBYE_PROTOCOL = '/aztec/req/goodbye/0.1.0';
 export const TX_REQ_PROTOCOL = '/aztec/req/tx/0.1.0';
 export const BLOCK_REQ_PROTOCOL = '/aztec/req/block/0.1.0';
+export const AUTH_PROTOCOL = '/aztec/req/auth/0.1.0';
+export const BLOCK_TXS_REQ_PROTOCOL = '/aztec/req/block_txs/0.1.0';
 
 export enum ReqRespSubProtocol {
   PING = PING_PROTOCOL,
@@ -23,6 +27,8 @@ export enum ReqRespSubProtocol {
   GOODBYE = GOODBYE_PROTOCOL,
   TX = TX_REQ_PROTOCOL,
   BLOCK = BLOCK_REQ_PROTOCOL,
+  AUTH = AUTH_PROTOCOL,
+  BLOCK_TXS = BLOCK_TXS_REQ_PROTOCOL,
 }
 
 /**
@@ -38,12 +44,12 @@ export type ReqRespSubProtocolRateLimits = Record<ReqRespSubProtocol, ProtocolRa
 
 /**
  * The response from the ReqResp protocol
- * Consists of a status (Error code) and data
+ * Consists of a status
+ * And, optionally, a data buffer (in case status is SUCCESS)
  */
-export interface ReqRespResponse {
-  status: ReqRespStatus;
-  data: Buffer;
-}
+export type ReqRespResponse =
+  | { status: ReqRespStatus.SUCCESS; data: Buffer }
+  | { status: Exclude<ReqRespStatus, ReqRespStatus.SUCCESS> };
 
 /**
  * A rate limit quota
@@ -93,21 +99,34 @@ export const DEFAULT_SUB_PROTOCOL_VALIDATORS: ReqRespSubProtocolValidators = {
   [ReqRespSubProtocol.TX]: noopValidator,
   [ReqRespSubProtocol.GOODBYE]: noopValidator,
   [ReqRespSubProtocol.BLOCK]: noopValidator,
+  [ReqRespSubProtocol.AUTH]: noopValidator,
+  [ReqRespSubProtocol.BLOCK_TXS]: noopValidator,
 };
 
+/*
+ * Helper class to sub-protocol validation error*/
+export class ValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+}
+
 /**
  * Sub protocol map determines the request and response types for each
  * Req Resp protocol
  */
 export type SubProtocolMap = {
-  [S in ReqRespSubProtocol]: RequestResponsePair<any, any>;
+  [S in ReqRespSubProtocol]: RequestResponsePair<
+    InstanceType<(typeof subProtocolMap)[S]['request']>,
+    InstanceType<(typeof subProtocolMap)[S]['response']>
+  >;
 };
 
 /**
  * Default handler for unimplemented sub protocols, this SHOULD be overwritten
  * by the service, but is provided as a fallback
  */
-const defaultHandler = (_msg: any): Promise<Buffer> => {
+export const defaultHandler = (_msg: any): Promise<Buffer> => {
   return Promise.resolve(Buffer.from('unimplemented'));
 };
 
@@ -120,6 +139,8 @@ export const DEFAULT_SUB_PROTOCOL_HANDLERS: ReqRespSubProtocolHandlers = {
   [ReqRespSubProtocol.TX]: defaultHandler,
   [ReqRespSubProtocol.GOODBYE]: defaultHandler,
   [ReqRespSubProtocol.BLOCK]: defaultHandler,
+  [ReqRespSubProtocol.AUTH]: defaultHandler,
+  [ReqRespSubProtocol.BLOCK_TXS]: defaultHandler,
 };
 
 /**
@@ -140,6 +161,22 @@ interface RequestResponsePair<Req extends { toBuffer(): Buffer }, Res> {
   };
 }
 
+/*
+ * Small helper function which parses buffer into specific response type
+ * It is needed to make TypeScript happy, as it cannot infer the type from the buffer
+ *
+ * @param proto - The sub protocol to parse the response for
+ * @param buffer - The buffer to parse
+ *
+ * @returns - The parsed response object
+ * */
+export function responseFromBuffer<P extends ReqRespSubProtocol>(
+  proto: P,
+  buffer: Buffer,
+): InstanceType<(typeof subProtocolMap)[P]['response']> {
+  return subProtocolMap[proto].response.fromBuffer(buffer) as InstanceType<(typeof subProtocolMap)[P]['response']>;
+}
+
 /**
  * RequestableBuffer is a wrapper around a buffer that allows it to be
  * used in generic request response protocols
@@ -163,7 +200,7 @@ export class RequestableBuffer {
  * This defines the request and response types for each sub protocol, used primarily
  * as a type rather than an object
  */
-export const subProtocolMap: SubProtocolMap = {
+export const subProtocolMap = {
   [ReqRespSubProtocol.PING]: {
     request: RequestableBuffer,
     response: RequestableBuffer,
@@ -173,8 +210,8 @@ export const subProtocolMap: SubProtocolMap = {
     response: StatusMessage,
   },
   [ReqRespSubProtocol.TX]: {
-    request: TxHash,
-    response: Tx,
+    request: TxHashArray,
+    response: TxArray,
   },
   [ReqRespSubProtocol.GOODBYE]: {
     request: RequestableBuffer,
@@ -184,18 +221,27 @@ export const subProtocolMap: SubProtocolMap = {
     request: Fr, // block number
     response: L2Block,
   },
+  [ReqRespSubProtocol.AUTH]: {
+    request: AuthRequest,
+    response: AuthResponse,
+  },
+  [ReqRespSubProtocol.BLOCK_TXS]: {
+    request: BlockTxsRequest,
+    response: BlockTxsResponse,
+  },
 };
 
 export interface ReqRespInterface {
   start(
-    subProtocolHandlers: ReqRespSubProtocolHandlers,
+    subProtocolHandlers: Partial<ReqRespSubProtocolHandlers>,
     subProtocolValidators: ReqRespSubProtocolValidators,
   ): Promise<void>;
+  addSubProtocol(
+    subProtocol: ReqRespSubProtocol,
+    handler: ReqRespSubProtocolHandler,
+    validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol],
+  ): Promise<void>;
   stop(): Promise<void>;
-  sendRequest<SubProtocol extends ReqRespSubProtocol>(
-    subProtocol: SubProtocol,
-    request: InstanceType<SubProtocolMap[SubProtocol]['request']>,
-  ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined>;
   sendBatchRequest<SubProtocol extends ReqRespSubProtocol>(
     subProtocol: SubProtocol,
     requests: InstanceType<SubProtocolMap[SubProtocol]['request']>[],
@@ -203,7 +249,7 @@ export interface ReqRespInterface {
     timeoutMs?: number,
     maxPeers?: number,
     maxRetryAttempts?: number,
-  ): Promise<(InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined)[]>;
+  ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']>[]>;
   sendRequestToPeer(
     peerId: PeerId,
     subProtocol: ReqRespSubProtocol,

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

@@ -0,0 +1,83 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { keccak256 } from '@aztec/foundation/crypto';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { StatusMessage } from './status.js';
+
+export const VALIDATOR_AUTH_DOMAIN_SEPARATOR = 'Aztec Validator Challenge:';
+export const VALIDATOR_AUTH_FULL_CHALLENGE_ENCODED_LENGTH =
+  VALIDATOR_AUTH_DOMAIN_SEPARATOR.length + Fr.random().toString().length;
+
+/*
+ * P2P Auth Message
+ * Superset of the StatusMessage, used to establish a handshake between peers and authenticate them.
+ */
+export class AuthRequest {
+  constructor(
+    readonly status: StatusMessage,
+    readonly challenge: Fr,
+  ) {}
+
+  /**
+   * Deserializes the AuthRequest object from a Buffer.
+   * @param buffer - Buffer or BufferReader object to deserialize.
+   * @returns An instance of StatusMessage.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): AuthRequest {
+    const reader = BufferReader.asReader(buffer);
+    return new AuthRequest(
+      StatusMessage.fromBuffer(reader), // Deserialize StatusMessage
+      Fr.fromBuffer(reader), // challenge
+    );
+  }
+
+  /**
+   * Serializes the AuthRequest object into a Buffer.
+   * @returns Buffer representation of the StatusMessage object.
+   */
+  toBuffer() {
+    return serializeToBuffer([this.status, this.challenge]);
+  }
+
+  getPayloadToSign(): Buffer32 {
+    const fullChallenge = VALIDATOR_AUTH_DOMAIN_SEPARATOR + this.challenge.toString();
+    return Buffer32.fromBuffer(keccak256(Buffer.from(fullChallenge, 'utf-8')));
+  }
+
+  static random(): AuthRequest {
+    return new AuthRequest(StatusMessage.random(), Fr.random());
+  }
+}
+
+export class AuthResponse {
+  constructor(
+    readonly status: StatusMessage,
+    readonly signature: Signature,
+  ) {}
+  /**
+   * Deserializes the AuthResponse object from a Buffer.
+   * @param buffer - Buffer or BufferReader object to deserialize.
+   * @returns An instance of StatusMessage.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): AuthResponse {
+    const reader = BufferReader.asReader(buffer);
+    return new AuthResponse(
+      StatusMessage.fromBuffer(reader), // Deserialize StatusMessage
+      Signature.fromBuffer(reader), // response
+    );
+  }
+
+  /**
+   * Serializes the AuthRequest object into a Buffer.
+   * @returns Buffer representation of the StatusMessage object.
+   */
+  toBuffer() {
+    return serializeToBuffer([this.status, this.signature]);
+  }
+
+  static random(): AuthResponse {
+    return new AuthResponse(StatusMessage.random(), Signature.random());
+  }
+}

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

@@ -4,12 +4,33 @@ 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) => {
-    const blockNumber = Fr.fromBuffer(msg);
+    let blockNumber: Fr;
+    try {
+      blockNumber = Fr.fromBuffer(msg);
+    } catch (err: any) {
+      throw new ReqRespStatusError(ReqRespStatus.BADLY_FORMED_REQUEST, { cause: err });
+    }
 
-    const foundBlock = await l2BlockSource.getBlock(Number(blockNumber));
-    return foundBlock ? foundBlock.toBuffer() : Buffer.alloc(0);
+    try {
+      const foundBlock = await l2BlockSource.getBlock(Number(blockNumber));
+      return foundBlock ? foundBlock.toBuffer() : Buffer.alloc(0);
+    } catch (err: any) {
+      throw new ReqRespStatusError(ReqRespStatus.INTERNAL_ERROR, { cause: err });
+    }
   };
 }

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

@@ -0,0 +1,90 @@
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+/**
+ * BitVector helper class for representing and serializing bit vectors
+ */
+export class BitVector {
+  private buffer: Buffer;
+  private length: number;
+
+  constructor(buffer: Buffer, length: number) {
+    this.buffer = buffer;
+    this.length = length;
+  }
+
+  /*
+   * Creates new BitVector instance
+   * @param length - Length of the bit vector
+   * @param indices - Array of indices to set to 1 in the bit vector
+   *
+   * @returns A new BitVector instance with specified length and set indices
+   * */
+  static init(length: number, indices: number[]): BitVector {
+    if (indices.length > length) {
+      throw new Error('Indices length exceeds specified length');
+    }
+
+    const buffer = Buffer.alloc(BitVector.byteLength(length));
+
+    indices.forEach(idx => {
+      const invalidIndex = idx < 0 || idx >= length;
+      if (invalidIndex) {
+        throw new Error(`Index ${idx} is out of bounds for BitVector of length ${length}`);
+      }
+
+      const byteIndex = Math.floor(idx / 8);
+      const bitIndex = idx % 8;
+      buffer[byteIndex] |= 1 << bitIndex;
+    });
+
+    return new BitVector(buffer, length);
+  }
+
+  getLength(): number {
+    return this.length;
+  }
+
+  /*
+   * Checks if element at index is set to true
+   *
+   * @param index - Index of the bit to check
+   *
+   * @returns True if the bit at index is set, false otherwise
+   * */
+  isSet(index: number): boolean {
+    return index >= 0 && index < this.length && !!(this.buffer[Math.floor(index / 8)] & (1 << index % 8));
+  }
+
+  /**
+   * Returns all indices which are set to true
+   * */
+  getTrueIndices(): number[] {
+    return Array.from({ length: this.length }, (_, i) => i).filter(i => this.isSet(i));
+  }
+
+  /**
+   * Serializes the BitVector object into a Buffer
+   *
+   * @returns Buffer representation of the BitVector object
+   * */
+  toBuffer(): Buffer {
+    return serializeToBuffer([this.length, this.buffer]);
+  }
+
+  /**
+   * Deserializes buffer into new BitVector
+   *
+   * @returns A new BitVector instance
+   * */
+  static fromBuffer(buffer: Buffer | BufferReader): BitVector {
+    const reader = BufferReader.asReader(buffer);
+    const length = reader.readNumber();
+
+    const bitBuffer = reader.readBytes(BitVector.byteLength(length));
+    return new BitVector(bitBuffer, length);
+  }
+
+  static byteLength(length: number) {
+    return Math.ceil(length / 8);
+  }
+}

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

@@ -0,0 +1,53 @@
+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 { TxPool } from '../../../../mem_pools/index.js';
+import type { ReqRespSubProtocolHandler } from '../../interface.js';
+import { ReqRespStatus, ReqRespStatusError } from '../../status.js';
+import { BitVector } from './bitvector.js';
+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
+ * @returns the BlockTxs request handler
+ */
+export function reqRespBlockTxsHandler(attestationPool: AttestationPool, txPool: TxPool): ReqRespSubProtocolHandler {
+  /**
+   * Handler for block txs requests
+   * @param msg - the block txs request message
+   * @returns the block txs response message
+   * @throws if msg is not a valid block txs request
+   */
+  return async (_peerId: PeerId, msg: Buffer) => {
+    let request: BlockTxsRequest;
+    try {
+      request = BlockTxsRequest.fromBuffer(msg);
+    } catch (err: any) {
+      throw new ReqRespStatusError(ReqRespStatus.BADLY_FORMED_REQUEST, { cause: err });
+    }
+
+    const blockProposal = await attestationPool.getBlockProposal(request.blockHash.toString());
+
+    if (!blockProposal) {
+      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 availableIndices = txsAvailableInPool.map((hasTx, idx) => (hasTx ? idx : -1)).filter(idx => idx !== -1);
+    const responseBitVector = BitVector.init(blockProposal.txHashes.length, availableIndices);
+
+    const requestedIndices = new Set(request.txIndices.getTrueIndices());
+    const requestedTxsHashes = blockProposal.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);
+
+    return response.toBuffer();
+  };
+}