@aztec/p2p 0.0.0-test.0

package/dest/services/reqresp/interface.js

@@ -0,0 +1,84 @@
+import { Fr } from '@aztec/foundation/fields';
+import { L2Block } from '@aztec/stdlib/block';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
+/*
+ * Request Response Sub Protocols
+ */ export const PING_PROTOCOL = '/aztec/req/ping/0.1.0';
+export const STATUS_PROTOCOL = '/aztec/req/status/0.1.0';
+export const GOODBYE_PROTOCOL = '/aztec/req/goodbye/0.1.0';
+export const TX_REQ_PROTOCOL = '/aztec/req/tx/0.1.0';
+export const BLOCK_REQ_PROTOCOL = '/aztec/req/block/0.1.0';
+export var ReqRespSubProtocol = /*#__PURE__*/ function(ReqRespSubProtocol) {
+    ReqRespSubProtocol[ReqRespSubProtocol["PING"] = PING_PROTOCOL] = "PING";
+    ReqRespSubProtocol[ReqRespSubProtocol["STATUS"] = STATUS_PROTOCOL] = "STATUS";
+    ReqRespSubProtocol[ReqRespSubProtocol["GOODBYE"] = GOODBYE_PROTOCOL] = "GOODBYE";
+    ReqRespSubProtocol[ReqRespSubProtocol["TX"] = TX_REQ_PROTOCOL] = "TX";
+    ReqRespSubProtocol[ReqRespSubProtocol["BLOCK"] = BLOCK_REQ_PROTOCOL] = "BLOCK";
+    return ReqRespSubProtocol;
+}({});
+export const noopValidator = ()=>Promise.resolve(true);
+export const DEFAULT_SUB_PROTOCOL_VALIDATORS = {
+    [ReqRespSubProtocol.PING]: noopValidator,
+    [ReqRespSubProtocol.STATUS]: noopValidator,
+    [ReqRespSubProtocol.TX]: noopValidator,
+    [ReqRespSubProtocol.GOODBYE]: noopValidator,
+    [ReqRespSubProtocol.BLOCK]: noopValidator
+};
+/**
+ * Default handler for unimplemented sub protocols, this SHOULD be overwritten
+ * by the service, but is provided as a fallback
+ */ const defaultHandler = (_msg)=>{
+    return Promise.resolve(Buffer.from('unimplemented'));
+};
+/**
+ * Default sub protocol handlers - this SHOULD be overwritten by the service,
+ */ export const DEFAULT_SUB_PROTOCOL_HANDLERS = {
+    [ReqRespSubProtocol.PING]: defaultHandler,
+    [ReqRespSubProtocol.STATUS]: defaultHandler,
+    [ReqRespSubProtocol.TX]: defaultHandler,
+    [ReqRespSubProtocol.GOODBYE]: defaultHandler,
+    [ReqRespSubProtocol.BLOCK]: defaultHandler
+};
+/**
+ * RequestableBuffer is a wrapper around a buffer that allows it to be
+ * used in generic request response protocols
+ *
+ * An instance of the RequestResponsePair defined above
+ */ export class RequestableBuffer {
+    buffer;
+    constructor(buffer){
+        this.buffer = buffer;
+    }
+    toBuffer() {
+        return this.buffer;
+    }
+    static fromBuffer(buffer) {
+        return new RequestableBuffer(buffer);
+    }
+}
+/**
+ * A mapping from each protocol to their request and response types
+ * This defines the request and response types for each sub protocol, used primarily
+ * as a type rather than an object
+ */ export const subProtocolMap = {
+    [ReqRespSubProtocol.PING]: {
+        request: RequestableBuffer,
+        response: RequestableBuffer
+    },
+    [ReqRespSubProtocol.STATUS]: {
+        request: RequestableBuffer,
+        response: RequestableBuffer
+    },
+    [ReqRespSubProtocol.TX]: {
+        request: TxHash,
+        response: Tx
+    },
+    [ReqRespSubProtocol.GOODBYE]: {
+        request: RequestableBuffer,
+        response: RequestableBuffer
+    },
+    [ReqRespSubProtocol.BLOCK]: {
+        request: Fr,
+        response: L2Block
+    }
+};

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

@@ -0,0 +1,15 @@
+import type { TelemetryClient, Tracer } from '@aztec/telemetry-client';
+export declare class ReqRespMetrics {
+    readonly telemetryClient: TelemetryClient;
+    readonly tracer: Tracer;
+    private readonly sentRequests;
+    private readonly receivedRequests;
+    private readonly failedOutboundRequests;
+    private readonly failedInboundRequests;
+    constructor(telemetryClient: TelemetryClient, name?: string);
+    recordRequestSent(protocol: string): void;
+    recordRequestReceived(protocol: string): void;
+    recordRequestError(protocol: string): void;
+    recordResponseError(protocol: string): void;
+}
+//# sourceMappingURL=metrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../../../src/services/reqresp/metrics.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAiB,MAAM,yBAAyB,CAAC;AAEtF,qBAAa,cAAc;IASb,QAAQ,CAAC,eAAe,EAAE,eAAe;IARrD,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAgB;IAC7C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAgB;IAEjD,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAgB;IACvD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAgB;gBAEjC,eAAe,EAAE,eAAe,EAAE,IAAI,SAAY;IA4BhE,iBAAiB,CAAC,QAAQ,EAAE,MAAM;IAIlC,qBAAqB,CAAC,QAAQ,EAAE,MAAM;IAItC,kBAAkB,CAAC,QAAQ,EAAE,MAAM;IAInC,mBAAmB,CAAC,QAAQ,EAAE,MAAM;CAG5C"}

package/dest/services/reqresp/metrics.js

@@ -0,0 +1,55 @@
+// Request response metrics
+import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
+export class ReqRespMetrics {
+    telemetryClient;
+    tracer;
+    sentRequests;
+    receivedRequests;
+    failedOutboundRequests;
+    failedInboundRequests;
+    constructor(telemetryClient, name = 'ReqResp'){
+        this.telemetryClient = telemetryClient;
+        this.tracer = telemetryClient.getTracer(name);
+        const meter = telemetryClient.getMeter(name);
+        this.sentRequests = meter.createUpDownCounter(Metrics.P2P_REQ_RESP_SENT_REQUESTS, {
+            description: 'Number of requests sent to peers',
+            unit: 'requests',
+            valueType: ValueType.INT
+        });
+        this.receivedRequests = meter.createUpDownCounter(Metrics.P2P_REQ_RESP_RECEIVED_REQUESTS, {
+            description: 'Number of requests received from peers',
+            unit: 'requests',
+            valueType: ValueType.INT
+        });
+        this.failedOutboundRequests = meter.createUpDownCounter(Metrics.P2P_REQ_RESP_FAILED_OUTBOUND_REQUESTS, {
+            description: 'Number of failed outbound requests - nodes not getting valid responses',
+            unit: 'requests',
+            valueType: ValueType.INT
+        });
+        this.failedInboundRequests = meter.createUpDownCounter(Metrics.P2P_REQ_RESP_FAILED_INBOUND_REQUESTS, {
+            description: 'Number of failed inbound requests - node failing to respond to requests',
+            unit: 'requests',
+            valueType: ValueType.INT
+        });
+    }
+    recordRequestSent(protocol) {
+        this.sentRequests.add(1, {
+            [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol
+        });
+    }
+    recordRequestReceived(protocol) {
+        this.receivedRequests.add(1, {
+            [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol
+        });
+    }
+    recordRequestError(protocol) {
+        this.failedOutboundRequests.add(1, {
+            [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol
+        });
+    }
+    recordResponseError(protocol) {
+        this.failedInboundRequests.add(1, {
+            [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol
+        });
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { ReqRespSubProtocolHandler } from '../interface.js';
+export declare function reqRespBlockHandler(l2BlockSource: L2BlockSource): ReqRespSubProtocolHandler;
+//# sourceMappingURL=block.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/protocols/block.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAEjE,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,aAAa,GAAG,yBAAyB,CAO3F"}

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

@@ -0,0 +1,8 @@
+import { Fr } from '@aztec/foundation/fields';
+export function reqRespBlockHandler(l2BlockSource) {
+    return async (_peerId, msg)=>{
+        const blockNumber = Fr.fromBuffer(msg);
+        const foundBlock = await l2BlockSource.getBlock(Number(blockNumber));
+        return foundBlock ? foundBlock.toBuffer() : Buffer.alloc(0);
+    };
+}

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

@@ -0,0 +1,51 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { PeerId } from '@libp2p/interface';
+import type { PeerManager } from '../../peer-manager/peer_manager.js';
+import { type ReqRespSubProtocolHandler } from '../interface.js';
+import type { ReqResp } from '../reqresp.js';
+/**
+ * Enum defining the possible reasons for a goodbye message.
+ */
+export declare enum GoodByeReason {
+    /** The peer has shutdown, will be received whenever a peer's node is routinely stopped */
+    SHUTDOWN = 1,
+    /** The max peer count has been reached, will be received whenever a low scoring peer is disconnected to satisfy the max peer count */
+    MAX_PEERS = 2,
+    /** The peer has a low score, will be received whenever a peer's score is low */
+    LOW_SCORE = 3,
+    /** The peer has been banned, will be received whenever a peer is banned */
+    BANNED = 4,
+    /** Wrong network / fork */
+    WRONG_NETWORK = 5,
+    /** Unknown reason */
+    UNKNOWN = 6
+}
+export declare function encodeGoodbyeReason(reason: GoodByeReason): Buffer;
+export declare function decodeGoodbyeReason(buffer: Buffer): GoodByeReason;
+/**
+ * Pretty prints the goodbye reason.
+ * @param reason - The goodbye reason.
+ * @returns The pretty printed goodbye reason.
+ */
+export declare function prettyGoodbyeReason(reason: GoodByeReason): string;
+/**
+ * Handles a goodbye message request
+ */
+export declare class GoodbyeProtocolHandler {
+    private reqresp;
+    private logger;
+    constructor(reqresp: ReqResp);
+    sendGoodbye(peerId: PeerId, reason: GoodByeReason): Promise<void>;
+}
+/**
+ * Handles the goodbye request. In request response, the goodbye request is handled by the peer manager.
+ *
+ * @dev Implemented as returning a function as the function is bound in the libp2p service, however
+ *      its implementation is here to keep functionality together.
+ *
+ * @param peerManager - The peer manager.
+ * @returns A resolved promise with the goodbye response.
+ */
+export declare function reqGoodbyeHandler(peerManager: PeerManager): ReqRespSubProtocolHandler;
+//# sourceMappingURL=goodbye.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"goodbye.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/protocols/goodbye.ts"],"names":[],"mappings":";;AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AACtE,OAAO,EAAsB,KAAK,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AACrF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C;;GAEG;AACH,oBAAY,aAAa;IACvB,0FAA0F;IAC1F,QAAQ,IAAM;IACd,sIAAsI;IACtI,SAAS,IAAM;IACf,gFAAgF;IAChF,SAAS,IAAM;IACf,2EAA2E;IAC3E,MAAM,IAAM;IACZ,2BAA2B;IAC3B,aAAa,IAAM;IACnB,qBAAqB;IACrB,OAAO,IAAM;CACd;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAEjE;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,CASjE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAgBjE;AAED;;GAEG;AACH,qBAAa,sBAAsB;IAGrB,OAAO,CAAC,OAAO;IAF3B,OAAO,CAAC,MAAM,CAAwC;gBAElC,OAAO,EAAE,OAAO;IAEvB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CAQ/E;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,WAAW,GAAG,yBAAyB,CASrF"}

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

@@ -0,0 +1,87 @@
+import { createLogger } from '@aztec/foundation/log';
+import { ReqRespSubProtocol } from '../interface.js';
+/**
+ * Enum defining the possible reasons for a goodbye message.
+ */ export var GoodByeReason = /*#__PURE__*/ function(GoodByeReason) {
+    /** The peer has shutdown, will be received whenever a peer's node is routinely stopped */ GoodByeReason[GoodByeReason["SHUTDOWN"] = 1] = "SHUTDOWN";
+    /** The max peer count has been reached, will be received whenever a low scoring peer is disconnected to satisfy the max peer count */ GoodByeReason[GoodByeReason["MAX_PEERS"] = 2] = "MAX_PEERS";
+    /** The peer has a low score, will be received whenever a peer's score is low */ GoodByeReason[GoodByeReason["LOW_SCORE"] = 3] = "LOW_SCORE";
+    /** The peer has been banned, will be received whenever a peer is banned */ GoodByeReason[GoodByeReason["BANNED"] = 4] = "BANNED";
+    /** Wrong network / fork */ GoodByeReason[GoodByeReason["WRONG_NETWORK"] = 5] = "WRONG_NETWORK";
+    /** Unknown reason */ GoodByeReason[GoodByeReason["UNKNOWN"] = 6] = "UNKNOWN";
+    return GoodByeReason;
+}({});
+export function encodeGoodbyeReason(reason) {
+    return Buffer.from([
+        reason
+    ]);
+}
+export function decodeGoodbyeReason(buffer) {
+    try {
+        if (buffer.length !== 1) {
+            throw new Error('Invalid goodbye reason buffer length');
+        }
+        return buffer[0];
+    } catch (error) {
+        return 6;
+    }
+}
+/**
+ * Pretty prints the goodbye reason.
+ * @param reason - The goodbye reason.
+ * @returns The pretty printed goodbye reason.
+ */ export function prettyGoodbyeReason(reason) {
+    switch(reason){
+        case 1:
+            return 'shutdown';
+        case 2:
+            return 'max_peers';
+        case 3:
+            return 'low_score';
+        case 4:
+            return 'banned';
+        // TODO(#11328): implement
+        case 5:
+            return 'wrong_network';
+        case 6:
+            return 'unknown';
+    }
+}
+/**
+ * Handles a goodbye message request
+ */ export class GoodbyeProtocolHandler {
+    reqresp;
+    logger;
+    constructor(reqresp){
+        this.reqresp = reqresp;
+        this.logger = createLogger('p2p:goodbye-protocol');
+    }
+    async sendGoodbye(peerId, reason) {
+        try {
+            await this.reqresp.sendRequestToPeer(peerId, ReqRespSubProtocol.GOODBYE, Buffer.from([
+                reason
+            ]));
+            this.logger.debug(`Sent goodbye to peer ${peerId.toString()} with reason ${reason}`);
+        } catch (error) {
+            this.logger.debug(`Failed to send goodbye to peer ${peerId.toString()}: ${error}`);
+        }
+    }
+}
+/**
+ * Handles the goodbye request. In request response, the goodbye request is handled by the peer manager.
+ *
+ * @dev Implemented as returning a function as the function is bound in the libp2p service, however
+ *      its implementation is here to keep functionality together.
+ *
+ * @param peerManager - The peer manager.
+ * @returns A resolved promise with the goodbye response.
+ */ export function reqGoodbyeHandler(peerManager) {
+    return (peerId, _msg)=>{
+        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
+        ]));
+    };
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Request Response protocol handlers
+ */
+export * from './ping.js';
+export * from './status.js';
+export * from './tx.js';
+export * from './goodbye.js';
+export * from './block.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/protocols/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

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

@@ -0,0 +1,7 @@
+/**
+ * Request Response protocol handlers
+ */ export * from './ping.js';
+export * from './status.js';
+export * from './tx.js';
+export * from './goodbye.js';
+export * from './block.js';

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

@@ -0,0 +1,9 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * Handles the ping request.
+ * @param _msg - The ping request message.
+ * @returns A resolved promise with the pong response.
+ */
+export declare function pingHandler(_msg: any): Promise<Buffer>;
+//# sourceMappingURL=ping.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ping.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/protocols/ping.ts"],"names":[],"mappings":";;AAAA;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAEtD"}

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

@@ -0,0 +1,7 @@
+/**
+ * Handles the ping request.
+ * @param _msg - The ping request message.
+ * @returns A resolved promise with the pong response.
+ */ export function pingHandler(_msg) {
+    return Promise.resolve(Buffer.from('pong'));
+}

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

@@ -0,0 +1,9 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * Handles the status request.
+ * @param _msg - The status request message.
+ * @returns A resolved promise with the ok response.
+ */
+export declare function statusHandler(_msg: any): Promise<Buffer>;
+//# sourceMappingURL=status.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/protocols/status.ts"],"names":[],"mappings":";;AAAA;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAExD"}

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

@@ -0,0 +1,7 @@
+/**
+ * Handles the status request.
+ * @param _msg - The status request message.
+ * @returns A resolved promise with the ok response.
+ */ export function statusHandler(_msg) {
+    return Promise.resolve(Buffer.from('ok'));
+}

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

@@ -0,0 +1,13 @@
+import type { P2PClientType } from '@aztec/stdlib/p2p';
+import type { MemPools } from '../../../mem_pools/interface.js';
+import type { ReqRespSubProtocolHandler } from '../interface.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
+ * so we need to pass it in as a parameter.
+ *
+ * Handler for tx requests
+ * @param mempools - the mempools
+ * @returns the tx response message
+ */
+export declare function reqRespTxHandler<T extends P2PClientType>(mempools: MemPools<T>): ReqRespSubProtocolHandler;
+//# sourceMappingURL=tx.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tx.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/protocols/tx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAKvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAEjE;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,aAAa,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,yBAAyB,CAY1G"}

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

@@ -0,0 +1,20 @@
+import { TxHash } from '@aztec/stdlib/tx';
+/**
+ * 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
+ * so we need to pass it in as a parameter.
+ *
+ * Handler for tx requests
+ * @param mempools - the mempools
+ * @returns the tx response message
+ */ export function reqRespTxHandler(mempools) {
+    /**
+   * 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;
+    };
+}

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

@@ -0,0 +1 @@
+export { RequestResponseRateLimiter } from './rate_limiter.js';

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, 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;
+}
+export declare enum RateLimitStatus {
+    DeniedGlobal = 0,
+    DeniedPeer = 1,
+    Allowed = 2
+}
+export declare function prettyPrintRateLimitStatus(status: RateLimitStatus): "DeniedGlobal" | "DeniedPeer" | "Allowed";
+/**
+ * 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): RateLimitStatus;
+    cleanupInactivePeers(): void;
+    /**
+     * Make sure to call destroy on each of the sub protocol rate limiters when cleaning up
+     */
+    stop(): void;
+}
+//# 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,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAMxF;;;;;;;;;;;;;;;;;;;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,oBAAY,eAAe;IACzB,YAAY,IAAA;IACZ,UAAU,IAAA;IACV,OAAO,IAAA;CACR;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,eAAe,6CASjE;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,eAAe;IAavE,oBAAoB;IAIpB;;OAEG;IACH,IAAI;CAGL"}