@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.24de95ac

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();
+  };
+}

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

@@ -0,0 +1,79 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { TxArray } from '@aztec/stdlib/tx';
+
+import { BitVector } from './bitvector.js';
+
+/**
+ * Request message for requesting specific transactions from a block
+ */
+export class BlockTxsRequest {
+  constructor(
+    readonly blockHash: Fr, // 32 byte hash of the proposed block header
+    // BitVector indicating which txs from the proposal we are requesting
+    // 1 means we want the tx, 0 means we don't
+    readonly txIndices: BitVector,
+  ) {}
+
+  /**
+   * 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 blockHash = Fr.fromBuffer(reader);
+    const txIndices = BitVector.fromBuffer(reader);
+
+    return new BlockTxsRequest(blockHash, txIndices);
+  }
+
+  /**
+   * Serializes the BlockTxRequest object into a Buffer
+   * @returns Buffer representation of the BlockTxRequest object
+   */
+  toBuffer(): Buffer {
+    return serializeToBuffer([this.blockHash, this.txIndices.toBuffer()]);
+  }
+}
+
+/**
+ * Response message containing requested transactions from a block
+ */
+export class BlockTxsResponse {
+  constructor(
+    readonly blockHash: 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
+    readonly txIndices: BitVector,
+  ) {}
+
+  /**
+   * 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 blockHash = Fr.fromBuffer(reader);
+    const txs = TxArray.fromBuffer(reader);
+    const txIndices = BitVector.fromBuffer(reader);
+
+    return new BlockTxsResponse(blockHash, 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.blockHash, this.txs.toBuffer(), this.txIndices.toBuffer()]);
+  }
+
+  static empty(): BlockTxsResponse {
+    return new BlockTxsResponse(Fr.ZERO, new TxArray(), BitVector.init(0, []));
+  }
+}

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

@@ -2,7 +2,7 @@ import { createLogger } from '@aztec/foundation/log';
 
 import type { PeerId } from '@libp2p/interface';
 
-import type { PeerManager } from '../../peer-manager/peer_manager.js';
+import type { PeerManagerInterface } from '../../peer-manager/interface.js';
 import { ReqRespSubProtocol, type ReqRespSubProtocolHandler } from '../interface.js';
 import type { ReqResp } from '../reqresp.js';
 
@@ -34,7 +34,7 @@ export function decodeGoodbyeReason(buffer: Buffer): GoodByeReason {
       throw new Error('Invalid goodbye reason buffer length');
     }
     return buffer[0] as GoodByeReason;
-  } catch (error) {
+  } catch {
     return GoodByeReason.UNKNOWN;
   }
 }
@@ -89,13 +89,15 @@ export class GoodbyeProtocolHandler {
  * @param peerManager - The peer manager.
  * @returns A resolved promise with the goodbye response.
  */
-export function reqGoodbyeHandler(peerManager: PeerManager): ReqRespSubProtocolHandler {
-  return (peerId: PeerId, _msg: Buffer) => {
-    const reason = decodeGoodbyeReason(_msg);
+export function reqGoodbyeHandler(peerManager: PeerManagerInterface): ReqRespSubProtocolHandler {
+  return (peerId: PeerId, msg: Buffer) => {
+    const reason = decodeGoodbyeReason(msg);
 
     peerManager.goodbyeReceived(peerId, reason);
 
-    // Return a buffer of length 1 as an acknowledgement: this is allowed to fail
-    return Promise.resolve(Buffer.from([0x0]));
+    // 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

@@ -6,3 +6,5 @@ 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/status.ts

@@ -1,8 +1,120 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import type { Logger } from '@aztec/foundation/log';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex } from '@aztec/foundation/string';
+import type { WorldStateSyncStatus, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+
+import type { PeerId } from '@libp2p/interface';
+
+/*
+ * 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: number,
+    readonly latestBlockHash: string,
+    readonly finalizedBlockNumber: number,
+    //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(), // compressedComponentsVersion
+      reader.readNumber(), // latestBlockNumber
+      reader.readString(), // latestBlockHash
+      reader.readNumber(), // finalizedBlockNumber
+      //TODO: add finalizedBlockHash
+      //reader.readString(), // 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,
+      syncStatus.latestBlockNumber,
+      syncStatus.latestBlockHash,
+      syncStatus.finalizedBlockNumber,
+      //TODO: add finalizedBlockHash
+    );
+  }
+
+  static random(): StatusMessage {
+    return new StatusMessage(
+      '1.0.0',
+      Math.floor(Math.random() * 100),
+      Buffer32.random().toString(),
+      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.
- * @param _msg - The status request message.
- * @returns A resolved promise with the ok response.
+ * 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 statusHandler(_msg: any): Promise<Buffer> {
-  return Promise.resolve(Buffer.from('ok'));
+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

@@ -1,10 +1,12 @@
+import { chunk } from '@aztec/foundation/collection';
 import type { P2PClientType } from '@aztec/stdlib/p2p';
-import { TxHash } from '@aztec/stdlib/tx';
+import { TxArray, TxHash, TxHashArray } from '@aztec/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
@@ -12,18 +14,45 @@ import type { ReqRespSubProtocolHandler } from '../interface.js';
  *
  * Handler for tx requests
  * @param mempools - the mempools
- * @returns the tx response message
+ * @returns the Tx request handler
  */
 export function reqRespTxHandler<T extends P2PClientType>(mempools: MemPools<T>): 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) => {
-    const txHash = TxHash.fromBuffer(msg);
-    const foundTx = await mempools.txPool.getTxByHash(txHash);
-    const buf = foundTx ? foundTx.toBuffer() : Buffer.alloc(0);
-    return buf;
+    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.
+ */
+//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> {
+  return chunk(hashes, chunkSize).map(chunk => new TxHashArray(...chunk));
+}

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

@@ -8,7 +8,7 @@ import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import type { PeerId } from '@libp2p/interface';
 
 import type { PeerScoring } from '../../peer-manager/peer_scoring.js';
-import type { ReqRespSubProtocol, ReqRespSubProtocolRateLimits } from '../interface.js';
+import type { ProtocolRateLimitQuota, ReqRespSubProtocol, ReqRespSubProtocolRateLimits } from '../interface.js';
 import { DEFAULT_RATE_LIMITS } from './rate_limits.js';
 
 // Check for disconnected peers every 10 minutes
@@ -177,13 +177,18 @@ export class SubProtocolRateLimiter {
  */
 export class RequestResponseRateLimiter {
   private subProtocolRateLimiters: Map<ReqRespSubProtocol, SubProtocolRateLimiter>;
+  private rateLimits: ReqRespSubProtocolRateLimits;
 
   private cleanupInterval: NodeJS.Timeout | undefined = undefined;
 
-  constructor(private peerScoring: PeerScoring, rateLimits: ReqRespSubProtocolRateLimits = DEFAULT_RATE_LIMITS) {
+  constructor(
+    private peerScoring: PeerScoring,
+    rateLimits: Partial<ReqRespSubProtocolRateLimits> = {},
+  ) {
     this.subProtocolRateLimiters = new Map();
 
-    for (const [subProtocol, protocolLimits] of Object.entries(rateLimits)) {
+    this.rateLimits = { ...DEFAULT_RATE_LIMITS, ...rateLimits };
+    for (const [subProtocol, protocolLimits] of Object.entries(this.rateLimits)) {
       this.subProtocolRateLimiters.set(
         subProtocol as ReqRespSubProtocol,
         new SubProtocolRateLimiter(
@@ -225,4 +230,8 @@ export class RequestResponseRateLimiter {
   stop() {
     clearInterval(this.cleanupInterval);
   }
+
+  getRateLimits(protocol: ReqRespSubProtocol): ProtocolRateLimitQuota {
+    return this.rateLimits[protocol];
+  }
 }

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

@@ -22,6 +22,16 @@ export const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits = {
       quotaCount: 10,
     },
   },
+  [ReqRespSubProtocol.AUTH]: {
+    peerLimit: {
+      quotaTimeMs: 1000,
+      quotaCount: 5,
+    },
+    globalLimit: {
+      quotaTimeMs: 1000,
+      quotaCount: 10,
+    },
+  },
   [ReqRespSubProtocol.TX]: {
     peerLimit: {
       quotaTimeMs: 1000,
@@ -29,7 +39,7 @@ export const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits = {
     },
     globalLimit: {
       quotaTimeMs: 1000,
-      quotaCount: 20,
+      quotaCount: 200,
     },
   },
   [ReqRespSubProtocol.BLOCK]: {
@@ -52,4 +62,14 @@ export const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits = {
       quotaCount: 10,
     },
   },
+  [ReqRespSubProtocol.BLOCK_TXS]: {
+    peerLimit: {
+      quotaTimeMs: 1000,
+      quotaCount: 10,
+    },
+    globalLimit: {
+      quotaTimeMs: 1000,
+      quotaCount: 200,
+    },
+  },
 };