@aztec/p2p 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2 → 0.76.0

package/dest/services/reqresp/protocols/tx.js

@@ -6,15 +6,18 @@ import { TxHash } from '@aztec/circuit-types/tx_hash';
  * Handler for tx requests
  * @param mempools - the mempools
  * @returns the tx response message
- */ export function reqRespTxHandler(mempools) {
+ */
+export function reqRespTxHandler(mempools) {
     /**
-   * Handler for tx requests
-   * @param msg - the tx request message
-   * @returns the tx response message
-   */ return async (_peerId, msg)=>{
+     * Handler for tx requests
+     * @param msg - the tx request message
+     * @returns the tx response message
+     */
+    return async (_peerId, msg) => {
         const txHash = TxHash.fromBuffer(msg);
         const foundTx = await mempools.txPool.getTxByHash(txHash);
         const buf = foundTx ? foundTx.toBuffer() : Buffer.alloc(0);
         return buf;
     };
 }
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc2VydmljZXMvcmVxcmVzcC9wcm90b2NvbHMvdHgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBT3REOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLFVBQVUsZ0JBQWdCLENBQTBCLFFBQXFCO0lBQzdFOzs7O09BSUc7SUFDSCxPQUFPLEtBQUssRUFBRSxPQUFlLEVBQUUsR0FBVyxFQUFFLEVBQUU7UUFDNUMsTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUN0QyxNQUFNLE9BQU8sR0FBRyxNQUFNLFFBQVEsQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQzFELE1BQU0sR0FBRyxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQzNELE9BQU8sR0FBRyxDQUFDO0lBQ2IsQ0FBQyxDQUFDO0FBQ0osQ0FBQyJ9

package/dest/services/reqresp/rate-limiter/index.d.ts

@@ -0,0 +1,2 @@
+export { RequestResponseRateLimiter } from './rate_limiter.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/services/reqresp/rate-limiter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/rate-limiter/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC"}

package/dest/services/reqresp/rate-limiter/index.js

@@ -1 +1,2 @@
 export { RequestResponseRateLimiter } from './rate_limiter.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc2VydmljZXMvcmVxcmVzcC9yYXRlLWxpbWl0ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLDBCQUEwQixFQUFFLE1BQU0sbUJBQW1CLENBQUMifQ==

package/dest/services/reqresp/rate-limiter/rate_limiter.d.ts

@@ -0,0 +1,102 @@
+import { type PeerId } from '@libp2p/interface';
+import { type PeerScoring } from '../../peer-manager/peer_scoring.js';
+import { type ReqRespSubProtocol, type ReqRespSubProtocolRateLimits } from '../interface.js';
+/**
+ * GCRARateLimiter: A Generic Cell Rate Algorithm (GCRA) based rate limiter.
+ *
+ * How it works:
+ * 1. The rate limiter allows a certain number of operations (quotaCount) within a specified
+ *    time interval (quotaTimeMs).
+ * 2. It uses a "virtual scheduling time" (VST) to determine when the next operation should be allowed.
+ * 3. When an operation is requested, the limiter checks if enough time has passed since the last
+ *    allowed operation.
+ * 4. If sufficient time has passed, the operation is allowed, and the VST is updated.
+ * 5. If not enough time has passed, the operation is denied.
+ *
+ * The limiter also allows for short bursts of activity, as long as the overall rate doesn't exceed
+ * the specified quota over time.
+ *
+ * Usage example:
+ * ```
+ * const limiter = new GCRARateLimiter(100, 60000); // 100 operations per minute
+ * ```
+ */
+export declare class GCRARateLimiter {
+    private vst;
+    private readonly emissionInterval;
+    private readonly limitInterval;
+    /**
+     * @param quotaCount - The number of requests to allow over the limit interval
+     * @param quotaTimeMs - The time interval over which the quotaCount applies
+     */
+    constructor(quotaCount: number, quotaTimeMs: number);
+    allow(): boolean;
+}
+declare enum RateLimitStatus {
+    Allowed = 0,
+    DeniedGlobal = 1,
+    DeniedPeer = 2
+}
+/**
+ * SubProtocolRateLimiter: A rate limiter for managing request rates on a per-peer and global basis for a specific subprotocol.
+ *
+ * This class provides a two-tier rate limiting system:
+ * 1. A global rate limit for all requests across all peers for this subprotocol.
+ * 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.
+ * - 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.
+ *
+ * Note: Remember to call `start()` to begin the cleanup process and `stop()` when shutting down to clear the cleanup interval.
+ */
+export declare class SubProtocolRateLimiter {
+    private peerLimiters;
+    private globalLimiter;
+    private readonly peerQuotaCount;
+    private readonly peerQuotaTimeMs;
+    constructor(peerQuotaCount: number, peerQuotaTimeMs: number, globalQuotaCount: number, globalQuotaTimeMs: number);
+    allow(peerId: PeerId): RateLimitStatus;
+    cleanupInactivePeers(): void;
+}
+/**
+ * RequestResponseRateLimiter.
+ *
+ * A rate limiter that is protocol aware, then peer aware.
+ * SubProtocols can have their own global / peer level rate limits.
+ *
+ * How it works:
+ * - Initializes with a set of rate limit configurations for different subprotocols.
+ * - Creates a separate SubProtocolRateLimiter for each configured subprotocol.
+ * - When a request comes in, it routes the rate limiting decision to the appropriate subprotocol limiter.
+ * - Peers who exceed their peer rate limits will be penalised by the peer manager.
+ *
+ * Usage:
+ * ```
+ * const peerManager = new PeerManager(...);
+ * const rateLimits = {
+ *   subprotocol1: { peerLimit: { quotaCount: 10, quotaTimeMs: 1000 }, globalLimit: { quotaCount: 100, quotaTimeMs: 1000 } },
+ *   subprotocol2: { peerLimit: { quotaCount: 5, quotaTimeMs: 1000 }, globalLimit: { quotaCount: 50, quotaTimeMs: 1000 } }
+ * };
+ * const limiter = new RequestResponseRateLimiter(peerManager, rateLimits);
+ *
+ * Note: Ensure to call `stop()` when shutting down to properly clean up all subprotocol limiters.
+ */
+export declare class RequestResponseRateLimiter {
+    private peerScoring;
+    private subProtocolRateLimiters;
+    private cleanupInterval;
+    constructor(peerScoring: PeerScoring, rateLimits?: ReqRespSubProtocolRateLimits);
+    start(): void;
+    allow(subProtocol: ReqRespSubProtocol, peerId: PeerId): boolean;
+    cleanupInactivePeers(): void;
+    /**
+     * Make sure to call destroy on each of the sub protocol rate limiters when cleaning up
+     */
+    stop(): void;
+}
+export {};
+//# sourceMappingURL=rate_limiter.d.ts.map

package/dest/services/reqresp/rate-limiter/rate_limiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate_limiter.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/rate-limiter/rate_limiter.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,oCAAoC,CAAC;AACtE,OAAO,EAAE,KAAK,kBAAkB,EAAE,KAAK,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAM7F;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,eAAe;IAE1B,OAAO,CAAC,GAAG,CAAS;IAEpB,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAE1C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IAEvC;;;OAGG;gBACS,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAMnD,KAAK,IAAI,OAAO;CAWjB;AASD,aAAK,eAAe;IAClB,OAAO,IAAA;IACP,YAAY,IAAA;IACZ,UAAU,IAAA;CACX;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,YAAY,CAA2C;IAC/D,OAAO,CAAC,aAAa,CAAkB;IACvC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;gBAE7B,cAAc,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM;IAOhH,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe;IAwBtC,oBAAoB;CAQrB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,0BAA0B;IAKzB,OAAO,CAAC,WAAW;IAJ/B,OAAO,CAAC,uBAAuB,CAAkD;IAEjF,OAAO,CAAC,eAAe,CAAyC;gBAE5C,WAAW,EAAE,WAAW,EAAE,UAAU,GAAE,4BAAkD;IAgB5G,KAAK;IAML,KAAK,CAAC,WAAW,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO;IAoB/D,oBAAoB;IAIpB;;OAEG;IACH,IAAI;CAGL"}

package/dest/services/reqresp/rate-limiter/rate_limiter.js

@@ -2,7 +2,8 @@
  * @attribution Rate limiter approach implemented in the lodestar ethereum 2 client.
  * Rationale is that if it was good enough for them, then it should be good enough for us.
  * https://github.com/ChainSafe/lodestar
- */ import { PeerErrorSeverity } from '@aztec/circuit-types';
+ */
+import { PeerErrorSeverity } from '@aztec/circuit-types';
 import { DEFAULT_RATE_LIMITS } from './rate_limits.js';
 // Check for disconnected peers every 10 minutes
 const CHECK_DISCONNECTED_PEERS_INTERVAL_MS = 10 * 60 * 1000;
@@ -25,17 +26,13 @@ const CHECK_DISCONNECTED_PEERS_INTERVAL_MS = 10 * 60 * 1000;
  * ```
  * const limiter = new GCRARateLimiter(100, 60000); // 100 operations per minute
  * ```
- */ export class GCRARateLimiter {
-    // Virtual scheduling time: i.e. the time at which we should allow the next request
-    vst;
-    // The interval at which we emit a new token
-    emissionInterval;
-    // The interval over which we limit the number of requests
-    limitInterval;
+ */
+export class GCRARateLimiter {
     /**
-   * @param quotaCount - The number of requests to allow over the limit interval
-   * @param quotaTimeMs - The time interval over which the quotaCount applies
-   */ constructor(quotaCount, quotaTimeMs){
+     * @param quotaCount - The number of requests to allow over the limit interval
+     * @param quotaTimeMs - The time interval over which the quotaCount applies
+     */
+    constructor(quotaCount, quotaTimeMs) {
         this.emissionInterval = quotaTimeMs / quotaCount;
         this.limitInterval = quotaTimeMs;
         this.vst = Date.now();
@@ -50,12 +47,12 @@ const CHECK_DISCONNECTED_PEERS_INTERVAL_MS = 10 * 60 * 1000;
         return false;
     }
 }
-var RateLimitStatus = /*#__PURE__*/ function(RateLimitStatus) {
+var RateLimitStatus;
+(function (RateLimitStatus) {
     RateLimitStatus[RateLimitStatus["Allowed"] = 0] = "Allowed";
     RateLimitStatus[RateLimitStatus["DeniedGlobal"] = 1] = "DeniedGlobal";
     RateLimitStatus[RateLimitStatus["DeniedPeer"] = 2] = "DeniedPeer";
-    return RateLimitStatus;
-}(RateLimitStatus || {});
+})(RateLimitStatus || (RateLimitStatus = {}));
 /**
  * SubProtocolRateLimiter: A rate limiter for managing request rates on a per-peer and global basis for a specific subprotocol.
  *
@@ -71,12 +68,10 @@ var RateLimitStatus = /*#__PURE__*/ function(RateLimitStatus) {
  * - It periodically cleans up rate limiters for inactive peers to conserve memory.
  *
  * Note: Remember to call `start()` to begin the cleanup process and `stop()` when shutting down to clear the cleanup interval.
- */ export class SubProtocolRateLimiter {
-    peerLimiters = new Map();
-    globalLimiter;
-    peerQuotaCount;
-    peerQuotaTimeMs;
-    constructor(peerQuotaCount, peerQuotaTimeMs, globalQuotaCount, globalQuotaTimeMs){
+ */
+export class SubProtocolRateLimiter {
+    constructor(peerQuotaCount, peerQuotaTimeMs, globalQuotaCount, globalQuotaTimeMs) {
+        this.peerLimiters = new Map();
         this.peerLimiters = new Map();
         this.globalLimiter = new GCRARateLimiter(globalQuotaCount, globalQuotaTimeMs);
         this.peerQuotaCount = peerQuotaCount;
@@ -84,7 +79,7 @@ var RateLimitStatus = /*#__PURE__*/ function(RateLimitStatus) {
     }
     allow(peerId) {
         if (!this.globalLimiter.allow()) {
-            return 1;
+            return RateLimitStatus.DeniedGlobal;
         }
         const peerIdStr = peerId.toString();
         let peerLimiter = this.peerLimiters.get(peerIdStr);
@@ -92,21 +87,22 @@ var RateLimitStatus = /*#__PURE__*/ function(RateLimitStatus) {
             // Create a limiter for this peer
             peerLimiter = {
                 limiter: new GCRARateLimiter(this.peerQuotaCount, this.peerQuotaTimeMs),
-                lastAccess: Date.now()
+                lastAccess: Date.now(),
             };
             this.peerLimiters.set(peerIdStr, peerLimiter);
-        } else {
+        }
+        else {
             peerLimiter.lastAccess = Date.now();
         }
         const peerLimitAllowed = peerLimiter.limiter.allow();
         if (!peerLimitAllowed) {
-            return 2;
+            return RateLimitStatus.DeniedPeer;
         }
-        return 0;
+        return RateLimitStatus.Allowed;
     }
     cleanupInactivePeers() {
         const now = Date.now();
-        this.peerLimiters.forEach((peerLimiter, peerId)=>{
+        this.peerLimiters.forEach((peerLimiter, peerId) => {
             if (now - peerLimiter.lastAccess > CHECK_DISCONNECTED_PEERS_INTERVAL_MS) {
                 this.peerLimiters.delete(peerId);
             }
@@ -135,20 +131,18 @@ var RateLimitStatus = /*#__PURE__*/ function(RateLimitStatus) {
  * const limiter = new RequestResponseRateLimiter(peerManager, rateLimits);
  *
  * Note: Ensure to call `stop()` when shutting down to properly clean up all subprotocol limiters.
- */ export class RequestResponseRateLimiter {
-    peerScoring;
-    subProtocolRateLimiters;
-    cleanupInterval;
-    constructor(peerScoring, rateLimits = DEFAULT_RATE_LIMITS){
+ */
+export class RequestResponseRateLimiter {
+    constructor(peerScoring, rateLimits = DEFAULT_RATE_LIMITS) {
         this.peerScoring = peerScoring;
         this.cleanupInterval = undefined;
         this.subProtocolRateLimiters = new Map();
-        for (const [subProtocol, protocolLimits] of Object.entries(rateLimits)){
+        for (const [subProtocol, protocolLimits] of Object.entries(rateLimits)) {
             this.subProtocolRateLimiters.set(subProtocol, new SubProtocolRateLimiter(protocolLimits.peerLimit.quotaCount, protocolLimits.peerLimit.quotaTimeMs, protocolLimits.globalLimit.quotaCount, protocolLimits.globalLimit.quotaTimeMs));
         }
     }
     start() {
-        this.cleanupInterval = setInterval(()=>{
+        this.cleanupInterval = setInterval(() => {
             this.cleanupInactivePeers();
         }, CHECK_DISCONNECTED_PEERS_INTERVAL_MS);
     }
@@ -158,12 +152,12 @@ var RateLimitStatus = /*#__PURE__*/ function(RateLimitStatus) {
             return true;
         }
         const rateLimitStatus = limiter.allow(peerId);
-        switch(rateLimitStatus){
-            case 2:
+        switch (rateLimitStatus) {
+            case RateLimitStatus.DeniedPeer:
                 // Hitting a peer specific limit, we should lightly penalise the peer
                 this.peerScoring.penalizePeer(peerId, PeerErrorSeverity.HighToleranceError);
                 return false;
-            case 1:
+            case RateLimitStatus.DeniedGlobal:
                 // Hitting a global limit, we should not penalise the peer
                 return false;
             default:
@@ -171,11 +165,13 @@ var RateLimitStatus = /*#__PURE__*/ function(RateLimitStatus) {
         }
     }
     cleanupInactivePeers() {
-        this.subProtocolRateLimiters.forEach((limiter)=>limiter.cleanupInactivePeers());
+        this.subProtocolRateLimiters.forEach(limiter => limiter.cleanupInactivePeers());
     }
     /**
-   * Make sure to call destroy on each of the sub protocol rate limiters when cleaning up
-   */ stop() {
+     * Make sure to call destroy on each of the sub protocol rate limiters when cleaning up
+     */
+    stop() {
         clearInterval(this.cleanupInterval);
     }
 }
+//# sourceMappingURL=data:application/json;base64,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

package/dest/services/reqresp/rate-limiter/rate_limits.d.ts

@@ -0,0 +1,3 @@
+import { type ReqRespSubProtocolRateLimits } from '../interface.js';
+export declare const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits;
+//# sourceMappingURL=rate_limits.d.ts.map

package/dest/services/reqresp/rate-limiter/rate_limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate_limits.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/rate-limiter/rate_limits.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAGxF,eAAO,MAAM,mBAAmB,EAAE,4BAmDjC,CAAC"}

package/dest/services/reqresp/rate-limiter/rate_limits.js

@@ -4,51 +4,52 @@ export const DEFAULT_RATE_LIMITS = {
     [ReqRespSubProtocol.PING]: {
         peerLimit: {
             quotaTimeMs: 1000,
-            quotaCount: 5
+            quotaCount: 5,
         },
         globalLimit: {
             quotaTimeMs: 1000,
-            quotaCount: 10
-        }
+            quotaCount: 10,
+        },
     },
     [ReqRespSubProtocol.STATUS]: {
         peerLimit: {
             quotaTimeMs: 1000,
-            quotaCount: 5
+            quotaCount: 5,
         },
         globalLimit: {
             quotaTimeMs: 1000,
-            quotaCount: 10
-        }
+            quotaCount: 10,
+        },
     },
     [ReqRespSubProtocol.TX]: {
         peerLimit: {
             quotaTimeMs: 1000,
-            quotaCount: 10
+            quotaCount: 10,
         },
         globalLimit: {
             quotaTimeMs: 1000,
-            quotaCount: 20
-        }
+            quotaCount: 20,
+        },
     },
     [ReqRespSubProtocol.BLOCK]: {
         peerLimit: {
             quotaTimeMs: 1000,
-            quotaCount: 2
+            quotaCount: 2,
         },
         globalLimit: {
             quotaTimeMs: 1000,
-            quotaCount: 5
-        }
+            quotaCount: 5,
+        },
     },
     [ReqRespSubProtocol.GOODBYE]: {
         peerLimit: {
             quotaTimeMs: 1000,
-            quotaCount: 5
+            quotaCount: 5,
         },
         globalLimit: {
             quotaTimeMs: 1000,
-            quotaCount: 10
-        }
-    }
+            quotaCount: 10,
+        },
+    },
 };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmF0ZV9saW1pdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc2VydmljZXMvcmVxcmVzcC9yYXRlLWxpbWl0ZXIvcmF0ZV9saW1pdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGtCQUFrQixFQUFxQyxNQUFNLGlCQUFpQixDQUFDO0FBRXhGLDRDQUE0QztBQUM1QyxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBaUM7SUFDL0QsQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsRUFBRTtRQUN6QixTQUFTLEVBQUU7WUFDVCxXQUFXLEVBQUUsSUFBSTtZQUNqQixVQUFVLEVBQUUsQ0FBQztTQUNkO1FBQ0QsV0FBVyxFQUFFO1lBQ1gsV0FBVyxFQUFFLElBQUk7WUFDakIsVUFBVSxFQUFFLEVBQUU7U0FDZjtLQUNGO0lBQ0QsQ0FBQyxrQkFBa0IsQ0FBQyxNQUFNLENBQUMsRUFBRTtRQUMzQixTQUFTLEVBQUU7WUFDVCxXQUFXLEVBQUUsSUFBSTtZQUNqQixVQUFVLEVBQUUsQ0FBQztTQUNkO1FBQ0QsV0FBVyxFQUFFO1lBQ1gsV0FBVyxFQUFFLElBQUk7WUFDakIsVUFBVSxFQUFFLEVBQUU7U0FDZjtLQUNGO0lBQ0QsQ0FBQyxrQkFBa0IsQ0FBQyxFQUFFLENBQUMsRUFBRTtRQUN2QixTQUFTLEVBQUU7WUFDVCxXQUFXLEVBQUUsSUFBSTtZQUNqQixVQUFVLEVBQUUsRUFBRTtTQUNmO1FBQ0QsV0FBVyxFQUFFO1lBQ1gsV0FBVyxFQUFFLElBQUk7WUFDakIsVUFBVSxFQUFFLEVBQUU7U0FDZjtLQUNGO0lBQ0QsQ0FBQyxrQkFBa0IsQ0FBQyxLQUFLLENBQUMsRUFBRTtRQUMxQixTQUFTLEVBQUU7WUFDVCxXQUFXLEVBQUUsSUFBSTtZQUNqQixVQUFVLEVBQUUsQ0FBQztTQUNkO1FBQ0QsV0FBVyxFQUFFO1lBQ1gsV0FBVyxFQUFFLElBQUk7WUFDakIsVUFBVSxFQUFFLENBQUM7U0FDZDtLQUNGO0lBQ0QsQ0FBQyxrQkFBa0IsQ0FBQyxPQUFPLENBQUMsRUFBRTtRQUM1QixTQUFTLEVBQUU7WUFDVCxXQUFXLEVBQUUsSUFBSTtZQUNqQixVQUFVLEVBQUUsQ0FBQztTQUNkO1FBQ0QsV0FBVyxFQUFFO1lBQ1gsV0FBVyxFQUFFLElBQUk7WUFDakIsVUFBVSxFQUFFLEVBQUU7U0FDZjtLQUNGO0NBQ0YsQ0FBQyJ9

package/dest/services/reqresp/reqresp.d.ts

@@ -0,0 +1,166 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { type Logger } from '@aztec/foundation/log';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import { type PeerId } from '@libp2p/interface';
+import { type Libp2p } from 'libp2p';
+import { type PeerScoring } from '../peer-manager/peer_scoring.js';
+import { type P2PReqRespConfig } from './config.js';
+import { type ReqRespResponse, ReqRespSubProtocol, type ReqRespSubProtocolHandlers, type ReqRespSubProtocolValidators, type SubProtocolMap } from './interface.js';
+/**
+ * The Request Response Service
+ *
+ * It allows nodes to request specific information from their peers, its use case covers recovering
+ * information that was missed during a syncronisation or a gossip event.
+ *
+ * This service implements the request response sub protocol, it is heavily inspired from
+ * ethereum implementations of the same name.
+ *
+ * Note, responses get compressed in streamHandler
+ *       so they get decompressed in readMessage
+ *
+ * see: https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/p2p-interface.md#the-reqresp-domain
+ */
+export declare class ReqResp {
+    private libp2p;
+    private peerScoring;
+    protected readonly logger: Logger;
+    private overallRequestTimeoutMs;
+    private individualRequestTimeoutMs;
+    private subProtocolHandlers;
+    private subProtocolValidators;
+    private connectionSampler;
+    private rateLimiter;
+    private snappyTransform;
+    private metrics;
+    constructor(config: P2PReqRespConfig, libp2p: Libp2p, peerScoring: PeerScoring, telemetryClient?: TelemetryClient);
+    get tracer(): import("@aztec/telemetry-client").Tracer;
+    /**
+     * Start the reqresp service
+     */
+    start(subProtocolHandlers: ReqRespSubProtocolHandlers, subProtocolValidators: ReqRespSubProtocolValidators): Promise<void>;
+    /**
+     * Stop the reqresp service
+     */
+    stop(): Promise<void>;
+    /**
+     * Send a request to peers, returns the first response
+     *
+     * @param subProtocol - The protocol being requested
+     * @param request - The request to send
+     * @returns - The response from the peer, otherwise undefined
+     *
+     * @description
+     * This method attempts to send a request to all active peers using the specified sub-protocol.
+     * It opens a stream with each peer, sends the request, and awaits a response.
+     * If a valid response is received, it returns the response; otherwise, it continues to the next peer.
+     * If no response is received from any peer, it returns undefined.
+     *
+     * The method performs the following steps:
+     * - Sample a peer to send the request to.
+     * - Opens a stream with the peer using the specified sub-protocol.
+     *
+     * When a response is received, it is validated using the given sub protocols response validator.
+     * To see the interface for the response validator - see `interface.ts`
+     *
+     * Failing a response validation requests in a severe peer penalty, and will
+     * prompt the node to continue to search to the next peer.
+     * For example, a transaction request validator will check that the payload returned does in fact
+     * match the txHash that was requested. A peer that fails this check an only be an extremely naughty peer.
+     *
+     * This entire operation is wrapped in an overall timeout, that is independent of the
+     * peer it is requesting data from.
+     *
+     */
+    sendRequest<SubProtocol extends ReqRespSubProtocol>(subProtocol: SubProtocol, request: InstanceType<SubProtocolMap[SubProtocol]['request']>): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined>;
+    /**
+     * Request multiple messages over the same sub protocol, balancing the requests across peers.
+     *
+     * @devnote
+     * - The function prioritizes sending requests to free peers using a batch sampling strategy.
+     * - If a peer fails to respond or returns an invalid response, it is removed from the sampling pool and replaced.
+     * - The function stops retrying once all requests are processed, no active peers remain, or the maximum retry attempts are reached.
+     * - Responses are validated using a custom validator for the sub-protocol.*
+     *
+     * Requests are sent in parallel to each peer, but multiple requests are sent to the same peer in series
+     * - If a peer fails to respond or returns an invalid response, it is removed from the sampling pool and replaced.
+     * - The function stops retrying once all requests are processed, no active peers remain, or the maximum retry attempts are reached.
+     * - Responses are validated using a custom validator for the sub-protocol.*
+     *
+     * @param subProtocol
+     * @param requests
+     * @param timeoutMs
+     * @param maxPeers
+     * @returns
+     *
+     * @throws {CollectiveReqRespTimeoutError} - If the request batch exceeds the specified timeout (`timeoutMs`).
+     */
+    sendBatchRequest<SubProtocol extends ReqRespSubProtocol>(subProtocol: SubProtocol, requests: InstanceType<SubProtocolMap[SubProtocol]['request']>[], timeoutMs?: number, maxPeers?: number, maxRetryAttempts?: number): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']>[]>;
+    /**
+     * Sends a request to a specific peer
+     *
+     * We first dial a particular protocol for the peer, this ensures that the peer knows
+     * what to respond with
+     *
+     *
+     * @param peerId - The peer to send the request to
+     * @param subProtocol - The protocol to use to request
+     * @param payload - The payload to send
+     * @returns If the request is successful, the response is returned, otherwise undefined
+     *
+     * @description
+     * This method attempts to open a stream with the specified peer, send the payload,
+     * and await a response.
+     * If an error occurs, it penalizes the peer and returns undefined.
+     *
+     * The method performs the following steps:
+     * - Opens a stream with the peer using the specified sub-protocol.
+     * - Sends the payload and awaits a response with a timeout.
+     *
+     * If the stream is not closed by the dialled peer, and a timeout occurs, then
+     * the stream is closed on the requester's end and sender (us) updates its peer score
+     */
+    sendRequestToPeer(peerId: PeerId, subProtocol: ReqRespSubProtocol, payload: Buffer): Promise<ReqRespResponse | undefined>;
+    /**
+     * Handle a response error
+     *
+     * ReqResp errors are punished differently depending on the severity of the offense
+     *
+     * @param e - The error
+     * @param peerId - The peer id
+     * @param subProtocol - The sub protocol
+     * @returns If the error is non pubishable, then undefined is returned, otherwise the peer is penalized
+     */
+    private handleResponseError;
+    /**
+     * Categorize the error and log it.
+     */
+    private categorizeError;
+    /**
+     * Read a message returned from a stream into a single buffer
+     *
+     * The message is split into two components
+     * - The first chunk should contain a control byte, indicating the status of the response see `ReqRespStatus`
+     * - The second chunk should contain the response data
+     */
+    private readMessage;
+    /**
+     * Stream Handler
+     * Reads the incoming stream, determines the protocol, then triggers the appropriate handler
+     *
+     * @param param0 - The incoming stream data
+     *
+     * @description
+     * An individual stream handler will be bound to each sub protocol, and handles returning data back
+     * to the requesting peer.
+     *
+     * The sub protocol handler interface is defined within `interface.ts` and will be assigned to the
+     * req resp service on start up.
+     *
+     * We check rate limits for each peer, note the peer will be penalised within the rate limiter implementation
+     * if they exceed their peer specific limits.
+     */
+    private streamHandler;
+    private sendErrorChunk;
+}
+//# sourceMappingURL=reqresp.d.ts.map

package/dest/services/reqresp/reqresp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reqresp.d.ts","sourceRoot":"","sources":["../../../src/services/reqresp/reqresp.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAElE,OAAO,EAAc,KAAK,eAAe,EAAiC,MAAM,yBAAyB,CAAC;AAE1G,OAAO,EAA2B,KAAK,MAAM,EAAe,MAAM,mBAAmB,CAAC;AAEtF,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AASrC,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpD,OAAO,EAGL,KAAK,eAAe,EACpB,kBAAkB,EAClB,KAAK,0BAA0B,EAC/B,KAAK,4BAA4B,EACjC,KAAK,cAAc,EAEpB,MAAM,gBAAgB,CAAC;AAKxB;;;;;;;;;;;;;GAaG;AACH,qBAAa,OAAO;IAmBhB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,WAAW;IAnBrB,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAElC,OAAO,CAAC,uBAAuB,CAAS;IACxC,OAAO,CAAC,0BAA0B,CAAS;IAG3C,OAAO,CAAC,mBAAmB,CAA6D;IACxF,OAAO,CAAC,qBAAqB,CAAiE;IAE9F,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,WAAW,CAA6B;IAEhD,OAAO,CAAC,eAAe,CAAkB;IAEzC,OAAO,CAAC,OAAO,CAAiB;gBAG9B,MAAM,EAAE,gBAAgB,EAChB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,WAAW,EAChC,eAAe,GAAE,eAAsC;IAgBzD,IAAI,MAAM,6CAET;IAED;;OAEG;IACG,KAAK,CAAC,mBAAmB,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,4BAA4B;IAiBhH;;OAEG;IACG,IAAI;IAoBV;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACG,WAAW,CAAC,WAAW,SAAS,kBAAkB,EACtD,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,YAAY,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,CAAC,GAC5D,OAAO,CAAC,YAAY,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,UAAU,CAAC,CAAC,GAAG,SAAS,CAAC;IA8D7E;;;;;;;;;;;;;;;;;;;;;OAqBG;IAQG,gBAAgB,CAAC,WAAW,SAAS,kBAAkB,EAC3D,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,YAAY,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,EAChE,SAAS,SAAQ,EACjB,QAAQ,SAAgC,EACxC,gBAAgB,SAAI,GACnB,OAAO,CAAC,YAAY,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC;IA6HnE;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IAKU,iBAAiB,CAC5B,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,kBAAkB,EAC/B,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;IAgCvC;;;;;;;;;OASG;IACH,OAAO,CAAC,mBAAmB;IAO3B;;OAEG;IACH,OAAO,CAAC,eAAe;IAoDvB;;;;;;OAMG;YACW,WAAW;IAoCzB;;;;;;;;;;;;;;;OAeG;YAKW,aAAa;YA+DZ,cAAc;CAI9B"}