@aztec/p2p 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

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

@@ -1,11 +1,10 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
 import type { L2BlockSource } from '@aztec/stdlib/block';
-import { TxArray } from '@aztec/stdlib/tx';
+import { TxArray, TxHash } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 
 import type { AttestationPoolApi } from '../../../../mem_pools/attestation_pool/attestation_pool.js';
-import type { TxPool } from '../../../../mem_pools/index.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';
@@ -21,7 +20,7 @@ import { BlockTxsRequest, BlockTxsResponse } from './block_txs_reqresp.js';
 export function reqRespBlockTxsHandler(
   attestationPool: AttestationPoolApi,
   archiver: L2BlockSource,
-  txPool: TxPool,
+  txPool: TxPoolV2,
 ): ReqRespSubProtocolHandler {
   /**
    * Handler for block txs requests
@@ -36,40 +35,45 @@ export function reqRespBlockTxsHandler(
     } catch (err: any) {
       throw new ReqRespStatusError(ReqRespStatus.BADLY_FORMED_REQUEST, { cause: err });
     }
-    // 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;
-    }
+    // 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()));
 
-    // 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 (!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();
+    // 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 don't have this block and peer has not sent requested tx hashes
-    if (!txHashes) {
-      throw new ReqRespStatusError(ReqRespStatus.NOT_FOUND);
-    }
+    // 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);
 
-    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(txHashes.length, availableIndices);
-
-    const requestedIndices = new Set(request.txIndices.getTrueIndices());
-    requestedTxsHashes = txHashes.filter((_, idx) => requestedIndices.has(idx));
+        // 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()));
+      }
+    }
 
-    const responseTxs = (await txPool.getTxsByHash(requestedTxsHashes)).filter(tx => !!tx);
-    const response = new BlockTxsResponse(request.archiveRoot, new TxArray(...responseTxs), responseBitVector);
+    // 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

@@ -1,7 +1,11 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { MAX_TX_SIZE_KB } from '@aztec/stdlib/p2p';
 import { TxArray, type TxHash, TxHashArray } from '@aztec/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. */
@@ -15,17 +19,27 @@ export interface BlockTxsSource {
  */
 export class BlockTxsRequest {
   constructor(
-    // Archive root after the proposed block is applied (proposal identifier)
+    // 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
-    // 1 means we want the tx, 0 means we don't
-    // If we know peer has the Block Proposal then we can use this BitVector
-    // Otherwise we can use this optimization
+    // 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.
    *
@@ -58,8 +72,9 @@ export class BlockTxsRequest {
 
     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, hashes, requestBitVector);
+    return new BlockTxsRequest(blockTxsSource.archive, requestBitVector, commitment, hashes);
   }
 
   /**
@@ -70,10 +85,11 @@ export class BlockTxsRequest {
   static fromBuffer(buffer: Buffer | BufferReader): BlockTxsRequest {
     const reader = BufferReader.asReader(buffer);
     const archiveRoot = Fr.fromBuffer(reader);
-    const txHashes = TxHashArray.fromBuffer(reader);
     const txIndices = BitVector.fromBuffer(reader);
+    const commitment = Buffer32.fromBuffer(reader);
+    const txHashes = TxHashArray.fromBuffer(reader);
 
-    return new BlockTxsRequest(archiveRoot, txHashes, txIndices);
+    return new BlockTxsRequest(archiveRoot, txIndices, commitment, txHashes);
   }
 
   /**
@@ -81,7 +97,12 @@ export class BlockTxsRequest {
    * @returns Buffer representation of the BlockTxRequest object
    */
   toBuffer(): Buffer {
-    return serializeToBuffer([this.archiveRoot, this.txHashes.toBuffer(), this.txIndices.toBuffer()]);
+    return serializeToBuffer([
+      this.archiveRoot,
+      this.txIndices.toBuffer(),
+      this.blockTxHashesCommitment.toBuffer(),
+      this.txHashes.toBuffer(),
+    ]);
   }
 }
 
@@ -90,13 +111,23 @@ export class BlockTxsRequest {
  */
 export class BlockTxsResponse {
   constructor(
-    readonly archiveRoot: Fr,
-    readonly txs: TxArray, // List of transactions we requested and peer has
+    // 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
+    // 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
@@ -104,24 +135,37 @@ export class BlockTxsResponse {
    */
   static fromBuffer(buffer: Buffer | BufferReader): BlockTxsResponse {
     const reader = BufferReader.asReader(buffer);
-    const archiveRoot = Fr.fromBuffer(reader);
     const txs = TxArray.fromBuffer(reader);
     const txIndices = BitVector.fromBuffer(reader);
 
-    return new BlockTxsResponse(archiveRoot, txs, txIndices);
+    return new BlockTxsResponse(txs, txIndices);
   }
 
   /**
    * Serializes the BlockTxResponse object into a Buffer
-   * @dev: In current implementation, txIndices is serialized as Buffer of unknown length,
-   * thus we serialize it last
    * @returns Buffer representation of the BlockTxResponse object
    */
   toBuffer(): Buffer {
-    return serializeToBuffer([this.archiveRoot, this.txs.toBuffer(), this.txIndices.toBuffer()]);
+    return serializeToBuffer([this.txs.toBuffer(), this.txIndices.toBuffer()]);
   }
 
   static empty(): BlockTxsResponse {
-    return new BlockTxsResponse(Fr.ZERO, new TxArray(), BitVector.init(0, []));
+    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/index.ts

@@ -5,6 +5,5 @@ export * from './ping.js';
 export * from './status.js';
 export * from './tx.js';
 export * from './goodbye.js';
-export * from './block.js';
 export * from './auth.js';
 export * from './block_txs/index.js';

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

@@ -1,4 +1,5 @@
 import { chunk } from '@aztec/foundation/collection';
+import { MAX_TX_SIZE_KB } from '@aztec/stdlib/p2p';
 import { TxArray, TxHash, TxHashArray } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
@@ -50,8 +51,27 @@ export function reqRespTxHandler(mempools: MemPools): ReqRespSubProtocolHandler
  *  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.
  */
-//TODO: (mralj) chunk size should by default be 8, this is just temporary until the protocol is implemented correctly
-//more info:  https://github.com/AztecProtocol/aztec-packages/pull/15516#pullrequestreview-2995474321
-export function chunkTxHashesRequest(hashes: TxHash[], chunkSize = 1): Array<TxHashArray> {
+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/rate_limiter.ts

@@ -97,9 +97,10 @@ export function prettyPrintRateLimitStatus(status: RateLimitStatus) {
  * 2. Individual rate limits for each peer.
  *
  * How it works:
- * - When a request comes in, it first checks against the global rate limit.
- * - If the global limit allows, it then checks against the specific peer's rate limit.
- * - The request is only allowed if both the global and peer-specific limits allow it.
+ * - When a request comes in, it first checks against the peer's individual rate limit.
+ * - If the peer limit allows, it then checks against the global rate limit.
+ * - The request is only allowed if both the peer-specific and global limits allow it.
+ * - Checking peer limit first ensures a rate-limited peer cannot exhaust the global quota.
  * - It automatically creates and manages rate limiters for new peers as they make requests.
  * - It periodically cleans up rate limiters for inactive peers to conserve memory.
  *
@@ -119,10 +120,6 @@ export class SubProtocolRateLimiter {
   }
 
   allow(peerId: PeerId): RateLimitStatus {
-    if (!this.globalLimiter.allow()) {
-      return RateLimitStatus.DeniedGlobal;
-    }
-
     const peerIdStr = peerId.toString();
     let peerLimiter: PeerRateLimiter | undefined = this.peerLimiters.get(peerIdStr);
     if (!peerLimiter) {
@@ -135,10 +132,17 @@ export class SubProtocolRateLimiter {
     } else {
       peerLimiter.lastAccess = Date.now();
     }
-    const peerLimitAllowed = peerLimiter.limiter.allow();
-    if (!peerLimitAllowed) {
+
+    // Check peer limit first: a rate-limited peer must not consume global quota,
+    // otherwise one spamming peer can starve all others by exhausting the global bucket.
+    if (!peerLimiter.limiter.allow()) {
       return RateLimitStatus.DeniedPeer;
     }
+
+    if (!this.globalLimiter.allow()) {
+      return RateLimitStatus.DeniedGlobal;
+    }
+
     return RateLimitStatus.Allowed;
   }
 

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

@@ -9,7 +9,7 @@ export const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits = {
     },
     globalLimit: {
       quotaTimeMs: 1000,
-      quotaCount: 10,
+      quotaCount: 50,
     },
   },
   [ReqRespSubProtocol.STATUS]: {
@@ -19,7 +19,7 @@ export const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits = {
     },
     globalLimit: {
       quotaTimeMs: 1000,
-      quotaCount: 10,
+      quotaCount: 50,
     },
   },
   [ReqRespSubProtocol.AUTH]: {
@@ -42,16 +42,6 @@ export const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits = {
       quotaCount: 200,
     },
   },
-  [ReqRespSubProtocol.BLOCK]: {
-    peerLimit: {
-      quotaTimeMs: 1000,
-      quotaCount: 2,
-    },
-    globalLimit: {
-      quotaTimeMs: 1000,
-      quotaCount: 5,
-    },
-  },
   [ReqRespSubProtocol.GOODBYE]: {
     peerLimit: {
       quotaTimeMs: 1000,
@@ -59,7 +49,7 @@ export const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits = {
     },
     globalLimit: {
       quotaTimeMs: 1000,
-      quotaCount: 10,
+      quotaCount: 50,
     },
   },
   [ReqRespSubProtocol.BLOCK_TXS]: {