@aztec/p2p 0.87.5 → 0.87.7

package/src/services/reqresp/reqresp.ts

@@ -1,4 +1,5 @@
 // @attribution: lodestar impl for inspiration
+import { compactArray } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { executeTimeout } from '@aztec/foundation/timer';
 import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
@@ -25,6 +26,7 @@ import {
   type ReqRespResponse,
   ReqRespSubProtocol,
   type ReqRespSubProtocolHandlers,
+  type ReqRespSubProtocolRateLimits,
   type ReqRespSubProtocolValidators,
   type SubProtocolMap,
   subProtocolMap,
@@ -72,6 +74,7 @@ export class ReqResp {
     config: P2PReqRespConfig,
     private libp2p: Libp2p,
     private peerScoring: PeerScoring,
+    rateLimits: Partial<ReqRespSubProtocolRateLimits> = {},
     telemetryClient: TelemetryClient = getTelemetryClient(),
   ) {
     this.logger = createLogger('p2p:reqresp');
@@ -79,7 +82,7 @@ export class ReqResp {
     this.overallRequestTimeoutMs = config.overallRequestTimeoutMs;
     this.individualRequestTimeoutMs = config.individualRequestTimeoutMs;
 
-    this.rateLimiter = new RequestResponseRateLimiter(peerScoring);
+    this.rateLimiter = new RequestResponseRateLimiter(peerScoring, rateLimits);
 
     // Connection sampler is used to sample our connected peers
     this.connectionSampler = new ConnectionSampler(libp2p);
@@ -261,6 +264,7 @@ export class ReqResp {
   async sendBatchRequest<SubProtocol extends ReqRespSubProtocol>(
     subProtocol: SubProtocol,
     requests: InstanceType<SubProtocolMap[SubProtocol]['request']>[],
+    pinnedPeer: PeerId | undefined,
     timeoutMs = 10000,
     maxPeers = Math.max(10, Math.ceil(requests.length / 3)),
     maxRetryAttempts = 3,
@@ -274,10 +278,15 @@ export class ReqResp {
       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);
+      const batchSampler = new BatchConnectionSampler(
+        this.connectionSampler,
+        requests.length,
+        maxPeers,
+        compactArray([pinnedPeer]), // Exclude pinned peer from sampling, we will forcefully send all requests to it
+      );
 
-      if (batchSampler.activePeerCount === 0) {
-        this.logger.debug('No active peers to send requests to');
+      if (batchSampler.activePeerCount === 0 && !pinnedPeer) {
+        this.logger.warn('No active peers to send requests to');
         return [];
       }
 
@@ -308,6 +317,16 @@ export class ReqResp {
           requestBatches.get(peerAsString)!.indices.push(requestIndex);
         }
 
+        // If there is a pinned peer, we will always send every request to that peer
+        // We use the default limits for the subprotocol to avoid hitting the rate limiter
+        if (pinnedPeer) {
+          const limit = this.rateLimiter.getRateLimits(subProtocol).peerLimit.quotaCount;
+          requestBatches.set(pinnedPeer.toString(), {
+            peerId: pinnedPeer,
+            indices: Array.from(pendingRequestIndices.values()).slice(0, limit),
+          });
+        }
+
         // Make parallel requests for each peer's batch
         // A batch entry will look something like this:
         // PeerId0: [0, 1, 2, 3]
@@ -323,6 +342,7 @@ export class ReqResp {
               const peerResults: { index: number; response: InstanceType<SubProtocolMap[SubProtocol]['response']> }[] =
                 [];
               for (const index of indices) {
+                this.logger.trace(`Sending request ${index} to peer ${peerAsString}`);
                 const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffers[index]);
 
                 // Check the status of the response buffer
@@ -621,8 +641,9 @@ export class ReqResp {
             const response = await handler(connection.remotePeer, msg);
 
             if (protocol === ReqRespSubProtocol.GOODBYE) {
+              // NOTE: The stream was already closed by Goodbye handler
+              // peerManager.goodbyeReceived(peerId, reason); will call libp2p.hangUp closing all active streams and connections
               // Don't respond
-              await stream.close();
               return;
             }
 
@@ -645,18 +666,25 @@ export class ReqResp {
         errorStatus = e.status;
       }
 
-      const sendErrorChunk = this.sendErrorChunk(errorStatus);
-
-      // Return and yield the response chunk
-      await pipe(
-        stream,
-        async function* (_source: any) {
-          yield* sendErrorChunk;
-        },
-        stream,
-      );
+      if (stream.status === 'open') {
+        const sendErrorChunk = this.sendErrorChunk(errorStatus);
+        // Return and yield the response chunk
+        await pipe(
+          stream,
+          async function* (_source: any) {
+            yield* sendErrorChunk;
+          },
+          stream,
+        );
+      } else {
+        this.logger.debug('Stream already closed, not sending error response', { protocol, err: e, errorStatus });
+      }
     } finally {
-      await stream.close();
+      //NOTE: All other status codes indicate closed stream.
+      //Either graceful close (closed/closing) or forced close (aborted/reset)
+      if (stream.status === 'open') {
+        await stream.close();
+      }
     }
   }
 

package/src/services/service.ts

@@ -13,6 +13,8 @@ export enum PeerDiscoveryState {
   STOPPED = 'stopped',
 }
 
+export type P2PBlockReceivedCallback = (block: BlockProposal, sender: PeerId) => Promise<BlockAttestation | undefined>;
+
 /**
  * The interface for a P2P service implementation.
  */
@@ -57,13 +59,14 @@ export interface P2PService {
   sendBatchRequest<Protocol extends ReqRespSubProtocol>(
     protocol: Protocol,
     requests: InstanceType<SubProtocolMap[Protocol]['request']>[],
+    pinnedPeerId?: PeerId,
     timeoutMs?: number,
     maxPeers?: number,
     maxRetryAttempts?: number,
   ): Promise<(InstanceType<SubProtocolMap[Protocol]['response']> | undefined)[]>;
 
   // Leaky abstraction: fix https://github.com/AztecProtocol/aztec-packages/issues/7963
-  registerBlockReceivedCallback(callback: (block: BlockProposal) => Promise<BlockAttestation | undefined>): void;
+  registerBlockReceivedCallback(callback: P2PBlockReceivedCallback): void;
 
   getEnr(): ENR | undefined;
 

package/src/services/tx_collector.ts

@@ -0,0 +1,103 @@
+import { compactArray } from '@aztec/foundation/collection';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
+import type { Tx, TxHash } from '@aztec/stdlib/tx';
+
+import type { P2PClient } from '../client/p2p_client.js';
+
+export class TxCollector {
+  constructor(
+    private p2pClient: Pick<
+      P2PClient,
+      'getTxsByHashFromPool' | 'hasTxsInPool' | 'getTxsByHash' | 'validate' | 'requestTxsByHash'
+    >,
+    private log: Logger = createLogger('p2p:tx-collector'),
+  ) {}
+
+  async collectForBlockProposal(
+    proposal: BlockProposal,
+    peerWhoSentTheProposal: any,
+  ): Promise<{ txs: Tx[]; missing?: TxHash[] }> {
+    if (proposal.payload.txHashes.length === 0) {
+      this.log.verbose(`Received block proposal with no transactions, skipping transaction availability check`);
+      return { txs: [] };
+    }
+    // Is this a new style proposal?
+    if (proposal.txs && proposal.txs.length > 0 && proposal.txs.length === proposal.payload.txHashes.length) {
+      // Yes, any txs that we already have we should use
+      this.log.info(`Using new style proposal with ${proposal.txs.length} transactions`);
+
+      // Request from the pool based on the signed hashes in the payload
+      const hashesFromPayload = proposal.payload.txHashes;
+      const txsToUse = await this.p2pClient.getTxsByHashFromPool(hashesFromPayload);
+
+      const missingTxs = txsToUse.filter(tx => tx === undefined).length;
+      if (missingTxs > 0) {
+        this.log.verbose(
+          `Missing ${missingTxs}/${hashesFromPayload.length} transactions in the tx pool, will attempt to take from the proposal`,
+        );
+      }
+
+      let usedFromProposal = 0;
+
+      // Fill any holes with txs in the proposal, provided their hash matches the hash in the payload
+      for (let i = 0; i < txsToUse.length; i++) {
+        if (txsToUse[i] === undefined) {
+          // We don't have the transaction, take from the proposal, provided the hash is the same
+          const hashOfTxInProposal = await proposal.txs[i].getTxHash();
+          if (hashOfTxInProposal.equals(hashesFromPayload[i])) {
+            // Hash is equal, we can use the tx from the proposal
+            txsToUse[i] = proposal.txs[i];
+            usedFromProposal++;
+          } else {
+            this.log.warn(
+              `Unable to take tx: ${hashOfTxInProposal.toString()} from the proposal, it does not match payload hash: ${hashesFromPayload[
+                i
+              ].toString()}`,
+            );
+          }
+        }
+      }
+
+      // See if we still have any holes, if there are then we were not successful and will try the old method
+      if (txsToUse.some(tx => tx === undefined)) {
+        this.log.warn(`Failed to use transactions from proposal. Falling back to old proposal logic`);
+      } else {
+        this.log.info(
+          `Successfully used ${usedFromProposal}/${hashesFromPayload.length} transactions from the proposal`,
+        );
+
+        await this.p2pClient.validate(txsToUse as Tx[]);
+        return { txs: txsToUse as Tx[] };
+      }
+    }
+
+    this.log.info(`Using old style proposal with ${proposal.payload.txHashes.length} transactions`);
+
+    // Old style proposal, we will perform a request by hash from pool
+    // This will request from network any txs that are missing
+    const txHashes: TxHash[] = proposal.payload.txHashes;
+
+    // This part is just for logging that we are requesting from the network
+    const availability = await this.p2pClient.hasTxsInPool(txHashes);
+    const notAvailable = availability.filter(availability => availability === false);
+    if (notAvailable.length) {
+      this.log.verbose(
+        `Missing ${notAvailable.length} transactions in the tx pool, will need to request from the network`,
+      );
+    }
+
+    // This will request from the network any txs that are missing
+    // NOTE: this could still return missing txs so we need to (1) be careful to handle undefined and (2) keep the txs in the correct order for re-execution
+    const maybeRetrievedTxs = await this.p2pClient.getTxsByHash(txHashes, peerWhoSentTheProposal);
+    const missingTxs = compactArray(
+      maybeRetrievedTxs.map((tx, index) => (tx === undefined ? txHashes[index] : undefined)),
+    );
+    // if we found all txs, this is a noop. If we didn't find all txs then validate the ones we did find and tell the validator to skip attestations because missingTxs.length > 0
+    const retrievedTxs = compactArray(maybeRetrievedTxs);
+
+    await this.p2pClient.validate(retrievedTxs);
+
+    return { txs: retrievedTxs, missing: missingTxs };
+  }
+}

package/src/test-helpers/reqresp-nodes.ts

@@ -33,6 +33,7 @@ import type { P2PReqRespConfig } from '../services/reqresp/config.js';
 import {
   ReqRespSubProtocol,
   type ReqRespSubProtocolHandlers,
+  type ReqRespSubProtocolRateLimits,
   type ReqRespSubProtocolValidators,
   noopValidator,
 } from '../services/reqresp/interface.js';
@@ -172,8 +173,12 @@ export const MOCK_SUB_PROTOCOL_VALIDATORS: ReqRespSubProtocolValidators = {
  * @param numberOfNodes - the number of nodes to create
  * @returns An array of the created nodes
  */
-export const createNodes = (peerScoring: PeerScoring, numberOfNodes: number): Promise<ReqRespNode[]> => {
-  return timesParallel(numberOfNodes, () => createReqResp(peerScoring));
+export const createNodes = (
+  peerScoring: PeerScoring,
+  numberOfNodes: number,
+  rateLimits: Partial<ReqRespSubProtocolRateLimits> = {},
+): Promise<ReqRespNode[]> => {
+  return timesParallel(numberOfNodes, () => createReqResp(peerScoring, rateLimits));
 };
 
 export const startNodes = async (
@@ -192,17 +197,17 @@ export const stopNodes = async (nodes: ReqRespNode[]): Promise<void> => {
 };
 
 // Create a req resp node, exposing the underlying p2p node
-export const createReqResp = async (peerScoring: PeerScoring): Promise<ReqRespNode> => {
+export const createReqResp = async (
+  peerScoring: PeerScoring,
+  rateLimits: Partial<ReqRespSubProtocolRateLimits> = {},
+): Promise<ReqRespNode> => {
   const p2p = await createLibp2pNode();
   const config: P2PReqRespConfig = {
     overallRequestTimeoutMs: 4000,
     individualRequestTimeoutMs: 2000,
   };
-  const req = new ReqResp(config, p2p, peerScoring);
-  return {
-    p2p,
-    req,
-  };
+  const req = new ReqResp(config, p2p, peerScoring, rateLimits);
+  return { p2p, req };
 };
 
 // Given a node list; hand shake all of the nodes with each other

package/src/testbench/p2p_client_testbench_worker.ts

@@ -49,7 +49,7 @@ function mockTxPool(): TxPool {
     getTxStatus: () => Promise.resolve(TxStatus.PENDING),
     getTxsByHash: () => Promise.resolve([]),
     hasTxs: () => Promise.resolve([]),
-    setMaxTxPoolSize: () => Promise.resolve(),
+    updateConfig: () => {},
     markTxsAsNonEvictable: () => Promise.resolve(),
   };
 }