@aztec/p2p 0.0.0-test.0

package/dest/services/reqresp/reqresp.js

@@ -0,0 +1,516 @@
+// @attribution: lodestar impl for inspiration
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { createLogger } from '@aztec/foundation/log';
+import { executeTimeout } from '@aztec/foundation/timer';
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+import { pipe } from 'it-pipe';
+import { CollectiveReqRespTimeoutError, IndividualReqRespTimeoutError, InvalidResponseError } from '../../errors/reqresp.error.js';
+import { SnappyTransform } from '../encoding.js';
+import { BatchConnectionSampler } from './connection-sampler/batch_connection_sampler.js';
+import { ConnectionSampler } from './connection-sampler/connection_sampler.js';
+import { DEFAULT_SUB_PROTOCOL_HANDLERS, DEFAULT_SUB_PROTOCOL_VALIDATORS, ReqRespSubProtocol, subProtocolMap } from './interface.js';
+import { ReqRespMetrics } from './metrics.js';
+import { RateLimitStatus, RequestResponseRateLimiter, prettyPrintRateLimitStatus } from './rate-limiter/rate_limiter.js';
+import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqRespStatus } from './status.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 class ReqResp {
+    libp2p;
+    peerScoring;
+    logger;
+    overallRequestTimeoutMs;
+    individualRequestTimeoutMs;
+    // Warning, if the `start` function is not called as the parent class constructor, then the default sub protocol handlers will be used ( not good )
+    subProtocolHandlers;
+    subProtocolValidators;
+    connectionSampler;
+    rateLimiter;
+    snappyTransform;
+    metrics;
+    constructor(config, libp2p, peerScoring, telemetryClient = getTelemetryClient()){
+        this.libp2p = libp2p;
+        this.peerScoring = peerScoring;
+        this.subProtocolHandlers = DEFAULT_SUB_PROTOCOL_HANDLERS;
+        this.subProtocolValidators = DEFAULT_SUB_PROTOCOL_VALIDATORS;
+        this.logger = createLogger('p2p:reqresp');
+        this.overallRequestTimeoutMs = config.overallRequestTimeoutMs;
+        this.individualRequestTimeoutMs = config.individualRequestTimeoutMs;
+        this.rateLimiter = new RequestResponseRateLimiter(peerScoring);
+        // Connection sampler is used to sample our connected peers
+        this.connectionSampler = new ConnectionSampler(libp2p);
+        this.snappyTransform = new SnappyTransform();
+        this.metrics = new ReqRespMetrics(telemetryClient);
+    }
+    get tracer() {
+        return this.metrics.tracer;
+    }
+    /**
+   * Start the reqresp service
+   */ async start(subProtocolHandlers, subProtocolValidators) {
+        this.subProtocolHandlers = subProtocolHandlers;
+        this.subProtocolValidators = subProtocolValidators;
+        // Register all protocol handlers
+        for (const subProtocol of Object.keys(this.subProtocolHandlers)){
+            await this.libp2p.handle(subProtocol, (data)=>void this.streamHandler(subProtocol, data).catch((err)=>this.logger.error(`Error on libp2p subprotocol ${subProtocol} handler`, err)));
+        }
+        this.rateLimiter.start();
+    }
+    /**
+   * Stop the reqresp service
+   */ async stop() {
+        // Unregister handlers in parallel
+        const unregisterPromises = Object.keys(this.subProtocolHandlers).map((protocol)=>this.libp2p.unhandle(protocol));
+        await Promise.all(unregisterPromises);
+        // Close connection sampler
+        await this.connectionSampler.stop();
+        this.logger.debug('ReqResp: Connection sampler stopped');
+        // Close streams in parallel
+        const closeStreamPromises = this.libp2p.getConnections().map((connection)=>connection.close());
+        await Promise.all(closeStreamPromises);
+        this.logger.debug('ReqResp: All active streams closed');
+        this.rateLimiter.stop();
+        this.logger.debug('ReqResp: Rate limiter stopped');
+    // NOTE: We assume libp2p instance is managed by the caller
+    }
+    /**
+   * 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.
+   *
+   */ async sendRequest(subProtocol, request) {
+        const responseValidator = this.subProtocolValidators[subProtocol];
+        const requestBuffer = request.toBuffer();
+        const requestFunction = async ()=>{
+            // Attempt to ask all of our peers, but sampled in a random order
+            // This function is wrapped in a timeout, so we will exit the loop if we have not received a response
+            const numberOfPeers = this.libp2p.getPeers().length;
+            if (numberOfPeers === 0) {
+                this.logger.debug('No active peers to send requests to');
+                return undefined;
+            }
+            const attemptedPeers = new Map();
+            for(let i = 0; i < numberOfPeers; i++){
+                // Sample a peer to make a request to
+                const peer = this.connectionSampler.getPeer(attemptedPeers);
+                this.logger.trace(`Attempting to send request to peer: ${peer?.toString()}`);
+                if (!peer) {
+                    this.logger.debug('No peers available to send requests to');
+                    return undefined;
+                }
+                attemptedPeers.set(peer.toString(), true);
+                this.logger.trace(`Sending request to peer: ${peer.toString()}`);
+                const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffer);
+                if (response && response.status !== ReqRespStatus.SUCCESS) {
+                    this.logger.debug(`Request to peer ${peer.toString()} failed with status ${prettyPrintReqRespStatus(response.status)}`);
+                    continue;
+                }
+                // If we get a response, return it, otherwise we iterate onto the next peer
+                // We do not consider it a success if we have an empty buffer
+                if (response && response.data.length > 0) {
+                    const object = subProtocolMap[subProtocol].response.fromBuffer(response.data);
+                    // The response validator handles peer punishment within
+                    const isValid = await responseValidator(request, object, peer);
+                    if (!isValid) {
+                        throw new InvalidResponseError();
+                    }
+                    return object;
+                }
+            }
+        };
+        try {
+            return await executeTimeout(requestFunction, this.overallRequestTimeoutMs, ()=>new CollectiveReqRespTimeoutError());
+        } catch (e) {
+            this.logger.debug(`${e.message} | subProtocol: ${subProtocol}`);
+            return 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`).
+   */ async sendBatchRequest(subProtocol, requests, timeoutMs = 10000, maxPeers = Math.min(10, requests.length), maxRetryAttempts = 3) {
+        const responseValidator = this.subProtocolValidators[subProtocol];
+        const responses = new Array(requests.length);
+        const requestBuffers = requests.map((req)=>req.toBuffer());
+        const requestFunction = async ()=>{
+            // Track which requests still need to be processed
+            const pendingRequestIndices = new Set(requestBuffers.map((_, i)=>i));
+            // Create batch sampler with the total number of requests and max peers
+            const batchSampler = new BatchConnectionSampler(this.connectionSampler, requests.length, maxPeers);
+            if (batchSampler.activePeerCount === 0) {
+                this.logger.debug('No active peers to send requests to');
+                return [];
+            }
+            // This is where it gets fun
+            // The outer loop is the retry loop, we will continue to retry until we process all indices we have
+            // not received a response for, or we have reached the max retry attempts
+            // The inner loop is the batch loop, we will process all requests for each peer in parallel
+            // We will then process the results of the requests, and resample any peers that failed to respond
+            // We will continue to retry until we have processed all indices, or we have reached the max retry attempts
+            let retryAttempts = 0;
+            while(pendingRequestIndices.size > 0 && batchSampler.activePeerCount > 0 && retryAttempts < maxRetryAttempts){
+                // Process requests in parallel for each available peer
+                const requestBatches = new Map();
+                // Group requests by peer
+                for (const requestIndex of pendingRequestIndices){
+                    const peer = batchSampler.getPeerForRequest(requestIndex);
+                    if (!peer) {
+                        break;
+                    }
+                    if (!requestBatches.has(peer)) {
+                        requestBatches.set(peer, []);
+                    }
+                    requestBatches.get(peer).push(requestIndex);
+                }
+                // Make parallel requests for each peer's batch
+                // A batch entry will look something like this:
+                // PeerId0: [0, 1, 2, 3]
+                // PeerId1: [4, 5, 6, 7]
+                // Peer Id 0 will send requests 0, 1, 2, 3 in serial
+                // while simultaneously Peer Id 1 will send requests 4, 5, 6, 7 in serial
+                const batchResults = await Promise.all(Array.from(requestBatches.entries()).map(async ([peer, indices])=>{
+                    try {
+                        // Requests all going to the same peer are sent synchronously
+                        const peerResults = [];
+                        for (const index of indices){
+                            const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffers[index]);
+                            // Check the status of the response buffer
+                            if (response && response.status !== ReqRespStatus.SUCCESS) {
+                                this.logger.debug(`Request to peer ${peer.toString()} failed with status ${prettyPrintReqRespStatus(response.status)}`);
+                                // If we hit a rate limit or some failure, we remove the peer and return the results,
+                                // they will be split among remaining peers and the new sampled peer
+                                batchSampler.removePeerAndReplace(peer);
+                                return {
+                                    peer,
+                                    results: peerResults
+                                };
+                            }
+                            if (response && response.data.length > 0) {
+                                const object = subProtocolMap[subProtocol].response.fromBuffer(response.data);
+                                const isValid = await responseValidator(requests[index], object, peer);
+                                if (isValid) {
+                                    peerResults.push({
+                                        index,
+                                        response: object
+                                    });
+                                }
+                            }
+                        }
+                        return {
+                            peer,
+                            results: peerResults
+                        };
+                    } catch (error) {
+                        this.logger.debug(`Failed batch request to peer ${peer.toString()}:`, error);
+                        batchSampler.removePeerAndReplace(peer);
+                        return {
+                            peer,
+                            results: []
+                        };
+                    }
+                }));
+                // Process results
+                for (const { results } of batchResults){
+                    for (const { index, response } of results){
+                        if (response) {
+                            responses[index] = response;
+                            pendingRequestIndices.delete(index);
+                        }
+                    }
+                }
+                retryAttempts++;
+            }
+            if (retryAttempts >= maxRetryAttempts) {
+                this.logger.debug(`Max retry attempts ${maxRetryAttempts} reached for batch request`);
+            }
+            return responses;
+        };
+        try {
+            return await executeTimeout(requestFunction, timeoutMs, ()=>new CollectiveReqRespTimeoutError());
+        } catch (e) {
+            this.logger.debug(`${e.message} | subProtocol: ${subProtocol}`);
+            return [];
+        }
+    }
+    /**
+   * 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
+   */ async sendRequestToPeer(peerId, subProtocol, payload) {
+        let stream;
+        try {
+            this.metrics.recordRequestSent(subProtocol);
+            stream = await this.connectionSampler.dialProtocol(peerId, subProtocol);
+            // Open the stream with a timeout
+            const result = await executeTimeout(()=>pipe([
+                    payload
+                ], stream, this.readMessage.bind(this)), this.individualRequestTimeoutMs, ()=>new IndividualReqRespTimeoutError());
+            return result;
+        } catch (e) {
+            this.metrics.recordRequestError(subProtocol);
+            this.handleResponseError(e, peerId, subProtocol);
+        } finally{
+            // Only close the stream if we created it
+            if (stream) {
+                try {
+                    await this.connectionSampler.close(stream.id);
+                } catch (closeError) {
+                    this.logger.error(`Error closing stream: ${closeError instanceof Error ? closeError.message : 'Unknown error'}`);
+                }
+            }
+        }
+    }
+    /**
+   * 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
+   */ handleResponseError(e, peerId, subProtocol) {
+        const severity = this.categorizeError(e, peerId, subProtocol);
+        if (severity) {
+            this.peerScoring.penalizePeer(peerId, severity);
+        }
+    }
+    /**
+   * Categorize the error and log it.
+   */ categorizeError(e, peerId, subProtocol) {
+        // Non punishable errors - we do not expect a response for goodbye messages
+        if (subProtocol === ReqRespSubProtocol.GOODBYE) {
+            this.logger.debug('Error encountered on goodbye sub protocol, no penalty', {
+                peerId: peerId.toString(),
+                subProtocol
+            });
+            return undefined;
+        }
+        // We do not punish a collective timeout, as the node triggers this interupt, independent of the peer's behaviour
+        const logTags = {
+            peerId: peerId.toString(),
+            subProtocol
+        };
+        if (e instanceof CollectiveReqRespTimeoutError || e instanceof InvalidResponseError) {
+            this.logger.debug(`Non-punishable error: ${e.message} | peerId: ${peerId.toString()} | subProtocol: ${subProtocol}`, logTags);
+            return undefined;
+        }
+        // Pubishable errors
+        // Connection reset errors in the networking stack are punished with high severity
+        // it just signals an unreliable peer
+        // We assume that the requesting node has a functioning networking stack.
+        if (e?.code === 'ECONNRESET' || e?.code === 'EPIPE') {
+            this.logger.debug(`Connection reset: ${peerId.toString()}`, logTags);
+            return PeerErrorSeverity.HighToleranceError;
+        }
+        if (e?.code === 'ECONNREFUSED') {
+            this.logger.debug(`Connection refused: ${peerId.toString()}`, logTags);
+            return PeerErrorSeverity.HighToleranceError;
+        }
+        // Timeout errors are punished with high tolerance, they can be due to a geogrpahically far away peer or an
+        // overloaded peer
+        if (e instanceof IndividualReqRespTimeoutError) {
+            this.logger.debug(`Timeout error: ${e.message} | peerId: ${peerId.toString()} | subProtocol: ${subProtocol}`, logTags);
+            return PeerErrorSeverity.HighToleranceError;
+        }
+        // Catch all error
+        this.logger.error(`Unexpected error sending request to peer`, e, logTags);
+        return PeerErrorSeverity.HighToleranceError;
+    }
+    /**
+   * 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
+   */ async readMessage(source) {
+        let statusBuffer;
+        const chunks = [];
+        try {
+            for await (const chunk of source){
+                if (statusBuffer === undefined) {
+                    const firstChunkBuffer = chunk.subarray();
+                    statusBuffer = parseStatusChunk(firstChunkBuffer);
+                } else {
+                    chunks.push(chunk.subarray());
+                }
+            }
+            const messageData = Buffer.concat(chunks);
+            const message = this.snappyTransform.inboundTransformNoTopic(messageData);
+            return {
+                status: statusBuffer ?? ReqRespStatus.UNKNOWN,
+                data: message
+            };
+        } catch (e) {
+            this.logger.debug(`Reading message failed: ${e.message}`);
+            let status = ReqRespStatus.UNKNOWN;
+            if (e instanceof ReqRespStatusError) {
+                status = e.status;
+            }
+            return {
+                status,
+                data: Buffer.from([])
+            };
+        }
+    }
+    /**
+   * 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.
+   */ async streamHandler(protocol, { stream, connection }) {
+        this.metrics.recordRequestReceived(protocol);
+        try {
+            // Store a reference to from this for the async generator
+            const rateLimitStatus = this.rateLimiter.allow(protocol, connection.remotePeer);
+            if (rateLimitStatus != RateLimitStatus.Allowed) {
+                this.logger.warn(`Rate limit exceeded ${prettyPrintRateLimitStatus(rateLimitStatus)} for ${protocol} from ${connection.remotePeer}`);
+                throw new ReqRespStatusError(ReqRespStatus.RATE_LIMIT_EXCEEDED);
+            }
+            const handler = this.subProtocolHandlers[protocol];
+            const transform = this.snappyTransform;
+            await pipe(stream, async function*(source) {
+                for await (const chunkList of source){
+                    const msg = Buffer.from(chunkList.subarray());
+                    const response = await handler(connection.remotePeer, msg);
+                    if (protocol === ReqRespSubProtocol.GOODBYE) {
+                        // Don't respond
+                        await stream.close();
+                        return;
+                    }
+                    // Send success code first, then the response
+                    const successChunk = Buffer.from([
+                        ReqRespStatus.SUCCESS
+                    ]);
+                    yield new Uint8Array(successChunk);
+                    yield new Uint8Array(transform.outboundTransformNoTopic(response));
+                }
+            }, stream);
+        } catch (e) {
+            this.logger.warn('Reqresp Response error: ', e);
+            this.metrics.recordResponseError(protocol);
+            // If we receive a known error, we use the error status in the response chunk, otherwise we categorize as unknown
+            let errorStatus = ReqRespStatus.UNKNOWN;
+            if (e instanceof ReqRespStatusError) {
+                errorStatus = e.status;
+            }
+            const sendErrorChunk = this.sendErrorChunk(errorStatus);
+            // Return and yield the response chunk
+            await pipe(stream, async function*(_source) {
+                yield* sendErrorChunk;
+            }, stream);
+        } finally{
+            await stream.close();
+        }
+    }
+    async *sendErrorChunk(error) {
+        const errorChunk = Buffer.from([
+            error
+        ]);
+        yield new Uint8Array(errorChunk);
+    }
+}
+_ts_decorate([
+    trackSpan('ReqResp.sendBatchRequest', (subProtocol, requests)=>({
+            [Attributes.P2P_REQ_RESP_PROTOCOL]: subProtocol,
+            [Attributes.P2P_REQ_RESP_BATCH_REQUESTS_COUNT]: requests.length
+        }))
+], ReqResp.prototype, "sendBatchRequest", null);
+_ts_decorate([
+    trackSpan('ReqResp.sendRequestToPeer', (peerId, subProtocol, _)=>({
+            [Attributes.P2P_ID]: peerId.toString(),
+            [Attributes.P2P_REQ_RESP_PROTOCOL]: subProtocol
+        }))
+], ReqResp.prototype, "sendRequestToPeer", null);
+_ts_decorate([
+    trackSpan('ReqResp.streamHandler', (protocol, { connection })=>({
+            [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol,
+            [Attributes.P2P_ID]: connection.remotePeer.toString()
+        }))
+], ReqResp.prototype, "streamHandler", null);

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

@@ -0,0 +1,31 @@
+/**
+ * The error codes for the ReqResp protocol
+ */
+export declare enum ReqRespStatus {
+    SUCCESS = 0,
+    RATE_LIMIT_EXCEEDED = 1,
+    BADLY_FORMED_REQUEST = 2,
+    UNKNOWN = 127
+}
+export declare class ReqRespStatusError extends Error {
+    /**
+     * The status code
+     */
+    status: ReqRespStatus;
+    constructor(status: ReqRespStatus);
+}
+/**
+ * Parse the status chunk
+ * @param chunk
+ * @returns
+ *
+ * @throws ReqRespStatusError if the chunk is not valid
+ */
+export declare function parseStatusChunk(chunk: Uint8Array): ReqRespStatus;
+/**
+ * Pretty print the ReqResp status
+ * @param status
+ * @returns
+ */
+export declare function prettyPrintReqRespStatus(status: ReqRespStatus): "SUCCESS" | "RATE_LIMIT_EXCEEDED" | "BADLY_FORMED_REQUEST" | "UNKNOWN";
+//# sourceMappingURL=status.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/services/reqresp/status.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,aAAa;IACvB,OAAO,IAAI;IACX,mBAAmB,IAAI;IACvB,oBAAoB,IAAI;IACxB,OAAO,MAAM;CACd;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C;;OAEG;IACH,MAAM,EAAE,aAAa,CAAC;gBAEV,MAAM,EAAE,aAAa;CAIlC;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAWjE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,0EAW7D"}

package/dest/services/reqresp/status.js

@@ -0,0 +1,51 @@
+/**
+ * The error codes for the ReqResp protocol
+ */ export var ReqRespStatus = /*#__PURE__*/ function(ReqRespStatus) {
+    ReqRespStatus[ReqRespStatus["SUCCESS"] = 0] = "SUCCESS";
+    ReqRespStatus[ReqRespStatus["RATE_LIMIT_EXCEEDED"] = 1] = "RATE_LIMIT_EXCEEDED";
+    ReqRespStatus[ReqRespStatus["BADLY_FORMED_REQUEST"] = 2] = "BADLY_FORMED_REQUEST";
+    ReqRespStatus[ReqRespStatus["UNKNOWN"] = 127] = "UNKNOWN";
+    return ReqRespStatus;
+}({});
+export class ReqRespStatusError extends Error {
+    /**
+   * The status code
+   */ status;
+    constructor(status){
+        super(`ReqResp Error: ${prettyPrintReqRespStatus(status)}`);
+        this.status = status;
+    }
+}
+/**
+ * Parse the status chunk
+ * @param chunk
+ * @returns
+ *
+ * @throws ReqRespStatusError if the chunk is not valid
+ */ export function parseStatusChunk(chunk) {
+    if (chunk.length !== 1) {
+        throw new ReqRespStatusError(127);
+    }
+    const status = chunk[0];
+    // Check if status is a valid ReqRespStatus value
+    if (!(status in ReqRespStatus)) {
+        throw new ReqRespStatusError(127);
+    }
+    return status;
+}
+/**
+ * Pretty print the ReqResp status
+ * @param status
+ * @returns
+ */ export function prettyPrintReqRespStatus(status) {
+    switch(status){
+        case 0:
+            return 'SUCCESS';
+        case 1:
+            return 'RATE_LIMIT_EXCEEDED';
+        case 2:
+            return 'BADLY_FORMED_REQUEST';
+        case 127:
+            return 'UNKNOWN';
+    }
+}