@aztec/p2p 0.0.1-commit.54489865 → 0.0.1-commit.5914bae

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

@@ -2,13 +2,13 @@ import { type Tx, TxHash } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 
+import type { IMissingTxsTracker } from '../../tx_collection/missing_txs_tracker.js';
 import { DEFAULT_BATCH_TX_REQUESTER_TX_BATCH_SIZE } from './config.js';
 import type { ITxMetadataCollection } from './interface.js';
 
-export class MissingTxMetadata {
+class MissingTxMetadata {
   constructor(
-    public readonly txHash: TxHash,
-    public fetched = false,
+    public readonly txHash: string,
     public requestedCount = 0,
     public inFlightCount = 0,
     public tx: Tx | undefined = undefined,
@@ -30,24 +30,6 @@ export class MissingTxMetadata {
   public isInFlight(): boolean {
     return this.inFlightCount > 0;
   }
-
-  //Returns true if this is the first time we mark it as fetched
-  public markAsFetched(peerId: PeerId, tx: Tx): boolean {
-    if (this.fetched) {
-      return false;
-    }
-
-    this.fetched = true;
-    this.tx = tx;
-
-    this.peers.add(peerId.toString());
-
-    return true;
-  }
-
-  public toString() {
-    return this.txHash.toString();
-  }
 }
 
 /*
@@ -55,21 +37,18 @@ export class MissingTxMetadata {
  * This could be better optimized but given expected count of missing txs (N < 100)
  * At the moment there is no need for it. And benefit is that we have everything in single store
  * */
-export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata> implements ITxMetadataCollection {
+export class MissingTxMetadataCollection implements ITxMetadataCollection {
+  private txMetadata = new Map<string, MissingTxMetadata>();
+
   constructor(
-    entries?: readonly (readonly [string, MissingTxMetadata])[] | null,
+    private missingTxsTracker: IMissingTxsTracker,
     private readonly txBatchSize: number = DEFAULT_BATCH_TX_REQUESTER_TX_BATCH_SIZE,
   ) {
-    super(entries);
-  }
-  public getSortedByRequestedCountAsc(txs: string[]): MissingTxMetadata[] {
-    return Array.from(this.values().filter(txMeta => txs.includes(txMeta.txHash.toString()))).sort(
-      (a, b) => a.requestedCount - b.requestedCount,
-    );
+    missingTxsTracker.missingTxHashes.forEach(hash => this.txMetadata.set(hash, new MissingTxMetadata(hash)));
   }
 
   public getPrioritizingNotInFlightAndLowerRequestCount(txs: string[]): MissingTxMetadata[] {
-    const filtered = Array.from(this.values()).filter(txMeta => txs.includes(txMeta.txHash.toString()));
+    const filtered = Array.from(this.txMetadata.values()).filter(txMeta => txs.includes(txMeta.txHash.toString()));
 
     const [notInFlight, inFlight] = filtered.reduce<[MissingTxMetadata[], MissingTxMetadata[]]>(
       (buckets, tx) => {
@@ -85,43 +64,15 @@ export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata>
     return [...notInFlight, ...inFlight];
   }
 
-  public getFetchedTxHashes(): Set<string> {
-    return new Set(
-      this.values()
-        .filter(t => t.fetched)
-        .map(t => t.txHash.toString()),
-    );
-  }
-
   public getMissingTxHashes(): Set<string> {
-    return new Set(
-      this.values()
-        .filter(t => !t.fetched)
-        .map(t => t.txHash.toString()),
-    );
-  }
-
-  public getInFlightTxHashes(): Set<string> {
-    return new Set(
-      this.values()
-        .filter(t => t.isInFlight())
-        .map(t => t.txHash.toString()),
-    );
-  }
-
-  public getFetchedTxs(): Tx[] {
-    return Array.from(
-      this.values()
-        .map(t => t.tx)
-        .filter(t => !!t),
-    );
+    return this.missingTxsTracker.missingTxHashes;
   }
 
   public getTxsPeerHas(peer: PeerId): Set<string> {
     const peerIdStr = peer.toString();
     const txsPeerHas = new Set<string>();
 
-    this.values().forEach(txMeta => {
+    this.txMetadata.values().forEach(txMeta => {
       if (txMeta.peers.has(peerIdStr)) {
         txsPeerHas.add(txMeta.txHash.toString());
       }
@@ -132,13 +83,13 @@ export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata>
 
   public getTxsToRequestFromThePeer(peer: PeerId): TxHash[] {
     const txsPeerHas = this.getTxsPeerHas(peer);
-    const fetchedTxs = this.getFetchedTxHashes();
+    const missingTxHashes = this.getMissingTxHashes();
 
-    const txsToRequest = txsPeerHas.difference(fetchedTxs);
+    const txsToRequest = txsPeerHas.intersection(missingTxHashes);
 
     if (txsToRequest.size >= this.txBatchSize) {
       return this.getPrioritizingNotInFlightAndLowerRequestCount(Array.from(txsToRequest))
-        .map(t => t.txHash)
+        .map(t => TxHash.fromString(t.txHash))
         .slice(0, this.txBatchSize);
     }
 
@@ -150,13 +101,13 @@ export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata>
       Array.from(this.getMissingTxHashes().difference(txsToRequest)),
     )
       .slice(0, countToFill)
-      .map(t => t.txHash);
+      .map(t => TxHash.fromString(t.txHash));
 
     return [...Array.from(txsToRequest).map(t => TxHash.fromString(t)), ...txsToFill];
   }
 
   public markRequested(txHash: TxHash) {
-    this.get(txHash.toString())?.markAsRequested();
+    this.txMetadata.get(txHash.toString())?.markAsRequested();
   }
 
   /*
@@ -165,7 +116,7 @@ export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata>
    * "dumb" peer might return it, or might not - we don't know
    * */
   public markInFlightBySmartPeer(txHash: TxHash) {
-    this.get(txHash.toString())?.markInFlight();
+    this.txMetadata.get(txHash.toString())?.markInFlight();
   }
 
   /*
@@ -173,16 +124,16 @@ export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata>
    * Because the smart peer should return this tx, whereas
    * "dumb" peer might return it, or might not - we don't know*/
   public markNotInFlightBySmartPeer(txHash: TxHash) {
-    this.get(txHash.toString())?.markNotInFlight();
+    this.txMetadata.get(txHash.toString())?.markNotInFlight();
   }
 
   public alreadyFetched(txHash: TxHash): boolean {
-    return this.get(txHash.toString())?.fetched ?? false;
+    return !this.missingTxsTracker.isMissing(txHash.toString());
   }
 
   public markFetched(peerId: PeerId, tx: Tx): boolean {
     const txHashStr = tx.txHash.toString();
-    const txMeta = this.get(txHashStr);
+    const txMeta = this.txMetadata.get(txHashStr);
     if (!txMeta) {
       //TODO: what to do about peer which sent txs we didn't request?
       // 1. don't request from it in the scope of this batch request
@@ -192,7 +143,8 @@ export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata>
       return false;
     }
 
-    return txMeta.markAsFetched(peerId, tx);
+    txMeta.peers.add(peerId.toString());
+    return this.missingTxsTracker.markFetched(tx);
   }
 
   public markPeerHas(peerId: PeerId, txHash: TxHash[]) {
@@ -200,7 +152,7 @@ export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata>
     txHash
       .map(t => t.toString())
       .forEach(txh => {
-        const txMeta = this.get(txh);
+        const txMeta = this.txMetadata.get(txh);
         if (txMeta) {
           txMeta.peers.add(peerIdStr);
         }

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

@@ -1,7 +1,7 @@
 import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
 import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 
-import { createTxReqRespValidator } from '../../../msg_validators/tx_validator/factory.js';
+import { createTxValidatorForReqResponseReceivedTxs } from '../../../msg_validators/index.js';
 
 export interface BatchRequestTxValidatorConfig {
   l1ChainId: number;
@@ -29,7 +29,7 @@ export class BatchRequestTxValidator implements IBatchRequestTxValidator {
   }
 
   static createRequestedTxValidator(config: BatchRequestTxValidatorConfig): TxValidator {
-    return createTxReqRespValidator(config.proofVerifier, {
+    return createTxValidatorForReqResponseReceivedTxs(config.proofVerifier, {
       l1ChainId: config.l1ChainId,
       rollupVersion: config.rollupVersion,
     });

package/src/services/reqresp/interface.ts

@@ -1,5 +1,6 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { L2Block } from '@aztec/stdlib/block';
+import { MAX_L2_BLOCK_SIZE_KB } from '@aztec/stdlib/p2p';
 import { TxArray, TxHashArray } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
@@ -7,8 +8,13 @@ import type { PeerId } from '@libp2p/interface';
 import type { P2PReqRespConfig } from './config.js';
 import type { ConnectionSampler } from './connection-sampler/connection_sampler.js';
 import { AuthRequest, AuthResponse } from './protocols/auth.js';
-import { BlockTxsRequest, BlockTxsResponse } from './protocols/block_txs/block_txs_reqresp.js';
+import {
+  BlockTxsRequest,
+  BlockTxsResponse,
+  calculateBlockTxsResponseSize,
+} from './protocols/block_txs/block_txs_reqresp.js';
 import { StatusMessage } from './protocols/status.js';
+import { calculateTxResponseSize } from './protocols/tx.js';
 import type { ReqRespStatus } from './status.js';
 
 /*
@@ -211,6 +217,25 @@ export const subProtocolMap = {
   },
 };
 
+/**
+ * Type for a function that calculates the expected response size in KB for a given request.
+ */
+export type ExpectedResponseSizeCalculator = (requestBuffer: Buffer) => number;
+
+/**
+ * Map of sub-protocols to their expected response size calculators.
+ * These are used to validate that responses don't exceed expected sizes based on request parameters.
+ */
+export const subProtocolSizeCalculators: Record<ReqRespSubProtocol, ExpectedResponseSizeCalculator> = {
+  [ReqRespSubProtocol.TX]: calculateTxResponseSize,
+  [ReqRespSubProtocol.BLOCK_TXS]: calculateBlockTxsResponseSize,
+  [ReqRespSubProtocol.BLOCK]: () => MAX_L2_BLOCK_SIZE_KB,
+  [ReqRespSubProtocol.STATUS]: () => 1,
+  [ReqRespSubProtocol.PING]: () => 1,
+  [ReqRespSubProtocol.AUTH]: () => 1,
+  [ReqRespSubProtocol.GOODBYE]: () => 1, // No response expected, but provide minimal limit
+};
+
 export interface ReqRespInterface {
   start(
     subProtocolHandlers: Partial<ReqRespSubProtocolHandlers>,

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

@@ -1,10 +1,11 @@
 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 { TxPool } from '../../../../mem_pools/index.js';
+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';
@@ -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: TxPoolV2,
+): 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,23 @@
 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 { MAX_TX_SIZE_KB } from '@aztec/stdlib/p2p';
+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 +28,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 +48,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 +70,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 +82,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 +91,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 +105,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,10 +119,26 @@ 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 {
     return new BlockTxsResponse(Fr.ZERO, 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/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';
@@ -55,3 +56,24 @@ export function reqRespTxHandler(mempools: MemPools): ReqRespSubProtocolHandler
 export function chunkTxHashesRequest(hashes: TxHash[], chunkSize = 1): 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;
   }