@aztec/p2p 0.0.0-test.0

package/dest/services/peer-manager/peer_scoring.js

@@ -0,0 +1,86 @@
+import { median } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+const DefaultPeerPenalties = {
+    [PeerErrorSeverity.LowToleranceError]: 50,
+    [PeerErrorSeverity.MidToleranceError]: 10,
+    [PeerErrorSeverity.HighToleranceError]: 2
+};
+export var PeerScoreState = /*#__PURE__*/ function(PeerScoreState) {
+    PeerScoreState[PeerScoreState["Banned"] = 0] = "Banned";
+    PeerScoreState[PeerScoreState["Disconnect"] = 1] = "Disconnect";
+    PeerScoreState[PeerScoreState["Healthy"] = 2] = "Healthy";
+    return PeerScoreState;
+}({});
+// TODO: move into config / constants
+const MIN_SCORE_BEFORE_BAN = -100;
+const MIN_SCORE_BEFORE_DISCONNECT = -50;
+export class PeerScoring {
+    logger = createLogger('p2p:peer-scoring');
+    scores = new Map();
+    lastUpdateTime = new Map();
+    decayInterval = 1000 * 60;
+    decayFactor = 0.9;
+    peerPenalties;
+    constructor(config){
+        const orderedValues = config.peerPenaltyValues?.sort((a, b)=>a - b);
+        this.peerPenalties = {
+            [PeerErrorSeverity.HighToleranceError]: orderedValues?.[0] ?? DefaultPeerPenalties[PeerErrorSeverity.HighToleranceError],
+            [PeerErrorSeverity.MidToleranceError]: orderedValues?.[1] ?? DefaultPeerPenalties[PeerErrorSeverity.MidToleranceError],
+            [PeerErrorSeverity.LowToleranceError]: orderedValues?.[2] ?? DefaultPeerPenalties[PeerErrorSeverity.LowToleranceError]
+        };
+    }
+    penalizePeer(peerId, penalty) {
+        const id = peerId.toString();
+        const penaltyValue = this.peerPenalties[penalty];
+        const newScore = this.updateScore(id, -penaltyValue);
+        this.logger.verbose(`Penalizing peer ${id} with ${penalty} (new score is ${newScore})`);
+        return newScore;
+    }
+    updateScore(peerId, scoreDelta) {
+        const currentTime = Date.now();
+        const lastUpdate = this.lastUpdateTime.get(peerId) || currentTime;
+        const timePassed = currentTime - lastUpdate;
+        const decayPeriods = Math.floor(timePassed / this.decayInterval);
+        let currentScore = this.scores.get(peerId) || 0;
+        // Apply decay
+        currentScore *= Math.pow(this.decayFactor, decayPeriods);
+        // Apply new score delta
+        currentScore += scoreDelta;
+        this.scores.set(peerId, currentScore);
+        this.lastUpdateTime.set(peerId, currentTime);
+        return currentScore;
+    }
+    decayAllScores() {
+        const currentTime = Date.now();
+        for (const [peerId, lastUpdate] of this.lastUpdateTime.entries()){
+            const timePassed = currentTime - lastUpdate;
+            const decayPeriods = Math.floor(timePassed / this.decayInterval);
+            if (decayPeriods > 0) {
+                let score = this.scores.get(peerId) || 0;
+                score *= Math.pow(this.decayFactor, decayPeriods);
+                this.scores.set(peerId, score);
+                this.lastUpdateTime.set(peerId, currentTime);
+            }
+        }
+    }
+    getScore(peerId) {
+        return this.scores.get(peerId) || 0;
+    }
+    getScoreState(peerId) {
+        // TODO(#11329): permanently store banned peers?
+        const score = this.getScore(peerId);
+        if (score < MIN_SCORE_BEFORE_BAN) {
+            return 0;
+        }
+        if (score < MIN_SCORE_BEFORE_DISCONNECT) {
+            return 1;
+        }
+        return 2;
+    }
+    getStats() {
+        return {
+            medianScore: median(Array.from(this.scores.values())) ?? 0
+        };
+    }
+}

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

@@ -0,0 +1,16 @@
+import { type ConfigMapping } from '@aztec/foundation/config';
+export declare const DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS = 2000;
+export declare const DEFAULT_OVERALL_REQUEST_TIMEOUT_MS = 4000;
+export declare const DEFAULT_P2P_REQRESP_CONFIG: P2PReqRespConfig;
+export interface P2PReqRespConfig {
+    /**
+     * The overall timeout for a request response operation.
+     */
+    overallRequestTimeoutMs: number;
+    /**
+     * The timeout for an individual request response peer interaction.
+     */
+    individualRequestTimeoutMs: number;
+}
+export declare const p2pReqRespConfigMappings: Record<keyof P2PReqRespConfig, ConfigMapping>;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/services/reqresp/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAsB,MAAM,0BAA0B,CAAC;AAElF,eAAO,MAAM,qCAAqC,OAAO,CAAC;AAC1D,eAAO,MAAM,kCAAkC,OAAO,CAAC;AAGvD,eAAO,MAAM,0BAA0B,EAAE,gBAGxC,CAAC;AAEF,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,uBAAuB,EAAE,MAAM,CAAC;IAEhC;;OAEG;IACH,0BAA0B,EAAE,MAAM,CAAC;CACpC;AAED,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,gBAAgB,EAAE,aAAa,CAWlF,CAAC"}

package/dest/services/reqresp/config.js

@@ -0,0 +1,20 @@
+import { numberConfigHelper } from '@aztec/foundation/config';
+export const DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS = 2000;
+export const DEFAULT_OVERALL_REQUEST_TIMEOUT_MS = 4000;
+// For use in tests.
+export const DEFAULT_P2P_REQRESP_CONFIG = {
+    overallRequestTimeoutMs: DEFAULT_OVERALL_REQUEST_TIMEOUT_MS,
+    individualRequestTimeoutMs: DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS
+};
+export const p2pReqRespConfigMappings = {
+    overallRequestTimeoutMs: {
+        env: 'P2P_REQRESP_OVERALL_REQUEST_TIMEOUT_MS',
+        description: 'The overall timeout for a request response operation.',
+        ...numberConfigHelper(DEFAULT_OVERALL_REQUEST_TIMEOUT_MS)
+    },
+    individualRequestTimeoutMs: {
+        env: 'P2P_REQRESP_INDIVIDUAL_REQUEST_TIMEOUT_MS',
+        description: 'The timeout for an individual request response peer interaction.',
+        ...numberConfigHelper(DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS)
+    }
+};

package/dest/services/reqresp/connection-sampler/batch_connection_sampler.d.ts

@@ -0,0 +1,45 @@
+import type { PeerId } from '@libp2p/interface';
+import type { ConnectionSampler } from './connection_sampler.js';
+/**
+ * Manages batches of peers for parallel request processing.
+ * Tracks active peers and provides deterministic peer assignment for requests.
+ *
+ * Example with 3 peers and 10 requests:
+ *
+ * Peers:    [P1]      [P2]     [P3]
+ *           ↓ ↓ ↓ ↓   ↓ ↓ ↓   ↓ ↓ ↓
+ * Requests: 0,1,2,9 | 3,4,5 | 6,7,8
+ *
+ * Each peer handles a bucket of consecutive requests.
+ * If a peer fails, it is replaced while maintaining the same bucket.
+ */
+export declare class BatchConnectionSampler {
+    private readonly connectionSampler;
+    private readonly logger;
+    private readonly batch;
+    private readonly requestsPerPeer;
+    constructor(connectionSampler: ConnectionSampler, batchSize: number, maxPeers: number);
+    /**
+     * Gets the peer responsible for handling a specific request index
+     *
+     * @param index - The request index
+     * @returns The peer assigned to handle this request
+     */
+    getPeerForRequest(index: number): PeerId | undefined;
+    /**
+     * Removes a peer and replaces it with a new one, maintaining the same position
+     * in the batch array to keep request distribution consistent
+     *
+     * @param peerId - The peer to remove and replace
+     */
+    removePeerAndReplace(peerId: PeerId): void;
+    /**
+     * Gets the number of active peers
+     */
+    get activePeerCount(): number;
+    /**
+     * Gets the number of requests each peer is assigned to handle
+     */
+    get requestsPerBucket(): number;
+}
+//# sourceMappingURL=batch_connection_sampler.d.ts.map

package/dest/services/reqresp/connection-sampler/batch_connection_sampler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch_connection_sampler.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/connection-sampler/batch_connection_sampler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE;;;;;;;;;;;;GAYG;AACH,qBAAa,sBAAsB;IAKrB,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAJ9C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwD;IAC/E,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;gBAEZ,iBAAiB,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAetG;;;;;OAKG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAUpD;;;;;OAKG;IACH,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAmB1C;;OAEG;IACH,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED;;OAEG;IACH,IAAI,iBAAiB,IAAI,MAAM,CAE9B;CACF"}

package/dest/services/reqresp/connection-sampler/batch_connection_sampler.js

@@ -0,0 +1,88 @@
+import { createLogger } from '@aztec/foundation/log';
+/**
+ * Manages batches of peers for parallel request processing.
+ * Tracks active peers and provides deterministic peer assignment for requests.
+ *
+ * Example with 3 peers and 10 requests:
+ *
+ * Peers:    [P1]      [P2]     [P3]
+ *           ↓ ↓ ↓ ↓   ↓ ↓ ↓   ↓ ↓ ↓
+ * Requests: 0,1,2,9 | 3,4,5 | 6,7,8
+ *
+ * Each peer handles a bucket of consecutive requests.
+ * If a peer fails, it is replaced while maintaining the same bucket.
+ */ export class BatchConnectionSampler {
+    connectionSampler;
+    logger;
+    batch;
+    requestsPerPeer;
+    constructor(connectionSampler, batchSize, maxPeers){
+        this.connectionSampler = connectionSampler;
+        this.logger = createLogger('p2p:reqresp:batch-connection-sampler');
+        this.batch = [];
+        if (maxPeers <= 0) {
+            throw new Error('Max peers cannot be 0');
+        }
+        if (batchSize <= 0) {
+            throw new Error('Batch size cannot be 0');
+        }
+        // Calculate how many requests each peer should handle, cannot be 0
+        this.requestsPerPeer = Math.max(1, Math.floor(batchSize / maxPeers));
+        // Sample initial peers
+        this.batch = this.connectionSampler.samplePeersBatch(maxPeers);
+    }
+    /**
+   * Gets the peer responsible for handling a specific request index
+   *
+   * @param index - The request index
+   * @returns The peer assigned to handle this request
+   */ getPeerForRequest(index) {
+        if (this.batch.length === 0) {
+            return undefined;
+        }
+        // Calculate which peer bucket this index belongs to
+        const peerIndex = Math.floor(index / this.requestsPerPeer) % this.batch.length;
+        return this.batch[peerIndex];
+    }
+    /**
+   * Removes a peer and replaces it with a new one, maintaining the same position
+   * in the batch array to keep request distribution consistent
+   *
+   * @param peerId - The peer to remove and replace
+   */ removePeerAndReplace(peerId) {
+        const index = this.batch.findIndex((p)=>p === peerId);
+        if (index === -1) {
+            return;
+        }
+        const excluding = new Map([
+            [
+                peerId.toString(),
+                true
+            ]
+        ]);
+        const newPeer = this.connectionSampler.getPeer(excluding);
+        if (newPeer) {
+            this.batch[index] = newPeer;
+            this.logger.trace(`Replaced peer ${peerId} with ${newPeer}`, {
+                peerId,
+                newPeer
+            });
+        } else {
+            // If we couldn't get a replacement, remove the peer and compact the array
+            this.batch.splice(index, 1);
+            this.logger.trace(`Removed peer ${peerId}`, {
+                peerId
+            });
+        }
+    }
+    /**
+   * Gets the number of active peers
+   */ get activePeerCount() {
+        return this.batch.length;
+    }
+    /**
+   * Gets the number of requests each peer is assigned to handle
+   */ get requestsPerBucket() {
+        return this.requestsPerPeer;
+    }
+}

package/dest/services/reqresp/connection-sampler/connection_sampler.d.ts

@@ -0,0 +1,61 @@
+import type { Libp2p, PeerId, Stream } from '@libp2p/interface';
+export declare class RandomSampler {
+    random(max: number): number;
+}
+/**
+ * A class that samples peers from the libp2p node and returns a peer that we don't already have a connection open to.
+ * If we already have a connection open, we try to sample a different peer.
+ * We do this MAX_SAMPLE_ATTEMPTS times, if we still don't find a peer we just go for it.
+ *
+ * @dev Close must always be called on connections, else memory leak
+ */
+export declare class ConnectionSampler {
+    private readonly libp2p;
+    private readonly cleanupIntervalMs;
+    private readonly sampler;
+    private readonly logger;
+    private cleanupInterval;
+    private abortController;
+    private readonly activeConnectionsCount;
+    private readonly streams;
+    private dialQueue;
+    constructor(libp2p: Libp2p, cleanupIntervalMs?: number, // Default to 1 minute
+    sampler?: RandomSampler);
+    /**
+     * Stops the cleanup job and closes all active connections
+     */
+    stop(): Promise<void>;
+    /**
+     *
+     * @param excluding - The peers to exclude from the sampling
+     *        This is to prevent sampling with replacement
+     * @returns
+     */
+    getPeer(excluding?: Map<string, boolean>): PeerId | undefined;
+    /**
+     * Samples a batch of unique peers from the libp2p node, prioritizing peers without active connections
+     *
+     * @param numberToSample - The number of peers to sample
+     * @returns Array of unique sampled peers, prioritizing those without active connections
+     */
+    samplePeersBatch(numberToSample: number): PeerId[];
+    /**
+     * Dials a protocol and returns the stream
+     *
+     * @param peerId - The peer id
+     * @param protocol - The protocol
+     * @returns The stream
+     */
+    dialProtocol(peerId: PeerId, protocol: string): Promise<Stream>;
+    /**
+     * Closes a stream and updates the active connections count
+     *
+     * @param streamId - The stream id
+     */
+    close(streamId: string): Promise<void>;
+    /**
+     * Cleans up stale connections that we have lost accounting for
+     */
+    private cleanupStaleConnections;
+}
+//# sourceMappingURL=connection_sampler.d.ts.map

package/dest/services/reqresp/connection-sampler/connection_sampler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection_sampler.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/connection-sampler/connection_sampler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAShE,qBAAa,aAAa;IACxB,MAAM,CAAC,GAAG,EAAE,MAAM;CAGnB;AAED;;;;;;GAMG;AACH,qBAAa,iBAAiB;IAY1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAb1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkD;IACzE,OAAO,CAAC,eAAe,CAAiB;IACxC,OAAO,CAAC,eAAe,CAA0C;IAEjE,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAkC;IACzE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2C;IAGnE,OAAO,CAAC,SAAS,CAAkC;gBAGhC,MAAM,EAAE,MAAM,EACd,iBAAiB,GAAE,MAAc,EAAE,sBAAsB;IACzD,OAAO,GAAE,aAAmC;IAO/D;;OAEG;IACG,IAAI;IAaV;;;;;OAKG;IACH,OAAO,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,SAAS;IA+B7D;;;;;OAKG;IACH,gBAAgB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,EAAE;IAkClD;;;;;;OAMG;IACG,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAmBrE;;;;OAIG;IACG,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA4B5C;;OAEG;YACW,uBAAuB;CAetC"}

package/dest/services/reqresp/connection-sampler/connection_sampler.js

@@ -0,0 +1,181 @@
+import { createLogger } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
+const MAX_SAMPLE_ATTEMPTS = 4;
+export class RandomSampler {
+    random(max) {
+        return Math.floor(Math.random() * max);
+    }
+}
+/**
+ * A class that samples peers from the libp2p node and returns a peer that we don't already have a connection open to.
+ * If we already have a connection open, we try to sample a different peer.
+ * We do this MAX_SAMPLE_ATTEMPTS times, if we still don't find a peer we just go for it.
+ *
+ * @dev Close must always be called on connections, else memory leak
+ */ export class ConnectionSampler {
+    libp2p;
+    cleanupIntervalMs;
+    sampler;
+    logger;
+    cleanupInterval;
+    abortController;
+    activeConnectionsCount;
+    streams;
+    // Serial queue to ensure that we only dial one peer at a time
+    dialQueue;
+    constructor(libp2p, cleanupIntervalMs = 60000, sampler = new RandomSampler()){
+        this.libp2p = libp2p;
+        this.cleanupIntervalMs = cleanupIntervalMs;
+        this.sampler = sampler;
+        this.logger = createLogger('p2p:reqresp:connection-sampler');
+        this.abortController = new AbortController();
+        this.activeConnectionsCount = new Map();
+        this.streams = new Map();
+        this.dialQueue = new SerialQueue();
+        this.cleanupInterval = setInterval(()=>void this.cleanupStaleConnections(), this.cleanupIntervalMs);
+        this.dialQueue.start();
+    }
+    /**
+   * Stops the cleanup job and closes all active connections
+   */ async stop() {
+        this.logger.info('Stopping connection sampler');
+        clearInterval(this.cleanupInterval);
+        this.abortController.abort();
+        await this.dialQueue.end();
+        // Close all active streams
+        const closePromises = Array.from(this.streams.keys()).map((streamId)=>this.close(streamId));
+        await Promise.all(closePromises);
+        this.logger.info('Connection sampler stopped');
+    }
+    /**
+   *
+   * @param excluding - The peers to exclude from the sampling
+   *        This is to prevent sampling with replacement
+   * @returns
+   */ getPeer(excluding) {
+        // In libp2p getPeers performs a shallow copy, so this array can be sliced from safetly
+        const peers = this.libp2p.getPeers();
+        if (peers.length === 0) {
+            return undefined;
+        }
+        let randomIndex = this.sampler.random(peers.length);
+        let attempts = 0;
+        // Keep sampling while:
+        // - we haven't exceeded max attempts AND
+        // - either the peer has active connections OR is in the exclusion list
+        while(attempts < MAX_SAMPLE_ATTEMPTS && ((this.activeConnectionsCount.get(peers[randomIndex]) ?? 0) > 0 || (excluding?.get(peers[randomIndex]?.toString()) ?? false))){
+            peers.splice(randomIndex, 1);
+            randomIndex = this.sampler.random(peers.length);
+            attempts++;
+        }
+        this.logger.trace(`Sampled peer in ${attempts} attempts`, {
+            attempts,
+            peer: peers[randomIndex]?.toString()
+        });
+        return peers[randomIndex];
+    }
+    /**
+   * Samples a batch of unique peers from the libp2p node, prioritizing peers without active connections
+   *
+   * @param numberToSample - The number of peers to sample
+   * @returns Array of unique sampled peers, prioritizing those without active connections
+   */ samplePeersBatch(numberToSample) {
+        const peers = this.libp2p.getPeers();
+        const sampledPeers = [];
+        const peersWithConnections = []; // Hold onto peers with active connections incase we need to sample more
+        for (const peer of peers){
+            const activeConnections = this.activeConnectionsCount.get(peer) ?? 0;
+            if (activeConnections === 0) {
+                if (sampledPeers.push(peer) === numberToSample) {
+                    return sampledPeers;
+                }
+            } else {
+                peersWithConnections.push(peer);
+            }
+        }
+        // If we still need more peers, sample from those with connections
+        while(sampledPeers.length < numberToSample && peersWithConnections.length > 0){
+            const randomIndex = this.sampler.random(peersWithConnections.length);
+            const [peer] = peersWithConnections.splice(randomIndex, 1);
+            sampledPeers.push(peer);
+        }
+        this.logger.trace(`Batch sampled ${sampledPeers.length} unique peers`, {
+            peers: sampledPeers,
+            withoutConnections: sampledPeers.length - peersWithConnections.length,
+            withConnections: peersWithConnections.length
+        });
+        return sampledPeers;
+    }
+    // Set of passthrough functions to keep track of active connections
+    /**
+   * Dials a protocol and returns the stream
+   *
+   * @param peerId - The peer id
+   * @param protocol - The protocol
+   * @returns The stream
+   */ async dialProtocol(peerId, protocol) {
+        // Dialling at the same time can cause race conditions where two different streams
+        // end up with the same id, hence a serial queue
+        const stream = await this.dialQueue.put(()=>this.libp2p.dialProtocol(peerId, protocol, {
+                signal: this.abortController.signal
+            }));
+        this.streams.set(stream.id, {
+            stream,
+            peerId
+        });
+        const updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerId) ?? 0) + 1;
+        this.activeConnectionsCount.set(peerId, updatedActiveConnectionsCount);
+        this.logger.trace(`Dialed protocol ${protocol} with peer ${peerId.toString()}`, {
+            streamId: stream.id,
+            peerId: peerId.toString(),
+            activeConnectionsCount: updatedActiveConnectionsCount
+        });
+        return stream;
+    }
+    /**
+   * Closes a stream and updates the active connections count
+   *
+   * @param streamId - The stream id
+   */ async close(streamId) {
+        try {
+            const streamAndPeerId = this.streams.get(streamId);
+            if (!streamAndPeerId) {
+                this.logger.warn(`Stream ${streamId} not found`);
+                return;
+            }
+            const { stream, peerId } = streamAndPeerId;
+            const updatedActiveConnectionsCount = (this.activeConnectionsCount.get(peerId) ?? 1) - 1;
+            this.activeConnectionsCount.set(peerId, updatedActiveConnectionsCount);
+            this.logger.trace(`Closing connection to peer ${peerId.toString()}`, {
+                streamId,
+                peerId: peerId.toString(),
+                protocol: stream.protocol,
+                activeConnectionsCount: updatedActiveConnectionsCount
+            });
+            await stream?.close();
+        } catch (error) {
+            this.logger.error(`Failed to close connection to peer with stream id ${streamId}`, error);
+        } finally{
+            this.streams.delete(streamId);
+        }
+    }
+    /**
+   * Cleans up stale connections that we have lost accounting for
+   */ async cleanupStaleConnections() {
+        // Look for streams without anything in the activeConnectionsCount
+        // If we find anything, close the stream
+        for (const [streamId, { peerId }] of this.streams.entries()){
+            try {
+                // Check if we have lost track of accounting
+                if (this.activeConnectionsCount.get(peerId) === 0) {
+                    await this.close(streamId);
+                    this.logger.debug(`Cleaned up stale connection ${streamId} to peer ${peerId.toString()}`);
+                }
+            } catch (error) {
+                this.logger.error(`Error cleaning up stale connection ${streamId}`, {
+                    error
+                });
+            }
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+export {};
+/**
+ * Request Response protocol allows nodes to ask their peers for data
+ * that they missed via the traditional gossip protocol.
+ */
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/reqresp/index.ts"],"names":[],"mappings":";AAAA;;;GAGG"}

package/dest/services/reqresp/index.js

@@ -0,0 +1,4 @@
+/**
+ * Request Response protocol allows nodes to ask their peers for data
+ * that they missed via the traditional gossip protocol.
+ */ 

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

@@ -0,0 +1,116 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { PeerId } from '@libp2p/interface';
+import type { ReqRespStatus } from './status.js';
+export declare const PING_PROTOCOL = "/aztec/req/ping/0.1.0";
+export declare const STATUS_PROTOCOL = "/aztec/req/status/0.1.0";
+export declare const GOODBYE_PROTOCOL = "/aztec/req/goodbye/0.1.0";
+export declare const TX_REQ_PROTOCOL = "/aztec/req/tx/0.1.0";
+export declare const BLOCK_REQ_PROTOCOL = "/aztec/req/block/0.1.0";
+export declare enum ReqRespSubProtocol {
+    PING = "/aztec/req/ping/0.1.0",
+    STATUS = "/aztec/req/status/0.1.0",
+    GOODBYE = "/aztec/req/goodbye/0.1.0",
+    TX = "/aztec/req/tx/0.1.0",
+    BLOCK = "/aztec/req/block/0.1.0"
+}
+/**
+ * A handler for a sub protocol
+ * The message will arrive as a buffer, and the handler must return a buffer
+ */
+export type ReqRespSubProtocolHandler = (peerId: PeerId, msg: Buffer) => Promise<Buffer>;
+/**
+ * A type mapping from supprotocol to it's rate limits
+ */
+export type ReqRespSubProtocolRateLimits = Record<ReqRespSubProtocol, ProtocolRateLimitQuota>;
+/**
+ * The response from the ReqResp protocol
+ * Consists of a status (Error code) and data
+ */
+export interface ReqRespResponse {
+    status: ReqRespStatus;
+    data: Buffer;
+}
+/**
+ * A rate limit quota
+ */
+export interface RateLimitQuota {
+    /**
+     * The time window in ms
+     */
+    quotaTimeMs: number;
+    /**
+     * The number of requests allowed within the time window
+     */
+    quotaCount: number;
+}
+export interface ProtocolRateLimitQuota {
+    /**
+     * The rate limit quota for a single peer
+     */
+    peerLimit: RateLimitQuota;
+    /**
+     * The rate limit quota for the global peer set
+     */
+    globalLimit: RateLimitQuota;
+}
+export declare const noopValidator: () => Promise<boolean>;
+/**
+ * A type mapping from supprotocol to it's handling function
+ */
+export type ReqRespSubProtocolHandlers = Record<ReqRespSubProtocol, ReqRespSubProtocolHandler>;
+type ResponseValidator<RequestIdentifier, Response> = (request: RequestIdentifier, response: Response, peerId: PeerId) => Promise<boolean>;
+export type ReqRespSubProtocolValidators = {
+    [S in ReqRespSubProtocol]: ResponseValidator<any, any>;
+};
+export declare const DEFAULT_SUB_PROTOCOL_VALIDATORS: ReqRespSubProtocolValidators;
+/**
+ * Sub protocol map determines the request and response types for each
+ * Req Resp protocol
+ */
+export type SubProtocolMap = {
+    [S in ReqRespSubProtocol]: RequestResponsePair<any, any>;
+};
+/**
+ * Default sub protocol handlers - this SHOULD be overwritten by the service,
+ */
+export declare const DEFAULT_SUB_PROTOCOL_HANDLERS: ReqRespSubProtocolHandlers;
+/**
+ * The Request Response Pair interface defines the methods that each
+ * request response pair must implement
+ */
+interface RequestResponsePair<Req extends {
+    toBuffer(): Buffer;
+}, Res> {
+    /**
+     * The request must implement the toBuffer method (generic serialisation)
+     */
+    request: new (...args: any[]) => Req;
+    /**
+     * The response must implement the static fromBuffer method (generic serialisation)
+     */
+    response: {
+        new (...args: any[]): Res;
+        fromBuffer(buffer: Buffer): Res;
+    };
+}
+/**
+ * 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 declare class RequestableBuffer {
+    buffer: Buffer;
+    constructor(buffer: Buffer);
+    toBuffer(): Buffer;
+    static fromBuffer(buffer: Buffer): RequestableBuffer;
+}
+/**
+ * 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 declare const subProtocolMap: SubProtocolMap;
+export {};
+//# sourceMappingURL=interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../src/services/reqresp/interface.ts"],"names":[],"mappings":";;AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKjD,eAAO,MAAM,aAAa,0BAA0B,CAAC;AACrD,eAAO,MAAM,eAAe,4BAA4B,CAAC;AACzD,eAAO,MAAM,gBAAgB,6BAA6B,CAAC;AAC3D,eAAO,MAAM,eAAe,wBAAwB,CAAC;AACrD,eAAO,MAAM,kBAAkB,2BAA2B,CAAC;AAE3D,oBAAY,kBAAkB;IAC5B,IAAI,0BAAgB;IACpB,MAAM,4BAAkB;IACxB,OAAO,6BAAmB;IAC1B,EAAE,wBAAkB;IACpB,KAAK,2BAAqB;CAC3B;AAED;;;GAGG;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAEzF;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG,MAAM,CAAC,kBAAkB,EAAE,sBAAsB,CAAC,CAAC;AAE9F;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,aAAa,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,SAAS,EAAE,cAAc,CAAC;IAC1B;;OAEG;IACH,WAAW,EAAE,cAAc,CAAC;CAC7B;AAED,eAAO,MAAM,aAAa,wBAA8B,CAAC;AAEzD;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG,MAAM,CAAC,kBAAkB,EAAE,yBAAyB,CAAC,CAAC;AAE/F,KAAK,iBAAiB,CAAC,iBAAiB,EAAE,QAAQ,IAAI,CACpD,OAAO,EAAE,iBAAiB,EAC1B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,KACX,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB,MAAM,MAAM,4BAA4B,GAAG;KACxC,CAAC,IAAI,kBAAkB,GAAG,iBAAiB,CAAC,GAAG,EAAE,GAAG,CAAC;CACvD,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,4BAM7C,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;KAC1B,CAAC,IAAI,kBAAkB,GAAG,mBAAmB,CAAC,GAAG,EAAE,GAAG,CAAC;CACzD,CAAC;AAUF;;GAEG;AACH,eAAO,MAAM,6BAA6B,EAAE,0BAM3C,CAAC;AAEF;;;GAGG;AACH,UAAU,mBAAmB,CAAC,GAAG,SAAS;IAAE,QAAQ,IAAI,MAAM,CAAA;CAAE,EAAE,GAAG;IACnE;;OAEG;IACH,OAAO,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;IACrC;;OAEG;IACH,QAAQ,EAAE;QACR,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,CAAC;QAC1B,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC;KACjC,CAAC;CACH;AAED;;;;;GAKG;AACH,qBAAa,iBAAiB;IACT,MAAM,EAAE,MAAM;gBAAd,MAAM,EAAE,MAAM;IAEjC,QAAQ;IAIR,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM;CAGjC;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,cAqB5B,CAAC"}