@aztec/p2p 1.2.1 → 2.0.0-nightly.20250813

package/dest/services/reqresp/protocols/block_txs/bitvector.d.ts

@@ -0,0 +1,30 @@
+import { BufferReader } from '@aztec/foundation/serialize';
+/**
+ * BitVector helper class for representing and serializing bit vectors
+ */
+export declare class BitVector {
+    private buffer;
+    private length;
+    constructor(buffer: Buffer, length: number);
+    static init(length: number, indices: number[]): BitVector;
+    getLength(): number;
+    isSet(index: number): boolean;
+    /**
+     * Returns all indices which are set to true
+     * */
+    getTrueIndices(): number[];
+    /**
+     * Serializes the BitVector object into a Buffer
+     *
+     * @returns Buffer representation of the BitVector object
+     * */
+    toBuffer(): Buffer;
+    /**
+     * Deserializes buffer into new BitVector
+     *
+     * @returns A new BitVector instance
+     * */
+    static fromBuffer(buffer: Buffer | BufferReader): BitVector;
+    static byteLength(length: number): number;
+}
+//# sourceMappingURL=bitvector.d.ts.map

package/dest/services/reqresp/protocols/block_txs/bitvector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitvector.d.ts","sourceRoot":"","sources":["../../../../../src/services/reqresp/protocols/block_txs/bitvector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAY1C,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,SAAS;IAqBzD,SAAS,IAAI,MAAM;IAWnB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAI7B;;SAEK;IACL,cAAc,IAAI,MAAM,EAAE;IAI1B;;;;SAIK;IACL,QAAQ,IAAI,MAAM;IAIlB;;;;SAIK;IACL,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAQ3D,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM;CAGjC"}

package/dest/services/reqresp/protocols/block_txs/bitvector.js

@@ -0,0 +1,75 @@
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+/**
+ * BitVector helper class for representing and serializing bit vectors
+ */ export class BitVector {
+    buffer;
+    length;
+    constructor(buffer, length){
+        this.buffer = buffer;
+        this.length = length;
+    }
+    /*
+   * Creates new BitVector instance
+   * @param length - Length of the bit vector
+   * @param indices - Array of indices to set to 1 in the bit vector
+   *
+   * @returns A new BitVector instance with specified length and set indices
+   * */ static init(length, indices) {
+        if (indices.length > length) {
+            throw new Error('Indices length exceeds specified length');
+        }
+        const buffer = Buffer.alloc(BitVector.byteLength(length));
+        indices.forEach((idx)=>{
+            const invalidIndex = idx < 0 || idx >= length;
+            if (invalidIndex) {
+                throw new Error(`Index ${idx} is out of bounds for BitVector of length ${length}`);
+            }
+            const byteIndex = Math.floor(idx / 8);
+            const bitIndex = idx % 8;
+            buffer[byteIndex] |= 1 << bitIndex;
+        });
+        return new BitVector(buffer, length);
+    }
+    getLength() {
+        return this.length;
+    }
+    /*
+   * Checks if element at index is set to true
+   *
+   * @param index - Index of the bit to check
+   *
+   * @returns True if the bit at index is set, false otherwise
+   * */ isSet(index) {
+        return index >= 0 && index < this.length && !!(this.buffer[Math.floor(index / 8)] & 1 << index % 8);
+    }
+    /**
+   * Returns all indices which are set to true
+   * */ getTrueIndices() {
+        return Array.from({
+            length: this.length
+        }, (_, i)=>i).filter((i)=>this.isSet(i));
+    }
+    /**
+   * Serializes the BitVector object into a Buffer
+   *
+   * @returns Buffer representation of the BitVector object
+   * */ toBuffer() {
+        return serializeToBuffer([
+            this.length,
+            this.buffer
+        ]);
+    }
+    /**
+   * Deserializes buffer into new BitVector
+   *
+   * @returns A new BitVector instance
+   * */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const length = reader.readNumber();
+        const bitBuffer = reader.readBytes(BitVector.byteLength(length));
+        return new BitVector(bitBuffer, length);
+    }
+    static byteLength(length) {
+        return Math.ceil(length / 8);
+    }
+}

package/dest/services/reqresp/protocols/block_txs/block_txs_handler.d.ts

@@ -0,0 +1,11 @@
+import type { AttestationPool } from '../../../../mem_pools/attestation_pool/attestation_pool.js';
+import type { TxPool } from '../../../../mem_pools/index.js';
+import type { ReqRespSubProtocolHandler } from '../../interface.js';
+/**
+ * Handler for block txs requests
+ * @param attestationPool - the attestation pool to check for block proposals
+ * @param mempools - the mempools containing the tx pool
+ * @returns the BlockTxs request handler
+ */
+export declare function reqRespBlockTxsHandler(attestationPool: AttestationPool, txPool: TxPool): ReqRespSubProtocolHandler;
+//# sourceMappingURL=block_txs_handler.d.ts.map

package/dest/services/reqresp/protocols/block_txs/block_txs_handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_txs_handler.d.ts","sourceRoot":"","sources":["../../../../../src/services/reqresp/protocols/block_txs/block_txs_handler.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4DAA4D,CAAC;AAClG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAKpE;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,eAAe,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,yBAAyB,CAmClH"}

package/dest/services/reqresp/protocols/block_txs/block_txs_handler.js

@@ -0,0 +1,39 @@
+import { TxArray } from '@aztec/stdlib/tx';
+import { ReqRespStatus, ReqRespStatusError } from '../../status.js';
+import { BitVector } from './bitvector.js';
+import { BlockTxsRequest, BlockTxsResponse } from './block_txs_reqresp.js';
+/**
+ * Handler for block txs requests
+ * @param attestationPool - the attestation pool to check for block proposals
+ * @param mempools - the mempools containing the tx pool
+ * @returns the BlockTxs request handler
+ */ export function reqRespBlockTxsHandler(attestationPool, txPool) {
+    /**
+   * Handler for block txs requests
+   * @param msg - the block txs request message
+   * @returns the block txs response message
+   * @throws if msg is not a valid block txs request
+   */ return async (_peerId, msg)=>{
+        let request;
+        try {
+            request = BlockTxsRequest.fromBuffer(msg);
+        } catch (err) {
+            throw new ReqRespStatusError(ReqRespStatus.BADLY_FORMED_REQUEST, {
+                cause: err
+            });
+        }
+        const blockProposal = await attestationPool.getBlockProposal(request.blockHash.toString());
+        if (!blockProposal) {
+            throw new ReqRespStatusError(ReqRespStatus.NOT_FOUND);
+        }
+        const txsAvailableInPool = await txPool.hasTxs(blockProposal.txHashes);
+        //Map txs in the pool to their indices in the block proposal
+        const availableIndices = txsAvailableInPool.map((hasTx, idx)=>hasTx ? idx : -1).filter((idx)=>idx !== -1);
+        const responseBitVector = BitVector.init(blockProposal.txHashes.length, availableIndices);
+        const requestedIndices = new Set(request.txIndices.getTrueIndices());
+        const requestedTxsHashes = blockProposal.txHashes.filter((_, idx)=>requestedIndices.has(idx));
+        const responseTxs = (await txPool.getTxsByHash(requestedTxsHashes)).filter((tx)=>!!tx);
+        const response = new BlockTxsResponse(request.blockHash, new TxArray(...responseTxs), responseBitVector);
+        return response.toBuffer();
+    };
+}

package/dest/services/reqresp/protocols/block_txs/block_txs_reqresp.d.ts

@@ -0,0 +1,49 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { TxArray } from '@aztec/stdlib/tx';
+import { BitVector } from './bitvector.js';
+/**
+ * Request message for requesting specific transactions from a block
+ */
+export declare class BlockTxsRequest {
+    readonly blockHash: Fr;
+    readonly txIndices: BitVector;
+    constructor(blockHash: Fr, // 32 byte hash of the proposed block header
+    txIndices: BitVector);
+    /**
+     * Deserializes the BlockTxRequest object from a Buffer
+     * @param buffer - Buffer or BufferReader object to deserialize
+     * @returns An instance of BlockTxRequest
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): BlockTxsRequest;
+    /**
+     * Serializes the BlockTxRequest object into a Buffer
+     * @returns Buffer representation of the BlockTxRequest object
+     */
+    toBuffer(): Buffer;
+}
+/**
+ * Response message containing requested transactions from a block
+ */
+export declare class BlockTxsResponse {
+    readonly blockHash: Fr;
+    readonly txs: TxArray;
+    readonly txIndices: BitVector;
+    constructor(blockHash: Fr, txs: TxArray, // List of transactions we requested and peer has
+    txIndices: BitVector);
+    /**
+     * Deserializes the BlockTxResponse object from a Buffer
+     * @param buffer - Buffer or BufferReader object to deserialize
+     * @returns An instance of BlockTxResponse
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): BlockTxsResponse;
+    /**
+     * Serializes the BlockTxResponse object into a Buffer
+     * @dev: In current implementation, txIndices is serialized as Buffer of unknown length,
+     * thus we serialize it last
+     * @returns Buffer representation of the BlockTxResponse object
+     */
+    toBuffer(): Buffer;
+    static empty(): BlockTxsResponse;
+}
+//# sourceMappingURL=block_txs_reqresp.d.ts.map

package/dest/services/reqresp/protocols/block_txs/block_txs_reqresp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_txs_reqresp.d.ts","sourceRoot":"","sources":["../../../../../src/services/reqresp/protocols/block_txs/block_txs_reqresp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAC9E,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE3C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;GAEG;AACH,qBAAa,eAAe;IAExB,QAAQ,CAAC,SAAS,EAAE,EAAE;IAGtB,QAAQ,CAAC,SAAS,EAAE,SAAS;gBAHpB,SAAS,EAAE,EAAE,EAAE,4CAA4C;IAG3D,SAAS,EAAE,SAAS;IAG/B;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,eAAe;IAQjE;;;OAGG;IACH,QAAQ,IAAI,MAAM;CAGnB;AAED;;GAEG;AACH,qBAAa,gBAAgB;IAEzB,QAAQ,CAAC,SAAS,EAAE,EAAE;IACtB,QAAQ,CAAC,GAAG,EAAE,OAAO;IAGrB,QAAQ,CAAC,SAAS,EAAE,SAAS;gBAJpB,SAAS,EAAE,EAAE,EACb,GAAG,EAAE,OAAO,EAAE,iDAAiD;IAG/D,SAAS,EAAE,SAAS;IAG/B;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,gBAAgB;IASlE;;;;;OAKG;IACH,QAAQ,IAAI,MAAM;IAIlB,MAAM,CAAC,KAAK,IAAI,gBAAgB;CAGjC"}

package/dest/services/reqresp/protocols/block_txs/block_txs_reqresp.js

@@ -0,0 +1,75 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { TxArray } from '@aztec/stdlib/tx';
+import { BitVector } from './bitvector.js';
+/**
+ * Request message for requesting specific transactions from a block
+ */ export class BlockTxsRequest {
+    blockHash;
+    txIndices;
+    constructor(blockHash, // BitVector indicating which txs from the proposal we are requesting
+    // 1 means we want the tx, 0 means we don't
+    txIndices){
+        this.blockHash = blockHash;
+        this.txIndices = txIndices;
+    }
+    /**
+   * Deserializes the BlockTxRequest object from a Buffer
+   * @param buffer - Buffer or BufferReader object to deserialize
+   * @returns An instance of BlockTxRequest
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const blockHash = Fr.fromBuffer(reader);
+        const txIndices = BitVector.fromBuffer(reader);
+        return new BlockTxsRequest(blockHash, txIndices);
+    }
+    /**
+   * Serializes the BlockTxRequest object into a Buffer
+   * @returns Buffer representation of the BlockTxRequest object
+   */ toBuffer() {
+        return serializeToBuffer([
+            this.blockHash,
+            this.txIndices.toBuffer()
+        ]);
+    }
+}
+/**
+ * Response message containing requested transactions from a block
+ */ export class BlockTxsResponse {
+    blockHash;
+    txs;
+    txIndices;
+    constructor(blockHash, txs, // BitVector indicating which txs from the proposal are available at the peer
+    // 1 means the tx is available, 0 means it is not
+    txIndices){
+        this.blockHash = blockHash;
+        this.txs = txs;
+        this.txIndices = txIndices;
+    }
+    /**
+   * Deserializes the BlockTxResponse object from a Buffer
+   * @param buffer - Buffer or BufferReader object to deserialize
+   * @returns An instance of BlockTxResponse
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const blockHash = Fr.fromBuffer(reader);
+        const txs = TxArray.fromBuffer(reader);
+        const txIndices = BitVector.fromBuffer(reader);
+        return new BlockTxsResponse(blockHash, txs, txIndices);
+    }
+    /**
+   * Serializes the BlockTxResponse object into a Buffer
+   * @dev: In current implementation, txIndices is serialized as Buffer of unknown length,
+   * thus we serialize it last
+   * @returns Buffer representation of the BlockTxResponse object
+   */ toBuffer() {
+        return serializeToBuffer([
+            this.blockHash,
+            this.txs.toBuffer(),
+            this.txIndices.toBuffer()
+        ]);
+    }
+    static empty() {
+        return new BlockTxsResponse(Fr.ZERO, new TxArray(), BitVector.init(0, []));
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from './block_txs_handler.js';
+export * from './bitvector.js';
+export * from './block_txs_reqresp.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/reqresp/protocols/block_txs/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from './block_txs_handler.js';
+export * from './bitvector.js';
+export * from './block_txs_reqresp.js';

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

@@ -76,14 +76,12 @@ export function decodeGoodbyeReason(buffer) {
  * @param peerManager - The peer manager.
  * @returns A resolved promise with the goodbye response.
  */ export function reqGoodbyeHandler(peerManager) {
-    return (peerId, _msg)=>{
-        const reason = decodeGoodbyeReason(_msg);
+    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.from([
-            0x0
-        ]));
+        return Promise.resolve(Buffer.alloc(0));
     };
 }

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

@@ -6,4 +6,6 @@ export * from './status.js';
 export * from './tx.js';
 export * from './goodbye.js';
 export * from './block.js';
+export * from './auth.js';
+export * from './block_txs/index.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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"}
+{"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;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC"}

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

@@ -5,3 +5,5 @@ export * from './status.js';
 export * from './tx.js';
 export * from './goodbye.js';
 export * from './block.js';
+export * from './auth.js';
+export * from './block_txs/index.js';

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

@@ -26,7 +26,9 @@ export declare class StatusMessage {
      * @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.

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

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/protocols/status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,KAAK,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAEpG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAQhD,qBAAa,aAAa;IAEtB,QAAQ,CAAC,2BAA2B,EAAE,MAAM;IAC5C,QAAQ,CAAC,iBAAiB,EAAE,MAAM;IAClC,QAAQ,CAAC,eAAe,EAAE,MAAM;IAChC,QAAQ,CAAC,oBAAoB,EAAE,MAAM;gBAH5B,2BAA2B,EAAE,MAAM,EACnC,iBAAiB,EAAE,MAAM,EACzB,eAAe,EAAE,MAAM,EACvB,oBAAoB,EAAE,MAAM;IAKvC;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa;IAY/D;;;OAGG;IACH,QAAQ;IAWR;;;;;OAKG;IACH,MAAM,CAAC,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,oBAAoB,GAAG,aAAa;IAUjG,QAAQ,CAAC,UAAU,EAAE,aAAa,GAAG,OAAO;CAI7C;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,2BAA2B,EAAE,MAAM,EACnC,sBAAsB,EAAE,sBAAsB,EAC9C,MAAM,CAAC,EAAE,MAAM,IAED,QAAQ,MAAM,EAAE,MAAM,MAAM,sCAU3C"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/protocols/status.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,KAAK,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAEpG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAQhD,qBAAa,aAAa;IAEtB,QAAQ,CAAC,2BAA2B,EAAE,MAAM;IAC5C,QAAQ,CAAC,iBAAiB,EAAE,MAAM;IAClC,QAAQ,CAAC,eAAe,EAAE,MAAM;IAChC,QAAQ,CAAC,oBAAoB,EAAE,MAAM;gBAH5B,2BAA2B,EAAE,MAAM,EACnC,iBAAiB,EAAE,MAAM,EACzB,eAAe,EAAE,MAAM,EACvB,oBAAoB,EAAE,MAAM;IAKvC;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa;IAY/D;;;OAGG;IACH,QAAQ;IAWR;;;;;OAKG;IACH,MAAM,CAAC,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,oBAAoB,GAAG,aAAa;IAUjG,MAAM,CAAC,MAAM,IAAI,aAAa;IAU9B,QAAQ,CAAC,UAAU,EAAE,aAAa,GAAG,OAAO;IAK5C,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO;CAQtC;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,2BAA2B,EAAE,MAAM,EACnC,sBAAsB,EAAE,sBAAsB,EAC9C,MAAM,CAAC,EAAE,MAAM,IAED,QAAQ,MAAM,EAAE,MAAM,MAAM,sCAU3C"}

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

@@ -1,3 +1,4 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex } from '@aztec/foundation/string';
 /*
@@ -43,10 +44,16 @@ import { bufferToHex } from '@aztec/foundation/string';
    */ static fromWorldStateSyncStatus(version, syncStatus) {
         return new StatusMessage(version, syncStatus.latestBlockNumber, syncStatus.latestBlockHash, syncStatus.finalisedBlockNumber);
     }
+    static random() {
+        return new StatusMessage('1.0.0', Math.floor(Math.random() * 100), Buffer32.random().toString(), 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.finalisedBlockNumber === other.finalisedBlockNumber;
+    }
 }
 /**
  * Handles the status request. By immediately responding  with the current node status.

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

@@ -1,4 +1,5 @@
 import type { P2PClientType } from '@aztec/stdlib/p2p';
+import { TxHash, TxHashArray } from '@aztec/stdlib/tx';
 import type { MemPools } from '../../../mem_pools/interface.js';
 import type { ReqRespSubProtocolHandler } from '../interface.js';
 /**
@@ -7,7 +8,17 @@ import type { ReqRespSubProtocolHandler } from '../interface.js';
  *
  * Handler for tx requests
  * @param mempools - the mempools
- * @returns the tx response message
+ * @returns the Tx request handler
  */
 export declare function reqRespTxHandler<T extends P2PClientType>(mempools: MemPools<T>): 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>;
 //# sourceMappingURL=tx.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"tx.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/protocols/tx.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAW,MAAM,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAIhE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAGjE;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,aAAa,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,yBAAyB,CAwB1G;AAED;;;;;;;;GAQG;AAGH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,SAAS,SAAI,GAAG,KAAK,CAAC,WAAW,CAAC,CAExF"}

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

@@ -1,20 +1,48 @@
-import { TxHash } from '@aztec/stdlib/tx';
+import { chunk } from '@aztec/foundation/collection';
+import { TxArray, TxHashArray } from '@aztec/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 response message
+ * @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)=>{
-        const txHash = TxHash.fromBuffer(msg);
-        const foundTx = await mempools.txPool.getTxByHash(txHash);
-        const buf = foundTx ? foundTx.toBuffer() : Buffer.alloc(0);
-        return buf;
+        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.
+ */ //TODO: (mralj) chunk size should by default be 8, this is just temporary until the protocol is implemented correctly
+//more info:  https://github.com/AztecProtocol/aztec-packages/pull/15516#pullrequestreview-2995474321
+export function chunkTxHashesRequest(hashes, chunkSize = 1) {
+    return chunk(hashes, chunkSize).map((chunk)=>new TxHashArray(...chunk));
+}

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

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

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

@@ -21,6 +21,16 @@ export const DEFAULT_RATE_LIMITS = {
             quotaCount: 10
         }
     },
+    [ReqRespSubProtocol.AUTH]: {
+        peerLimit: {
+            quotaTimeMs: 1000,
+            quotaCount: 5
+        },
+        globalLimit: {
+            quotaTimeMs: 1000,
+            quotaCount: 10
+        }
+    },
     [ReqRespSubProtocol.TX]: {
         peerLimit: {
             quotaTimeMs: 1000,
@@ -50,5 +60,15 @@ export const DEFAULT_RATE_LIMITS = {
             quotaTimeMs: 1000,
             quotaCount: 10
         }
+    },
+    [ReqRespSubProtocol.BLOCK_TXS]: {
+        peerLimit: {
+            quotaTimeMs: 1000,
+            quotaCount: 10
+        },
+        globalLimit: {
+            quotaTimeMs: 1000,
+            quotaCount: 200
+        }
     }
 };

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

@@ -3,7 +3,7 @@ import type { PeerId } from '@libp2p/interface';
 import type { Libp2p } from 'libp2p';
 import type { PeerScoring } from '../peer-manager/peer_scoring.js';
 import { type P2PReqRespConfig } from './config.js';
-import { type ReqRespInterface, type ReqRespResponse, ReqRespSubProtocol, type ReqRespSubProtocolHandlers, type ReqRespSubProtocolRateLimits, type ReqRespSubProtocolValidators, type SubProtocolMap } from './interface.js';
+import { type ReqRespInterface, type ReqRespResponse, ReqRespSubProtocol, type ReqRespSubProtocolHandler, type ReqRespSubProtocolHandlers, type ReqRespSubProtocolRateLimits, type ReqRespSubProtocolValidators, type SubProtocolMap } from './interface.js';
 /**
  * The Request Response Service
  *
@@ -22,7 +22,6 @@ export declare class ReqResp implements ReqRespInterface {
     private libp2p;
     private peerScoring;
     private logger;
-    private overallRequestTimeoutMs;
     private individualRequestTimeoutMs;
     private dialTimeoutMs;
     private subProtocolHandlers;
@@ -38,40 +37,11 @@ export declare class ReqResp implements ReqRespInterface {
      * Start the reqresp service
      */
     start(subProtocolHandlers: ReqRespSubProtocolHandlers, subProtocolValidators: ReqRespSubProtocolValidators): Promise<void>;
+    addSubProtocol(subProtocol: ReqRespSubProtocol, handler: ReqRespSubProtocolHandler, validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol]): Promise<void>;
     /**
      * Stop the reqresp service
      */
     stop(): Promise<void>;
-    /**
-     * Send a request to peers, returns the first response
-     *
-     * @param subProtocol - The protocol being requested
-     * @param request - The request to send
-     * @returns - The response from the peer, otherwise undefined
-     *
-     * @description
-     * This method attempts to send a request to all active peers using the specified sub-protocol.
-     * It opens a stream with each peer, sends the request, and awaits a response.
-     * If a valid response is received, it returns the response; otherwise, it continues to the next peer.
-     * If no response is received from any peer, it returns undefined.
-     *
-     * The method performs the following steps:
-     * - Sample a peer to send the request to.
-     * - Opens a stream with the peer using the specified sub-protocol.
-     *
-     * When a response is received, it is validated using the given sub protocols response validator.
-     * To see the interface for the response validator - see `interface.ts`
-     *
-     * Failing a response validation requests in a severe peer penalty, and will
-     * prompt the node to continue to search to the next peer.
-     * For example, a transaction request validator will check that the payload returned does in fact
-     * match the txHash that was requested. A peer that fails this check an only be an extremely naughty peer.
-     *
-     * This entire operation is wrapped in an overall timeout, that is independent of the
-     * peer it is requesting data from.
-     *
-     */
-    sendRequest<SubProtocol extends ReqRespSubProtocol>(subProtocol: SubProtocol, request: InstanceType<SubProtocolMap[SubProtocol]['request']>): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined>;
     /**
      * Request multiple messages over the same sub protocol, balancing the requests across peers.
      *
@@ -94,7 +64,7 @@ export declare class ReqResp implements ReqRespInterface {
      *
      * @throws {CollectiveReqRespTimeoutError} - If the request batch exceeds the specified timeout (`timeoutMs`).
      */
-    sendBatchRequest<SubProtocol extends ReqRespSubProtocol>(subProtocol: SubProtocol, requests: InstanceType<SubProtocolMap[SubProtocol]['request']>[], pinnedPeer: PeerId | undefined, timeoutMs?: number, maxPeers?: number, maxRetryAttempts?: number): Promise<(InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined)[]>;
+    sendBatchRequest<SubProtocol extends ReqRespSubProtocol>(subProtocol: SubProtocol, requests: InstanceType<SubProtocolMap[SubProtocol]['request']>[], pinnedPeer: PeerId | undefined, timeoutMs?: number, maxPeers?: number, maxRetryAttempts?: number): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']>[]>;
     /**
      * Sends a request to a specific peer
      *
@@ -132,10 +102,6 @@ export declare class ReqResp implements ReqRespInterface {
      * @returns If the error is non pubishable, then undefined is returned, otherwise the peer is penalized
      */
     private handleResponseError;
-    /**
-     * Categorize the error and log it.
-     */
-    private categorizeError;
     /**
      * Read a message returned from a stream into a single buffer
      *
@@ -148,7 +114,8 @@ export declare class ReqResp implements ReqRespInterface {
      * Stream Handler
      * Reads the incoming stream, determines the protocol, then triggers the appropriate handler
      *
-     * @param param0 - The incoming stream data
+     * @param protocol - The sub protocol to handle
+     * @param incomingStream - The incoming stream data containing the stream and connection
      *
      * @description
      * An individual stream handler will be bound to each sub protocol, and handles returning data back
@@ -161,6 +128,37 @@ export declare class ReqResp implements ReqRespInterface {
      * if they exceed their peer specific limits.
      */
     private streamHandler;
-    private sendErrorChunk;
+    /**
+     * Reads incoming data from the stream, processes it according to the sub protocol,
+     * and puts response back into the stream.
+     *
+     * @param protocol - The sub protocol to use for processing the stream
+     * @param incomingStream - The incoming stream data containing the stream and connection
+     *
+     * */
+    private processStream;
+    /**
+     * Try to send error status to the peer. We say try, because the stream,
+     * might already be closed
+     * @param stream - The stream opened between us and the peer
+     * @param status - The error status to send back to the peer
+     * @returns true if error was sent successfully, otherwise false
+     *
+     */
+    private trySendError;
+    private handleRequestError;
+    /**
+     * Categorize the request error and log it.
+     *
+     * @returns Severity of the error, or undefined if the error is not punishable.
+     */
+    private categorizeRequestError;
+    /**
+     * Categorize the response error and log it.
+     *
+     * @returns Severity of the error, or undefined if the error is not punishable.
+     */
+    private categorizeResponseError;
+    private categorizeConnectionErrors;
 }
 //# sourceMappingURL=reqresp.d.ts.map