@aztec/p2p 0.55.0 → 0.56.0

package/src/service/reqresp/reqresp.ts

@@ -8,11 +8,17 @@ import { type Libp2p } from 'libp2p';
 import { type Uint8ArrayList } from 'uint8arraylist';
 
 import { CollectiveReqRespTimeoutError, IndiviualReqRespTimeoutError } from '../../errors/reqresp.error.js';
+import { type PeerManager } from '../peer_manager.js';
+import { PeerErrorSeverity } from '../peer_scoring.js';
 import { type P2PReqRespConfig } from './config.js';
 import {
   DEFAULT_SUB_PROTOCOL_HANDLERS,
+  DEFAULT_SUB_PROTOCOL_VALIDATORS,
   type ReqRespSubProtocol,
   type ReqRespSubProtocolHandlers,
+  type ReqRespSubProtocolValidators,
+  type SubProtocolMap,
+  subProtocolMap,
 } from './interface.js';
 import { RequestResponseRateLimiter } from './rate_limiter/rate_limiter.js';
 
@@ -35,23 +41,28 @@ export class ReqResp {
   private overallRequestTimeoutMs: number;
   private individualRequestTimeoutMs: number;
 
+  // Warning, if the `start` function is not called as the parent class constructor, then the default sub protocol handlers will be used ( not good )
   private subProtocolHandlers: ReqRespSubProtocolHandlers = DEFAULT_SUB_PROTOCOL_HANDLERS;
+  private subProtocolValidators: ReqRespSubProtocolValidators = DEFAULT_SUB_PROTOCOL_VALIDATORS;
+
   private rateLimiter: RequestResponseRateLimiter;
 
-  constructor(config: P2PReqRespConfig, protected readonly libp2p: Libp2p) {
+  constructor(config: P2PReqRespConfig, protected readonly libp2p: Libp2p, private peerManager: PeerManager) {
     this.logger = createDebugLogger('aztec:p2p:reqresp');
 
     this.overallRequestTimeoutMs = config.overallRequestTimeoutMs;
     this.individualRequestTimeoutMs = config.individualRequestTimeoutMs;
 
-    this.rateLimiter = new RequestResponseRateLimiter();
+    this.rateLimiter = new RequestResponseRateLimiter(peerManager);
   }
 
   /**
    * Start the reqresp service
    */
-  async start(subProtocolHandlers: ReqRespSubProtocolHandlers) {
+  async start(subProtocolHandlers: ReqRespSubProtocolHandlers, subProtocolValidators: ReqRespSubProtocolValidators) {
     this.subProtocolHandlers = subProtocolHandlers;
+    this.subProtocolValidators = subProtocolValidators;
+
     // Register all protocol handlers
     for (const subProtocol of Object.keys(this.subProtocolHandlers)) {
       await this.libp2p.handle(subProtocol, this.streamHandler.bind(this, subProtocol as ReqRespSubProtocol));
@@ -76,29 +87,64 @@ export class ReqResp {
    * Send a request to peers, returns the first response
    *
    * @param subProtocol - The protocol being requested
-   * @param payload - The payload to send
+   * @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:
+   * - Iterates over all active peers.
+   * - Opens a stream with each 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: ReqRespSubProtocol, payload: Buffer): Promise<Buffer | undefined> {
+  async sendRequest<SubProtocol extends ReqRespSubProtocol>(
+    subProtocol: SubProtocol,
+    request: InstanceType<SubProtocolMap[SubProtocol]['request']>,
+  ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined> {
     const requestFunction = async () => {
+      const responseValidator = this.subProtocolValidators[subProtocol];
+      const requestBuffer = request.toBuffer();
+
       // Get active peers
       const peers = this.libp2p.getPeers();
 
       // Attempt to ask all of our peers
       for (const peer of peers) {
-        const response = await this.sendRequestToPeer(peer, subProtocol, payload);
+        const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffer);
 
         // 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.length > 0) {
-          return response;
+          const object = subProtocolMap[subProtocol].response.fromBuffer(response);
+          // The response validator handles peer punishment within
+          const isValid = await responseValidator(request, object, peer);
+          if (!isValid) {
+            this.logger.error(`Invalid response for ${subProtocol} from ${peer.toString()}`);
+            return undefined;
+          }
+          return object;
         }
       }
       return undefined;
     };
 
     try {
-      return await executeTimeoutWithCustomError<Buffer | undefined>(
+      return await executeTimeoutWithCustomError<InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined>(
         requestFunction,
         this.overallRequestTimeoutMs,
         () => new CollectiveReqRespTimeoutError(),
@@ -112,10 +158,26 @@ export class ReqResp {
   /**
    * 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: PeerId,
@@ -128,6 +190,7 @@ export class ReqResp {
 
       this.logger.debug(`Stream opened with ${peerId.toString()} for ${subProtocol}`);
 
+      // Open the stream with a timeout
       const result = await executeTimeoutWithCustomError<Buffer>(
         (): Promise<Buffer> => pipe([payload], stream!, this.readMessage),
         this.individualRequestTimeoutMs,
@@ -140,6 +203,7 @@ export class ReqResp {
       return result;
     } catch (e: any) {
       this.logger.error(`${e.message} | peerId: ${peerId.toString()} | subProtocol: ${subProtocol}`);
+      this.peerManager.penalizePeer(peerId, PeerErrorSeverity.HighToleranceError);
     } finally {
       if (stream) {
         try {
@@ -172,6 +236,16 @@ export class ReqResp {
    * 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.
    */
   private async streamHandler(protocol: ReqRespSubProtocol, { stream, connection }: IncomingStreamData) {
     // Store a reference to from this for the async generator

package/src/tx_validator/aggregate_tx_validator.ts

@@ -0,0 +1,34 @@
+import { type ProcessedTx, type Tx, type TxValidator } from '@aztec/circuit-types';
+
+export class AggregateTxValidator<T extends Tx | ProcessedTx> implements TxValidator<T> {
+  #validators: TxValidator<T>[];
+  constructor(...validators: TxValidator<T>[]) {
+    if (validators.length === 0) {
+      throw new Error('At least one validator must be provided');
+    }
+
+    this.#validators = validators;
+  }
+
+  async validateTxs(txs: T[]): Promise<[validTxs: T[], invalidTxs: T[]]> {
+    const invalidTxs: T[] = [];
+    let txPool = txs;
+    for (const validator of this.#validators) {
+      const [valid, invalid] = await validator.validateTxs(txPool);
+      invalidTxs.push(...invalid);
+      txPool = valid;
+    }
+
+    return [txPool, invalidTxs];
+  }
+
+  async validateTx(tx: T): Promise<boolean> {
+    for (const validator of this.#validators) {
+      const valid = await validator.validateTx(tx);
+      if (!valid) {
+        return false;
+      }
+    }
+    return true;
+  }
+}

package/src/tx_validator/data_validator.ts

@@ -0,0 +1,65 @@
+import { Tx, type TxValidator } from '@aztec/circuit-types';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+export class DataTxValidator implements TxValidator<Tx> {
+  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_data');
+
+  validateTxs(txs: Tx[]): Promise<[validTxs: Tx[], invalidTxs: Tx[]]> {
+    const validTxs: Tx[] = [];
+    const invalidTxs: Tx[] = [];
+    for (const tx of txs) {
+      if (!this.#hasCorrectExecutionRequests(tx)) {
+        invalidTxs.push(tx);
+        continue;
+      }
+
+      validTxs.push(tx);
+    }
+
+    return Promise.resolve([validTxs, invalidTxs]);
+  }
+
+  validateTx(tx: Tx): Promise<boolean> {
+    return Promise.resolve(this.#hasCorrectExecutionRequests(tx));
+  }
+
+  #hasCorrectExecutionRequests(tx: Tx): boolean {
+    const callRequests = [
+      ...tx.data.getRevertiblePublicCallRequests(),
+      ...tx.data.getNonRevertiblePublicCallRequests(),
+    ];
+    if (callRequests.length !== tx.enqueuedPublicFunctionCalls.length) {
+      this.#log.warn(
+        `Rejecting tx ${Tx.getHash(tx)} because of mismatch number of execution requests for public calls. Expected ${
+          callRequests.length
+        }. Got ${tx.enqueuedPublicFunctionCalls.length}.`,
+      );
+      return false;
+    }
+
+    const invalidExecutionRequestIndex = tx.enqueuedPublicFunctionCalls.findIndex(
+      (execRequest, i) => !execRequest.isForCallRequest(callRequests[i]),
+    );
+    if (invalidExecutionRequestIndex !== -1) {
+      this.#log.warn(
+        `Rejecting tx ${Tx.getHash(
+          tx,
+        )} because of incorrect execution requests for public call at index ${invalidExecutionRequestIndex}.`,
+      );
+      return false;
+    }
+
+    const teardownCallRequest = tx.data.getTeardownPublicCallRequest();
+    const isInvalidTeardownExecutionRequest =
+      (!teardownCallRequest && !tx.publicTeardownFunctionCall.isEmpty()) ||
+      (teardownCallRequest && !tx.publicTeardownFunctionCall.isForCallRequest(teardownCallRequest));
+    if (isInvalidTeardownExecutionRequest) {
+      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} because of incorrect teardown execution requests.`);
+      return false;
+    }
+
+    return true;
+  }
+
+  // TODO: Check logs.
+}

package/src/tx_validator/double_spend_validator.ts

@@ -0,0 +1,69 @@
+import { type AnyTx, Tx, type TxValidator } from '@aztec/circuit-types';
+import { Fr } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+export interface NullifierSource {
+  getNullifierIndex: (nullifier: Fr) => Promise<bigint | undefined>;
+}
+
+export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
+  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_double_spend');
+  #nullifierSource: NullifierSource;
+
+  constructor(nullifierSource: NullifierSource, private readonly isValidatingBlock: boolean = true) {
+    this.#nullifierSource = nullifierSource;
+  }
+
+  async validateTxs(txs: T[]): Promise<[validTxs: T[], invalidTxs: T[]]> {
+    const validTxs: T[] = [];
+    const invalidTxs: T[] = [];
+    const thisBlockNullifiers = new Set<bigint>();
+
+    for (const tx of txs) {
+      if (!(await this.#uniqueNullifiers(tx, thisBlockNullifiers))) {
+        invalidTxs.push(tx);
+        continue;
+      }
+
+      validTxs.push(tx);
+    }
+
+    return [validTxs, invalidTxs];
+  }
+
+  validateTx(tx: T): Promise<boolean> {
+    return this.#uniqueNullifiers(tx, new Set<bigint>());
+  }
+
+  async #uniqueNullifiers(tx: AnyTx, thisBlockNullifiers: Set<bigint>): Promise<boolean> {
+    const nullifiers = tx.data.getNonEmptyNullifiers().map(x => x.toBigInt());
+
+    // Ditch this tx if it has repeated nullifiers
+    const uniqueNullifiers = new Set(nullifiers);
+    if (uniqueNullifiers.size !== nullifiers.length) {
+      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for emitting duplicate nullifiers`);
+      return false;
+    }
+
+    if (this.isValidatingBlock) {
+      for (const nullifier of nullifiers) {
+        if (thisBlockNullifiers.has(nullifier)) {
+          this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for repeating a nullifier in the same block`);
+          return false;
+        }
+
+        thisBlockNullifiers.add(nullifier);
+      }
+    }
+
+    const nullifierIndexes = await Promise.all(nullifiers.map(n => this.#nullifierSource.getNullifierIndex(new Fr(n))));
+
+    const hasDuplicates = nullifierIndexes.some(index => index !== undefined);
+    if (hasDuplicates) {
+      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for repeating nullifiers present in state trees`);
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/tx_validator/index.ts

@@ -0,0 +1,5 @@
+export * from './aggregate_tx_validator.js';
+export * from './data_validator.js';
+export * from './double_spend_validator.js';
+export * from './metadata_validator.js';
+export * from './tx_proof_validator.js';

package/src/tx_validator/metadata_validator.ts

@@ -0,0 +1,65 @@
+import { type AnyTx, Tx, type TxValidator } from '@aztec/circuit-types';
+import { type Fr } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
+  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_metadata');
+
+  constructor(private chainId: Fr, private blockNumber: Fr) {}
+
+  validateTxs(txs: T[]): Promise<[validTxs: T[], invalidTxs: T[]]> {
+    const validTxs: T[] = [];
+    const invalidTxs: T[] = [];
+    for (const tx of txs) {
+      if (!this.#hasCorrectChainId(tx)) {
+        invalidTxs.push(tx);
+        continue;
+      }
+
+      if (!this.#isValidForBlockNumber(tx)) {
+        invalidTxs.push(tx);
+        continue;
+      }
+
+      validTxs.push(tx);
+    }
+
+    return Promise.resolve([validTxs, invalidTxs]);
+  }
+
+  validateTx(tx: T): Promise<boolean> {
+    return Promise.resolve(this.#hasCorrectChainId(tx) && this.#isValidForBlockNumber(tx));
+  }
+
+  #hasCorrectChainId(tx: T): boolean {
+    if (!tx.data.constants.txContext.chainId.equals(this.chainId)) {
+      this.#log.warn(
+        `Rejecting tx ${Tx.getHash(
+          tx,
+        )} because of incorrect chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.chainId.toNumber()}`,
+      );
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  #isValidForBlockNumber(tx: T): boolean {
+    const target =
+      tx instanceof Tx
+        ? tx.data.forRollup?.rollupValidationRequests || tx.data.forPublic!.validationRequests.forRollup
+        : tx.data.rollupValidationRequests;
+    const maxBlockNumber = target.maxBlockNumber;
+
+    if (maxBlockNumber.isSome && maxBlockNumber.value < this.blockNumber) {
+      this.#log.warn(
+        `Rejecting tx ${Tx.getHash(tx)} for low max block number. Tx max block number: ${
+          maxBlockNumber.value
+        }, current block number: ${this.blockNumber}.`,
+      );
+      return false;
+    } else {
+      return true;
+    }
+  }
+}

package/src/tx_validator/tx_proof_validator.ts

@@ -0,0 +1,28 @@
+import { type ClientProtocolCircuitVerifier, Tx, type TxValidator } from '@aztec/circuit-types';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+export class TxProofValidator implements TxValidator<Tx> {
+  #log = createDebugLogger('aztec:sequencer:tx_validator:private_proof');
+
+  constructor(private verifier: ClientProtocolCircuitVerifier) {}
+
+  async validateTxs(txs: Tx[]): Promise<[validTxs: Tx[], invalidTxs: Tx[]]> {
+    const validTxs: Tx[] = [];
+    const invalidTxs: Tx[] = [];
+
+    for (const tx of txs) {
+      if (await this.verifier.verifyProof(tx)) {
+        validTxs.push(tx);
+      } else {
+        this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for invalid proof`);
+        invalidTxs.push(tx);
+      }
+    }
+
+    return [validTxs, invalidTxs];
+  }
+
+  validateTx(tx: Tx): Promise<boolean> {
+    return this.verifier.verifyProof(tx);
+  }
+}

package/src/util.ts

@@ -1,4 +1,12 @@
+import type { GossipSub } from '@chainsafe/libp2p-gossipsub';
 import { resolve } from 'dns/promises';
+import type { Libp2p } from 'libp2p';
+
+export interface PubSubLibp2p extends Libp2p {
+  services: {
+    pubsub: GossipSub;
+  };
+}
 
 /**
  * Converts an address string to a multiaddr string.