@aztec-labs/p2p 6.0.0-nightly.20260829

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

@@ -0,0 +1,87 @@
+import { createLogger } from '@aztec-labs/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  {
+        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);
+        // 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/dest/services/reqresp/protocols/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Request Response protocol handlers
+ */
+export * from './ping.js';
+export * from './status.js';
+export * from './tx.js';
+export * from './goodbye.js';
+export * from './auth.js';
+export * from './block_txs/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9zZXJ2aWNlcy9yZXFyZXNwL3Byb3RvY29scy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsc0JBQXNCLENBQUMifQ==

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,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC"}

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

@@ -0,0 +1,8 @@
+/**
+ * Request Response protocol handlers
+ */ export * from './ping.js';
+export * from './status.js';
+export * from './tx.js';
+export * from './goodbye.js';
+export * from './auth.js';
+export * from './block_txs/index.js';

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

@@ -0,0 +1,7 @@
+/**
+ * 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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGluZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3NlcnZpY2VzL3JlcXJlc3AvcHJvdG9jb2xzL3BpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUNILHdCQUFnQixXQUFXLENBQUMsSUFBSSxFQUFFLEdBQUcsR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLENBRXREIn0=

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,42 @@
+import { BlockNumber } from '@aztec-labs/foundation/branded-types';
+import type { Logger } from '@aztec-labs/foundation/log';
+import { BufferReader } from '@aztec-labs/foundation/serialize';
+import type { WorldStateSyncStatus, WorldStateSynchronizer } from '@aztec-labs/stdlib/interfaces/server';
+import type { PeerId } from '@libp2p/interface';
+export declare class StatusMessage {
+    readonly compressedComponentsVersion: string;
+    readonly latestBlockNumber: BlockNumber;
+    readonly latestBlockHash: string;
+    readonly finalizedBlockNumber: BlockNumber;
+    constructor(compressedComponentsVersion: string, latestBlockNumber: BlockNumber, latestBlockHash: string, finalizedBlockNumber: BlockNumber);
+    /**
+     * 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;
+    /**
+     * Serializes the StatusMessage object into a Buffer.
+     * @returns Buffer representation of the StatusMessage object.
+     */
+    toBuffer(): Buffer<ArrayBufferLike>;
+    /**
+     * 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;
+    static random(): StatusMessage;
+    validate(peerStatus: StatusMessage): boolean;
+    equals(other: StatusMessage): boolean;
+}
+/**
+ * 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 declare function reqRespStatusHandler(compressedComponentsVersion: string, worldStateSynchronizer: WorldStateSynchronizer, logger?: Logger): (peerId: PeerId, _msg: Buffer<ArrayBufferLike>) => Promise<Buffer<ArrayBufferLike>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhdHVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc2VydmljZXMvcmVxcmVzcC9wcm90b2NvbHMvc3RhdHVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUVuRSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUN6RCxPQUFPLEVBQUUsWUFBWSxFQUFxQixNQUFNLGtDQUFrQyxDQUFDO0FBRW5GLE9BQU8sS0FBSyxFQUFFLG9CQUFvQixFQUFFLHNCQUFzQixFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFDekcsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFVaEQscUJBQWEsYUFBYTtJQUV0QixRQUFRLENBQUMsMkJBQTJCLEVBQUUsTUFBTTtJQUM1QyxRQUFRLENBQUMsaUJBQWlCLEVBQUUsV0FBVztJQUN2QyxRQUFRLENBQUMsZUFBZSxFQUFFLE1BQU07SUFDaEMsUUFBUSxDQUFDLG9CQUFvQixFQUFFLFdBQVc7SUFKNUMsWUFDVywyQkFBMkIsRUFBRSxNQUFNLEVBQ25DLGlCQUFpQixFQUFFLFdBQVcsRUFDOUIsZUFBZSxFQUFFLE1BQU0sRUFDdkIsb0JBQW9CLEVBQUUsV0FBVyxFQUkzQztJQUVEOzs7O09BSUc7SUFDSCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsWUFBWSxHQUFHLGFBQWEsQ0FVOUQ7SUFFRDs7O09BR0c7SUFDSCxRQUFRLDRCQVNQO0lBRUQ7Ozs7O09BS0c7SUFDSCxNQUFNLENBQUMsd0JBQXdCLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQUUsb0JBQW9CLEdBQUcsYUFBYSxDQVFoRztJQUVELE1BQU0sQ0FBQyxNQUFNLElBQUksYUFBYSxDQVE3QjtJQUVELFFBQVEsQ0FBQyxVQUFVLEVBQUUsYUFBYSxHQUFHLE9BQU8sQ0FHM0M7SUFFRCxNQUFNLENBQUMsS0FBSyxFQUFFLGFBQWEsR0FBRyxPQUFPLENBT3BDO0NBQ0Y7QUFFRDs7Ozs7O0dBTUc7QUFDSCx3QkFBZ0Isb0JBQW9CLENBQ2xDLDJCQUEyQixFQUFFLE1BQU0sRUFDbkMsc0JBQXNCLEVBQUUsc0JBQXNCLEVBQzlDLE1BQU0sQ0FBQyxFQUFFLE1BQU0sdUZBWWhCIn0=

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,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAEnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,YAAY,EAAqB,MAAM,kCAAkC,CAAC;AAEnF,OAAO,KAAK,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AACzG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAUhD,qBAAa,aAAa;IAEtB,QAAQ,CAAC,2BAA2B,EAAE,MAAM;IAC5C,QAAQ,CAAC,iBAAiB,EAAE,WAAW;IACvC,QAAQ,CAAC,eAAe,EAAE,MAAM;IAChC,QAAQ,CAAC,oBAAoB,EAAE,WAAW;IAJ5C,YACW,2BAA2B,EAAE,MAAM,EACnC,iBAAiB,EAAE,WAAW,EAC9B,eAAe,EAAE,MAAM,EACvB,oBAAoB,EAAE,WAAW,EAI3C;IAED;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa,CAU9D;IAED;;;OAGG;IACH,QAAQ,4BASP;IAED;;;;;OAKG;IACH,MAAM,CAAC,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,oBAAoB,GAAG,aAAa,CAQhG;IAED,MAAM,CAAC,MAAM,IAAI,aAAa,CAQ7B;IAED,QAAQ,CAAC,UAAU,EAAE,aAAa,GAAG,OAAO,CAG3C;IAED,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAOpC;CACF;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,2BAA2B,EAAE,MAAM,EACnC,sBAAsB,EAAE,sBAAsB,EAC9C,MAAM,CAAC,EAAE,MAAM,uFAYhB"}

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

@@ -0,0 +1,78 @@
+import { BlockNumber } from '@aztec-labs/foundation/branded-types';
+import { Buffer32 } from '@aztec-labs/foundation/buffer';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { bufferToHex } from '@aztec-labs/foundation/string';
+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 {
+    compressedComponentsVersion;
+    latestBlockNumber;
+    latestBlockHash;
+    finalizedBlockNumber;
+    constructor(compressedComponentsVersion, latestBlockNumber, latestBlockHash, finalizedBlockNumber){
+        this.compressedComponentsVersion = compressedComponentsVersion;
+        this.latestBlockNumber = latestBlockNumber;
+        this.latestBlockHash = latestBlockHash;
+        this.finalizedBlockNumber = finalizedBlockNumber;
+    //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) {
+        const reader = BufferReader.asReader(buffer);
+        return new StatusMessage(reader.readString(MAX_VERSION_STRING_LENGTH), BlockNumber(reader.readNumber()), reader.readString(MAX_BLOCK_HASH_STRING_LENGTH), BlockNumber(reader.readNumber()));
+    }
+    /**
+   * 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
+        ]);
+    }
+    /**
+   * Builds Status message
+   * @param  version - Compressed Components Version
+   * @param  worldStateSyncStatus - Info about the current sync status
+   * @returns StatusMessage instance
+   */ static fromWorldStateSyncStatus(version, syncStatus) {
+        return new StatusMessage(version, BlockNumber(syncStatus.latestBlockNumber), syncStatus.latestBlockHash, BlockNumber(syncStatus.finalizedBlockNumber));
+    }
+    static random() {
+        return new StatusMessage('1.0.0', BlockNumber(Math.floor(Math.random() * 100)), Buffer32.random().toString(), BlockNumber(Math.floor(Math.random() * 100)));
+    }
+    validate(peerStatus) {
+        // TODO: Validate other fields as well
+        return this.compressedComponentsVersion === peerStatus.compressedComponentsVersion;
+    }
+    equals(other) {
+        return this.compressedComponentsVersion === other.compressedComponentsVersion && this.latestBlockNumber === other.latestBlockNumber && this.latestBlockHash === other.latestBlockHash && this.finalizedBlockNumber === other.finalizedBlockNumber;
+    }
+}
+/**
+ * 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 reqRespStatusHandler(compressedComponentsVersion, worldStateSynchronizer, logger) {
+    return async (peerId, _msg)=>{
+        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/dest/services/reqresp/protocols/tx.d.ts

@@ -0,0 +1,29 @@
+import { TxHash, TxHashArray } from '@aztec-labs/stdlib/tx';
+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 request handler
+ */
+export declare function reqRespTxHandler(mempools: MemPools): ReqRespSubProtocolHandler;
+/**
+ * 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 declare function chunkTxHashesRequest(hashes: TxHash[], chunkSize?: number): Array<TxHashArray>;
+/**
+ * Calculate the expected response size for a TX request.
+ * @param requestBuffer - The serialized request buffer containing TxHashArray
+ * @returns Expected response size in KB
+ */
+export declare function calculateTxResponseSize(requestBuffer: Buffer): number;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9zZXJ2aWNlcy9yZXFyZXNwL3Byb3RvY29scy90eC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQVcsTUFBTSxFQUFFLFdBQVcsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBR3JFLE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2hFLE9BQU8sS0FBSyxFQUFFLHlCQUF5QixFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFHakU7Ozs7Ozs7R0FPRztBQUNILHdCQUFnQixnQkFBZ0IsQ0FBQyxRQUFRLEVBQUUsUUFBUSxHQUFHLHlCQUF5QixDQXdCOUU7QUFFRDs7Ozs7Ozs7R0FRRztBQUNILHdCQUFnQixvQkFBb0IsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLEVBQUUsU0FBUyxTQUFJLEdBQUcsS0FBSyxDQUFDLFdBQVcsQ0FBQyxDQUV4RjtBQUVEOzs7O0dBSUc7QUFDSCx3QkFBZ0IsdUJBQXVCLENBQUMsYUFBYSxFQUFFLE1BQU0sR0FBRyxNQUFNLENBY3JFIn0=

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":"AAEA,OAAO,EAAW,MAAM,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGrE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAGjE;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,yBAAyB,CAwB9E;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,SAAS,SAAI,GAAG,KAAK,CAAC,WAAW,CAAC,CAExF;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAcrE"}

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

@@ -0,0 +1,66 @@
+import { chunk } from '@aztec-labs/foundation/collection';
+import { MAX_TX_SIZE_KB } from '@aztec-labs/stdlib/p2p';
+import { TxArray, TxHashArray } from '@aztec-labs/stdlib/tx';
+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
+ * so we need to pass it in as a parameter.
+ *
+ * Handler for tx requests
+ * @param mempools - the mempools
+ * @returns the Tx request handler
+ */ export function reqRespTxHandler(mempools) {
+    /**
+   * 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, msg)=>{
+        let txHashes;
+        try {
+            txHashes = TxHashArray.fromBuffer(msg);
+        } catch (err) {
+            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) {
+            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, chunkSize = 8) {
+    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) {
+    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/dest/services/reqresp/rate-limiter/index.d.ts

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

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,105 @@
+import type { PeerId } from '@libp2p/interface';
+import type { PeerScoring } from '../../peer-manager/peer_scoring.js';
+import type { ProtocolRateLimitQuota, 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): "Allowed" | "DeniedGlobal" | "DeniedPeer";
+/**
+ * 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 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.
+ *
+ * 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 rateLimits;
+    private cleanupInterval;
+    constructor(peerScoring: PeerScoring, rateLimits?: Partial<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;
+    getRateLimits(protocol: ReqRespSubProtocol): ProtocolRateLimitQuota;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmF0ZV9saW1pdGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc2VydmljZXMvcmVxcmVzcC9yYXRlLWxpbWl0ZXIvcmF0ZV9saW1pdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRWhELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ3RFLE9BQU8sS0FBSyxFQUFFLHNCQUFzQixFQUFFLGtCQUFrQixFQUFFLDRCQUE0QixFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFNaEg7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FtQkc7QUFDSCxxQkFBYSxlQUFlO0lBRTFCLE9BQU8sQ0FBQyxHQUFHLENBQVM7SUFFcEIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxnQkFBZ0IsQ0FBUztJQUUxQyxPQUFPLENBQUMsUUFBUSxDQUFDLGFBQWEsQ0FBUztJQUV2Qzs7O09BR0c7SUFDSCxZQUFZLFVBQVUsRUFBRSxNQUFNLEVBQUUsV0FBVyxFQUFFLE1BQU0sRUFJbEQ7SUFFRCxLQUFLLElBQUksT0FBTyxDQVVmO0NBQ0Y7QUFTRCxvQkFBWSxlQUFlO0lBQ3pCLFlBQVksSUFBQTtJQUNaLFVBQVUsSUFBQTtJQUNWLE9BQU8sSUFBQTtDQUNSO0FBRUQsd0JBQWdCLDBCQUEwQixDQUFDLE1BQU0sRUFBRSxlQUFlLDZDQVNqRTtBQUVEOzs7Ozs7Ozs7Ozs7Ozs7O0dBZ0JHO0FBQ0gscUJBQWEsc0JBQXNCO0lBQ2pDLE9BQU8sQ0FBQyxZQUFZLENBQTJDO0lBQy9ELE9BQU8sQ0FBQyxhQUFhLENBQWtCO0lBQ3ZDLE9BQU8sQ0FBQyxRQUFRLENBQUMsY0FBYyxDQUFTO0lBQ3hDLE9BQU8sQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUFTO0lBRXpDLFlBQVksY0FBYyxFQUFFLE1BQU0sRUFBRSxlQUFlLEVBQUUsTUFBTSxFQUFFLGdCQUFnQixFQUFFLE1BQU0sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLEVBSy9HO0lBRUQsS0FBSyxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsZUFBZSxDQXlCckM7SUFFRCxvQkFBb0IsU0FPbkI7Q0FDRjtBQUVEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBc0JHO0FBQ0gscUJBQWEsMEJBQTBCO0lBT25DLE9BQU8sQ0FBQyxXQUFXO0lBTnJCLE9BQU8sQ0FBQyx1QkFBdUIsQ0FBa0Q7SUFDakYsT0FBTyxDQUFDLFVBQVUsQ0FBK0I7SUFFakQsT0FBTyxDQUFDLGVBQWUsQ0FBeUM7SUFFaEUsWUFDVSxXQUFXLEVBQUUsV0FBVyxFQUNoQyxVQUFVLEdBQUUsT0FBTyxDQUFDLDRCQUE0QixDQUFNLEVBZ0J2RDtJQUVELEtBQUssU0FJSjtJQUVELEtBQUssQ0FBQyxXQUFXLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxFQUFFLE1BQU0sR0FBRyxlQUFlLENBV3RFO0lBRUQsb0JBQW9CLFNBRW5CO0lBRUQ7O09BRUc7SUFDSCxJQUFJLFNBRUg7SUFFRCxhQUFhLENBQUMsUUFBUSxFQUFFLGtCQUFrQixHQUFHLHNCQUFzQixDQUVsRTtDQUNGIn0=

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":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AACtE,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAMhH;;;;;;;;;;;;;;;;;;;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;IACH,YAAY,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAIlD;IAED,KAAK,IAAI,OAAO,CAUf;CACF;AASD,oBAAY,eAAe;IACzB,YAAY,IAAA;IACZ,UAAU,IAAA;IACV,OAAO,IAAA;CACR;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,eAAe,6CASjE;AAED;;;;;;;;;;;;;;;;GAgBG;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;IAEzC,YAAY,cAAc,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAK/G;IAED,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CAyBrC;IAED,oBAAoB,SAOnB;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,0BAA0B;IAOnC,OAAO,CAAC,WAAW;IANrB,OAAO,CAAC,uBAAuB,CAAkD;IACjF,OAAO,CAAC,UAAU,CAA+B;IAEjD,OAAO,CAAC,eAAe,CAAyC;IAEhE,YACU,WAAW,EAAE,WAAW,EAChC,UAAU,GAAE,OAAO,CAAC,4BAA4B,CAAM,EAgBvD;IAED,KAAK,SAIJ;IAED,KAAK,CAAC,WAAW,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe,CAWtE;IAED,oBAAoB,SAEnB;IAED;;OAEG;IACH,IAAI,SAEH;IAED,aAAa,CAAC,QAAQ,EAAE,kBAAkB,GAAG,sBAAsB,CAElE;CACF"}