@aztec/p2p 1.2.1 → 2.0.0-nightly.20250813

package/src/services/reqresp/protocols/block_txs/block_txs_reqresp.ts

@@ -0,0 +1,79 @@
+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 {
+  constructor(
+    readonly blockHash: Fr, // 32 byte hash of the proposed block header
+    // BitVector indicating which txs from the proposal we are requesting
+    // 1 means we want the tx, 0 means we don't
+    readonly 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 {
+    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(): Buffer {
+    return serializeToBuffer([this.blockHash, this.txIndices.toBuffer()]);
+  }
+}
+
+/**
+ * Response message containing requested transactions from a block
+ */
+export class BlockTxsResponse {
+  constructor(
+    readonly blockHash: Fr,
+    readonly txs: TxArray, // List of transactions we requested and peer has
+    // BitVector indicating which txs from the proposal are available at the peer
+    // 1 means the tx is available, 0 means it is not
+    readonly 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 {
+    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(): Buffer {
+    return serializeToBuffer([this.blockHash, this.txs.toBuffer(), this.txIndices.toBuffer()]);
+  }
+
+  static empty(): BlockTxsResponse {
+    return new BlockTxsResponse(Fr.ZERO, new TxArray(), BitVector.init(0, []));
+  }
+}

package/src/services/reqresp/protocols/block_txs/index.ts

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

package/src/services/reqresp/protocols/goodbye.ts

@@ -90,14 +90,14 @@ export class GoodbyeProtocolHandler {
  * @returns A resolved promise with the goodbye response.
  */
 export function reqGoodbyeHandler(peerManager: PeerManagerInterface): ReqRespSubProtocolHandler {
-  return (peerId: PeerId, _msg: Buffer) => {
-    const reason = decodeGoodbyeReason(_msg);
+  return (peerId: PeerId, msg: Buffer) => {
+    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/src/services/reqresp/protocols/index.ts

@@ -6,3 +6,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/src/services/reqresp/protocols/status.ts

@@ -1,3 +1,4 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
 import type { Logger } from '@aztec/foundation/log';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex } from '@aztec/foundation/string';
@@ -69,10 +70,29 @@ export class StatusMessage {
     );
   }
 
+  static random(): StatusMessage {
+    return new StatusMessage(
+      '1.0.0',
+      Math.floor(Math.random() * 100),
+      Buffer32.random().toString(),
+      Math.floor(Math.random() * 100),
+      //TODO: add finalisedBlockHash
+    );
+  }
+
   validate(peerStatus: StatusMessage): boolean {
     // TODO: Validate other fields as well
     return this.compressedComponentsVersion === peerStatus.compressedComponentsVersion;
   }
+
+  equals(other: StatusMessage): boolean {
+    return (
+      this.compressedComponentsVersion === other.compressedComponentsVersion &&
+      this.latestBlockNumber === other.latestBlockNumber &&
+      this.latestBlockHash === other.latestBlockHash &&
+      this.finalisedBlockNumber === other.finalisedBlockNumber
+    );
+  }
 }
 
 /**

package/src/services/reqresp/protocols/tx.ts

@@ -1,10 +1,12 @@
+import { chunk } from '@aztec/foundation/collection';
 import type { P2PClientType } from '@aztec/stdlib/p2p';
-import { TxHash } from '@aztec/stdlib/tx';
+import { TxArray, TxHash, TxHashArray } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 
 import type { MemPools } from '../../../mem_pools/interface.js';
 import type { ReqRespSubProtocolHandler } from '../interface.js';
+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
@@ -12,18 +14,45 @@ 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 function reqRespTxHandler<T extends P2PClientType>(mempools: MemPools<T>): ReqRespSubProtocolHandler {
   /**
    * 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: PeerId, msg: Buffer) => {
-    const txHash = TxHash.fromBuffer(msg);
-    const foundTx = await mempools.txPool.getTxByHash(txHash);
-    const buf = foundTx ? foundTx.toBuffer() : Buffer.alloc(0);
-    return buf;
+    let txHashes: TxHashArray;
+    try {
+      txHashes = TxHashArray.fromBuffer(msg);
+    } catch (err: any) {
+      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: any) {
+      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: TxHash[], chunkSize = 1): Array<TxHashArray> {
+  return chunk(hashes, chunkSize).map(chunk => new TxHashArray(...chunk));
+}

package/src/services/reqresp/rate-limiter/rate_limits.ts

@@ -22,6 +22,16 @@ export const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits = {
       quotaCount: 10,
     },
   },
+  [ReqRespSubProtocol.AUTH]: {
+    peerLimit: {
+      quotaTimeMs: 1000,
+      quotaCount: 5,
+    },
+    globalLimit: {
+      quotaTimeMs: 1000,
+      quotaCount: 10,
+    },
+  },
   [ReqRespSubProtocol.TX]: {
     peerLimit: {
       quotaTimeMs: 1000,
@@ -52,4 +62,14 @@ export const DEFAULT_RATE_LIMITS: ReqRespSubProtocolRateLimits = {
       quotaCount: 10,
     },
   },
+  [ReqRespSubProtocol.BLOCK_TXS]: {
+    peerLimit: {
+      quotaTimeMs: 1000,
+      quotaCount: 10,
+    },
+    globalLimit: {
+      quotaTimeMs: 1000,
+      quotaCount: 200,
+    },
+  },
 };