@aztec-labs/p2p 6.0.0-nightly.20260829

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

@@ -0,0 +1,107 @@
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+
+import { MAX_TXS_PER_BLOCK } from '../../constants.js';
+
+/**
+ * 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.
+   * Ordered by index. No duplicates.
+   */
+  getTrueIndices(): number[] {
+    return Array.from({ length: this.length }, (_, i) => i).filter(i => this.isSet(i));
+  }
+
+  /**
+   * Returns true if no indices are set to true
+   * */
+  isEmpty(): boolean {
+    return this.getTrueIndices().length === 0;
+  }
+
+  /**
+   * 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();
+
+    if (length < 0) {
+      throw new Error(`BitVector length ${length} cannot be negative`);
+    }
+    if (length > MAX_TXS_PER_BLOCK) {
+      throw new Error(`BitVector length ${length} exceeds maximum ${MAX_TXS_PER_BLOCK}`);
+    }
+
+    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,79 @@
+import type { L2BlockSource } from '@aztec-labs/stdlib/block';
+import { TxArray, TxHash } from '@aztec-labs/stdlib/tx';
+import type { PeerId } from '@libp2p/interface';
+
+import type { AttestationPoolApi } from '../../../../mem_pools/attestation_pool/attestation_pool.js';
+import type { TxPoolV2 } from '../../../../mem_pools/tx_pool_v2/interfaces.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 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: AttestationPoolApi,
+  archiver: L2BlockSource,
+  txPool: TxPoolV2,
+): 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 });
+    }
+
+    // In principle assume we haven't found the block. This is how that is signaled to the requester.
+    let availableIndicesBitVector: BitVector = BitVector.init(0, []);
+    // We always try to service the explicitly requested tx hashes, even if we don't have the block.
+    const requestedTxsHashes: Set<string> = new Set(request.txHashes.map(h => h.toString()));
+
+    // First try attestation pool, then fall back to archiver.
+    let blockTxHashes = (await attestationPool.getBlockProposalByArchive(request.archiveRoot.toString()))?.txHashes;
+    if (!blockTxHashes) {
+      blockTxHashes = (await archiver.getBlock({ archive: request.archiveRoot }))?.body.txEffects.map(
+        effect => effect.txHash,
+      );
+    }
+
+    // If we have found the block,
+    if (blockTxHashes) {
+      // First confirm that we are talking about the same block (up to tx hashes and order).
+      // If we are not, then we can't:
+      // 1. Use the indices from the request to get the txs from the pool.
+      // 2. Respond to the peer with the txs we have using indices.
+      const blockTxHashesCommitment = BlockTxsRequest.computeBlockTxHashesCommitment(blockTxHashes);
+      if (blockTxHashesCommitment.equals(request.blockTxHashesCommitment)) {
+        // In that case, we can also get the available indices from the pool.
+        const txsAvailableInPool = await txPool.hasTxs(blockTxHashes);
+        // Map txs in the pool to their indices in the block
+        const availableIndices = txsAvailableInPool.map((hasTx, idx) => (hasTx ? idx : -1)).filter(idx => idx !== -1);
+        availableIndicesBitVector = BitVector.init(blockTxHashes.length, availableIndices);
+
+        // We add the requested tx hashes (by index) to the list of tx hashes we are sending to the peer.
+        const requestedIndices = new Set(request.txIndices.getTrueIndices());
+        blockTxHashes.filter((_, idx) => requestedIndices.has(idx)).forEach(h => requestedTxsHashes.add(h.toString()));
+      }
+    }
+
+    // Finally, get the txs from the pool and create the response.
+    const responseTxs = (
+      await txPool.getTxsByHash(Array.from(requestedTxsHashes).map(h => TxHash.fromString(h)))
+    ).filter(tx => !!tx);
+    const response = new BlockTxsResponse(new TxArray(...responseTxs), availableIndicesBitVector);
+
+    return response.toBuffer();
+  };
+}

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

@@ -0,0 +1,170 @@
+import { Buffer32 } from '@aztec-labs/foundation/buffer';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { MAX_TX_SIZE_KB } from '@aztec-labs/stdlib/p2p';
+import { TxArray, type TxHash, TxHashArray } from '@aztec-labs/stdlib/tx';
+import { createHash } from 'node:crypto';
+
+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(
+    // Archive root after the proposed block is applied (proposal identifier).
+    readonly archiveRoot: Fr,
+    // BitVector indicating which txs from the block (proposal) we are requesting
+    // 1 means we want the tx, 0 means we don't.
+    // This will only return txs in the response if the peer has the block (proposal).
+    readonly txIndices: BitVector,
+    // If we ask for txs via indices, the responder needs to be sure that we are talking about the same block.
+    // Unfortunately, the archive root is not enough, since it's possible for the peer to have seen a different
+    // block (proposal) with the same archive root but different txs. We include a commitment to the tx hashes
+    // so that the responder can verify this (for its own sake, and not be penalized).
+    readonly blockTxHashesCommitment: Buffer32,
+    // Explicit hashes of txs we are requesting (optional). The peer will try to serve these txs even if
+    // it doesn't have the block. If the requester lists txs from the block here, this serves as a fallback.
+    // Note: if a hash here is NOT part of the block (proposal), the peer can decide to return it or not.
+    readonly txHashes: TxHashArray,
+  ) {}
+
+  static computeBlockTxHashesCommitment(blockTxHashes: TxHash[]): Buffer32 {
+    return Buffer32.fromBuffer(createHash('sha256').update(serializeToBuffer(blockTxHashes)).digest());
+  }
+
+  /**
+   * Creates new BlockTxsRequest given a block txs source and missing tx hashes.
+   *
+   * @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 the source hashes, otherwise
+   * returns new BlockTxsRequest
+   */
+  static fromTxsSourceAndMissingTxs(
+    blockTxsSource: BlockTxsSource,
+    missingTxHashes: TxHash[],
+    includeFullTxHashes = false,
+  ): BlockTxsRequest | undefined {
+    if (missingTxHashes.length === 0) {
+      return undefined; // No missing txs to request
+    }
+
+    const missingHashesSet = new Set(missingTxHashes.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 = blockTxsSource.txHashes
+      .map((hash, idx) => (missingHashesSet.has(hash.toString()) ? idx : -1))
+      .filter(i => i != -1);
+
+    const requestBitVector = BitVector.init(blockTxsSource.txHashes.length, missingIndices);
+    const hashes = includeFullTxHashes ? new TxHashArray(...missingTxHashes) : new TxHashArray();
+    const commitment = BlockTxsRequest.computeBlockTxHashesCommitment(blockTxsSource.txHashes);
+
+    return new BlockTxsRequest(blockTxsSource.archive, requestBitVector, commitment, hashes);
+  }
+
+  /**
+   * Deserializes the BlockTxRequest object from a Buffer
+   * @param buffer - Buffer or BufferReader object to deserialize
+   * @returns An instance of BlockTxRequest
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): BlockTxsRequest {
+    const reader = BufferReader.asReader(buffer);
+    const archiveRoot = Fr.fromBuffer(reader);
+    const txIndices = BitVector.fromBuffer(reader);
+    const commitment = Buffer32.fromBuffer(reader);
+    const txHashes = TxHashArray.fromBuffer(reader);
+
+    return new BlockTxsRequest(archiveRoot, txIndices, commitment, txHashes);
+  }
+
+  /**
+   * Serializes the BlockTxRequest object into a Buffer
+   * @returns Buffer representation of the BlockTxRequest object
+   */
+  toBuffer(): Buffer {
+    return serializeToBuffer([
+      this.archiveRoot,
+      this.txIndices.toBuffer(),
+      this.blockTxHashesCommitment.toBuffer(),
+      this.txHashes.toBuffer(),
+    ]);
+  }
+}
+
+/**
+ * Response message containing requested transactions from a block
+ */
+export class BlockTxsResponse {
+  constructor(
+    // List of transactions we requested and peer has.
+    readonly txs: TxArray,
+    // BitVector indicating which txs from the proposal are available at the peer
+    // 1 means the tx is available, 0 means it is not.
+    // The vector should be empty to signal that the peer doesn't have the block.
+    // Otherwise, it should be a subset of the indices of the block tx hashes.
+    readonly txIndices: BitVector,
+  ) {}
+
+  /**
+   * Whether the response indicates that the peer has the block.
+   * @returns True if the peer has the block, false otherwise.
+   */
+  peerHasBlock(): boolean {
+    return this.txIndices.getLength() > 0;
+  }
+
+  /**
+   * Deserializes the BlockTxResponse object from a Buffer
+   * @param buffer - Buffer or BufferReader object to deserialize
+   * @returns An instance of BlockTxResponse
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): BlockTxsResponse {
+    const reader = BufferReader.asReader(buffer);
+    const txs = TxArray.fromBuffer(reader);
+    const txIndices = BitVector.fromBuffer(reader);
+
+    return new BlockTxsResponse(txs, txIndices);
+  }
+
+  /**
+   * Serializes the BlockTxResponse object into a Buffer
+   * @returns Buffer representation of the BlockTxResponse object
+   */
+  toBuffer(): Buffer {
+    return serializeToBuffer([this.txs.toBuffer(), this.txIndices.toBuffer()]);
+  }
+
+  static empty(): BlockTxsResponse {
+    return new BlockTxsResponse(new TxArray(), BitVector.init(0, []));
+  }
+}
+
+/**
+ * Calculate the expected response size for a BLOCK_TXS request.
+ * @param requestBuffer - The serialized request buffer containing BlockTxsRequest
+ * @returns Expected response size in KB
+ */
+export function calculateBlockTxsResponseSize(requestBuffer: Buffer): number {
+  try {
+    const request = BlockTxsRequest.fromBuffer(requestBuffer);
+    const requestedTxCount = request.txIndices.getTrueIndices().length;
+    return requestedTxCount * MAX_TX_SIZE_KB + 1; // +1 KB overhead for serialization
+  } catch {
+    // If we can't parse the request, fall back to allowing a single transaction response
+    return MAX_TX_SIZE_KB + 1;
+  }
+}

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

@@ -0,0 +1,3 @@
+export * from './block_txs_handler.js';
+export * from './bitvector.js';
+export * from './block_txs_reqresp.js';

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

@@ -0,0 +1,102 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import type { PeerId } from '@libp2p/interface';
+
+import type { PeerManagerInterface } from '../../peer-manager/interface.js';
+import { ReqRespSubProtocol, type ReqRespSubProtocolHandler } from '../interface.js';
+import type { ReqResp } from '../reqresp.js';
+
+/**
+ * Enum defining the possible reasons for a goodbye message.
+ */
+export enum GoodByeReason {
+  /** The peer has shutdown, will be received whenever a peer's node is routinely stopped */
+  SHUTDOWN = 0x1,
+  /** The max peer count has been reached, will be received whenever a low scoring peer is disconnected to satisfy the max peer count */
+  MAX_PEERS = 0x2,
+  /** The peer has a low score, will be received whenever a peer's score is low */
+  LOW_SCORE = 0x3,
+  /** The peer has been banned, will be received whenever a peer is banned */
+  BANNED = 0x4,
+  /** Wrong network / fork */
+  WRONG_NETWORK = 0x5,
+  /** Unknown reason */
+  UNKNOWN = 0x6,
+}
+
+export function encodeGoodbyeReason(reason: GoodByeReason): Buffer {
+  return Buffer.from([reason]);
+}
+
+export function decodeGoodbyeReason(buffer: Buffer): GoodByeReason {
+  try {
+    if (buffer.length !== 1) {
+      throw new Error('Invalid goodbye reason buffer length');
+    }
+    return buffer[0] as GoodByeReason;
+  } catch {
+    return GoodByeReason.UNKNOWN;
+  }
+}
+
+/**
+ * Pretty prints the goodbye reason.
+ * @param reason - The goodbye reason.
+ * @returns The pretty printed goodbye reason.
+ */
+export function prettyGoodbyeReason(reason: GoodByeReason): string {
+  switch (reason) {
+    case GoodByeReason.SHUTDOWN:
+      return 'shutdown';
+    case GoodByeReason.MAX_PEERS:
+      return 'max_peers';
+    case GoodByeReason.LOW_SCORE:
+      return 'low_score';
+    case GoodByeReason.BANNED:
+      return 'banned';
+    // TODO(#11328): implement
+    case GoodByeReason.WRONG_NETWORK:
+      return 'wrong_network';
+    case GoodByeReason.UNKNOWN:
+      return 'unknown';
+  }
+}
+
+/**
+ * Handles a goodbye message request
+ */
+export class GoodbyeProtocolHandler {
+  private logger = createLogger('p2p:goodbye-protocol');
+
+  constructor(private reqresp: ReqResp) {}
+
+  public async sendGoodbye(peerId: PeerId, reason: GoodByeReason): Promise<void> {
+    try {
+      await this.reqresp.sendRequestToPeer(peerId, ReqRespSubProtocol.GOODBYE, Buffer.from([reason]));
+      this.logger.debug(`Sent goodbye to peer ${peerId.toString()} with reason ${reason}`);
+    } catch (error) {
+      this.logger.debug(`Failed to send goodbye to peer ${peerId.toString()}: ${error}`);
+    }
+  }
+}
+
+/**
+ * Handles the goodbye request. In request response, the goodbye request is handled by the peer manager.
+ *
+ * @dev Implemented as returning a function as the function is bound in the libp2p service, however
+ *      its implementation is here to keep functionality together.
+ *
+ * @param peerManager - The peer manager.
+ * @returns A resolved promise with the goodbye response.
+ */
+export function reqGoodbyeHandler(peerManager: PeerManagerInterface): ReqRespSubProtocolHandler {
+  return (peerId: PeerId, msg: Buffer) => {
+    const reason = decodeGoodbyeReason(msg);
+
+    peerManager.goodbyeReceived(peerId, reason);
+
+    // NOTE: In the current implementation this won't be sent to peer,
+    // as the connection to peer has been already closed by peerManager.goodbyeReceived
+    // We have this just to satisfy interface
+    return Promise.resolve(Buffer.alloc(0));
+  };
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Request Response protocol handlers
+ */
+export * from './ping.js';
+export * from './status.js';
+export * from './tx.js';
+export * from './goodbye.js';
+export * from './auth.js';
+export * from './block_txs/index.js';

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

@@ -0,0 +1,8 @@
+/**
+ * Handles the ping request.
+ * @param _msg - The ping request message.
+ * @returns A resolved promise with the pong response.
+ */
+export function pingHandler(_msg: any): Promise<Buffer> {
+  return Promise.resolve(Buffer.from('pong'));
+}

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

@@ -0,0 +1,123 @@
+import { BlockNumber } from '@aztec-labs/foundation/branded-types';
+import { Buffer32 } from '@aztec-labs/foundation/buffer';
+import type { Logger } from '@aztec-labs/foundation/log';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { bufferToHex } from '@aztec-labs/foundation/string';
+import type { WorldStateSyncStatus, WorldStateSynchronizer } from '@aztec-labs/stdlib/interfaces/server';
+import type { PeerId } from '@libp2p/interface';
+
+import { MAX_BLOCK_HASH_STRING_LENGTH, MAX_VERSION_STRING_LENGTH } from '../constants.js';
+
+/*
+ * P2P Status Message
+ * It is used to establish Status handshake between to peers
+ * By validating Status handshake we ensure peers are on the same Blockchain fork
+ * And get peer sync status
+ */
+export class StatusMessage {
+  constructor(
+    readonly compressedComponentsVersion: string,
+    readonly latestBlockNumber: BlockNumber,
+    readonly latestBlockHash: string,
+    readonly finalizedBlockNumber: BlockNumber,
+  ) {
+    //TODO: add finalizedBlockHash
+    //readonly finalizedBlockHash: string,
+  }
+
+  /**
+   * Deserializes the StatusMessage object from a Buffer.
+   * @param buffer - Buffer or BufferReader object to deserialize.
+   * @returns An instance of StatusMessage.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): StatusMessage {
+    const reader = BufferReader.asReader(buffer);
+    return new StatusMessage(
+      reader.readString(MAX_VERSION_STRING_LENGTH), // compressedComponentsVersion
+      BlockNumber(reader.readNumber()), // latestBlockNumber
+      reader.readString(MAX_BLOCK_HASH_STRING_LENGTH), // latestBlockHash
+      BlockNumber(reader.readNumber()), // finalizedBlockNumber
+      //TODO: add finalizedBlockHash
+      //reader.readString(MAX_BLOCK_HASH_STRING_LENGTH), // finalizedBlockHash
+    );
+  }
+
+  /**
+   * Serializes the StatusMessage object into a Buffer.
+   * @returns Buffer representation of the StatusMessage object.
+   */
+  toBuffer() {
+    return serializeToBuffer([
+      this.compressedComponentsVersion,
+      this.latestBlockNumber,
+      this.latestBlockHash,
+      this.finalizedBlockNumber,
+      //TODO: add finalizedBlockHash
+      // this.finalizedBlockHash,
+    ]);
+  }
+
+  /**
+   * Builds Status message
+   * @param  version - Compressed Components Version
+   * @param  worldStateSyncStatus - Info about the current sync status
+   * @returns StatusMessage instance
+   */
+  static fromWorldStateSyncStatus(version: string, syncStatus: WorldStateSyncStatus): StatusMessage {
+    return new StatusMessage(
+      version,
+      BlockNumber(syncStatus.latestBlockNumber),
+      syncStatus.latestBlockHash,
+      BlockNumber(syncStatus.finalizedBlockNumber),
+      //TODO: add finalizedBlockHash
+    );
+  }
+
+  static random(): StatusMessage {
+    return new StatusMessage(
+      '1.0.0',
+      BlockNumber(Math.floor(Math.random() * 100)),
+      Buffer32.random().toString(),
+      BlockNumber(Math.floor(Math.random() * 100)),
+      //TODO: add finalizedBlockHash
+    );
+  }
+
+  validate(peerStatus: StatusMessage): boolean {
+    // TODO: Validate other fields as well
+    return this.compressedComponentsVersion === peerStatus.compressedComponentsVersion;
+  }
+
+  equals(other: StatusMessage): boolean {
+    return (
+      this.compressedComponentsVersion === other.compressedComponentsVersion &&
+      this.latestBlockNumber === other.latestBlockNumber &&
+      this.latestBlockHash === other.latestBlockHash &&
+      this.finalizedBlockNumber === other.finalizedBlockNumber
+    );
+  }
+}
+
+/**
+ * Handles the status request. By immediately responding  with the current node status.
+ * @param compressedComponentsVersion - Compressed Components Version
+ * @param worldStateSynchronizer - World State Synchronizer to fetch the sync status from.
+ * Note the WorldStateSynchronizer must be injected to fetch the fresh sync status, we cannot pass in pre-built StatusMessage.
+ * @returns Status message handler
+ */
+export function reqRespStatusHandler(
+  compressedComponentsVersion: string,
+  worldStateSynchronizer: WorldStateSynchronizer,
+  logger?: Logger,
+) {
+  return async (peerId: PeerId, _msg: Buffer) => {
+    logger?.trace(`Received status handshake request from ${peerId}`);
+    const status = StatusMessage.fromWorldStateSyncStatus(
+      compressedComponentsVersion,
+      (await worldStateSynchronizer.status()).syncSummary,
+    );
+    const response = status.toBuffer();
+    logger?.trace(`Responding status handshake from ${peerId}`, { data: bufferToHex(response) });
+    return response;
+  };
+}

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

@@ -0,0 +1,76 @@
+import { chunk } from '@aztec-labs/foundation/collection';
+import { MAX_TX_SIZE_KB } from '@aztec-labs/stdlib/p2p';
+import { TxArray, TxHash, TxHashArray } from '@aztec-labs/stdlib/tx';
+import type { PeerId } from '@libp2p/interface';
+
+import type { MemPools } from '../../../mem_pools/interface.js';
+import type { ReqRespSubProtocolHandler } from '../interface.js';
+import { ReqRespStatus, ReqRespStatusError } from '../status.js';
+
+/**
+ * We want to keep the logic of the req resp handler in this file, but we do not have a reference to the mempools here
+ * so we need to pass it in as a parameter.
+ *
+ * Handler for tx requests
+ * @param mempools - the mempools
+ * @returns the Tx request handler
+ */
+export function reqRespTxHandler(mempools: MemPools): ReqRespSubProtocolHandler {
+  /**
+   * Handler for tx requests
+   * @param msg - the tx request message
+   * @returns the tx response message
+   * @throws if msg is not a valid tx hash
+   */
+  return async (_peerId: PeerId, msg: Buffer) => {
+    let txHashes: TxHashArray;
+    try {
+      txHashes = TxHashArray.fromBuffer(msg);
+    } catch (err: any) {
+      throw new ReqRespStatusError(ReqRespStatus.BADLY_FORMED_REQUEST, { cause: err });
+    }
+
+    try {
+      const txs = new TxArray(
+        ...(await Promise.all(txHashes.map(txHash => mempools.txPool.getTxByHash(txHash)))).filter(t => !!t),
+      );
+      return txs.toBuffer();
+    } catch (err: any) {
+      throw new ReqRespStatusError(ReqRespStatus.INTERNAL_ERROR, { cause: err });
+    }
+  };
+}
+
+/**
+ * Helper function to chunk an array of transaction hashes into chunks of a specified size.
+ * This is mainly used in ReqResp in order not to request too many transactions at once from the single peer.
+ *
+ * @param hashes - The array of transaction hashes to chunk.
+ * @param chunkSize - The size of each chunk. Default is 8. Reasoning:
+ *  Per: https://github.com/AztecProtocol/aztec-packages/issues/15149#issuecomment-2999054485
+ *  we define Q as max number of transactions per batch, the comment explains why we use 8.
+ */
+export function chunkTxHashesRequest(hashes: TxHash[], chunkSize = 8): Array<TxHashArray> {
+  return chunk(hashes, chunkSize).map(chunk => new TxHashArray(...chunk));
+}
+
+/**
+ * Calculate the expected response size for a TX request.
+ * @param requestBuffer - The serialized request buffer containing TxHashArray
+ * @returns Expected response size in KB
+ */
+export function calculateTxResponseSize(requestBuffer: Buffer): number {
+  try {
+    const txHashes = TxHashArray.fromBuffer(requestBuffer);
+    // TxHashArray.fromBuffer returns empty array on parse failure, so check for that
+    if (txHashes.length === 0 && requestBuffer.length > 0) {
+      // If we got an empty array but had a non-empty buffer, parsing likely failed
+      // Fall back to allowing a single transaction response
+      return MAX_TX_SIZE_KB + 1;
+    }
+    return Math.max(txHashes.length, 1) * MAX_TX_SIZE_KB + 1; // +1 KB overhead, at least 1 tx
+  } catch {
+    // If we can't parse the request, fall back to allowing a single transaction response
+    return MAX_TX_SIZE_KB + 1;
+  }
+}

package/src/services/reqresp/rate-limiter/index.ts

@@ -0,0 +1 @@
+export { RequestResponseRateLimiter } from './rate_limiter.js';