@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.017a351

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

@@ -1,8 +1,124 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+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';
+
+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.
- * @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 type { P2PClientType } from '@aztec/stdlib/p2p';
-import { TxHash } from '@aztec/stdlib/tx';
+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';
 
 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,64 @@ 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 {
+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) => {
-    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.
+ */
+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

@@ -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
@@ -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;
   }
 
@@ -177,13 +181,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 +234,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,24 +22,24 @@ export const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits = {
       quotaCount: 10,
     },
   },
-  [ReqRespSubProtocol.TX]: {
+  [ReqRespSubProtocol.AUTH]: {
     peerLimit: {
       quotaTimeMs: 1000,
-      quotaCount: 10,
+      quotaCount: 5,
     },
     globalLimit: {
       quotaTimeMs: 1000,
-      quotaCount: 20,
+      quotaCount: 10,
     },
   },
-  [ReqRespSubProtocol.BLOCK]: {
+  [ReqRespSubProtocol.TX]: {
     peerLimit: {
       quotaTimeMs: 1000,
-      quotaCount: 2,
+      quotaCount: 10,
     },
     globalLimit: {
       quotaTimeMs: 1000,
-      quotaCount: 5,
+      quotaCount: 200,
     },
   },
   [ReqRespSubProtocol.GOODBYE]: {
@@ -52,4 +52,14 @@ export const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits = {
       quotaCount: 10,
     },
   },
+  [ReqRespSubProtocol.BLOCK_TXS]: {
+    peerLimit: {
+      quotaTimeMs: 1000,
+      quotaCount: 10,
+    },
+    globalLimit: {
+      quotaTimeMs: 1000,
+      quotaCount: 200,
+    },
+  },
 };