@aztec/p2p 0.66.0 → 0.67.1-devnet

package/src/{service → services/libp2p}/libp2p_service.ts

@@ -6,16 +6,18 @@ import {
   type Gossipable,
   type L2BlockSource,
   MerkleTreeId,
+  type PeerInfo,
   type RawGossipMessage,
-  TopicType,
   TopicTypeMap,
   Tx,
   TxHash,
   type WorldStateSynchronizer,
+  getTopicTypeForClientType,
   metricsTopicStrToLabels,
 } from '@aztec/circuit-types';
+import { P2PClientType } from '@aztec/circuit-types';
 import { Fr } from '@aztec/circuits.js';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import type { AztecKVStore } from '@aztec/kv-store';
@@ -27,26 +29,26 @@ import { createPeerScoreParams, createTopicScoreParams } from '@chainsafe/libp2p
 import { noise } from '@chainsafe/libp2p-noise';
 import { yamux } from '@chainsafe/libp2p-yamux';
 import { identify } from '@libp2p/identify';
-import type { PeerId } from '@libp2p/interface';
+import { type Message, type PeerId, TopicValidatorResult } from '@libp2p/interface';
 import '@libp2p/kad-dht';
 import { mplex } from '@libp2p/mplex';
 import { tcp } from '@libp2p/tcp';
 import { createLibp2p } from 'libp2p';
 
-import { type P2PConfig } from '../config.js';
-import { type MemPools } from '../mem_pools/interface.js';
+import { type P2PConfig } from '../../config.js';
+import { type MemPools } from '../../mem_pools/interface.js';
 import {
   DataTxValidator,
   DoubleSpendTxValidator,
   MetadataTxValidator,
   TxProofValidator,
-} from '../tx_validator/index.js';
-import { type PubSubLibp2p, convertToMultiaddr } from '../util.js';
-import { AztecDatastore } from './data_store.js';
-import { SnappyTransform, fastMsgIdFn, getMsgIdFn, msgIdToStrFn } from './encoding.js';
-import { PeerManager } from './peer_manager.js';
-import { PeerErrorSeverity } from './peer_scoring.js';
-import { pingHandler, statusHandler } from './reqresp/handlers.js';
+} from '../../tx_validator/index.js';
+import { type PubSubLibp2p, convertToMultiaddr } from '../../util.js';
+import { AztecDatastore } from '../data_store.js';
+import { SnappyTransform, fastMsgIdFn, getMsgIdFn, msgIdToStrFn } from '../encoding.js';
+import { PeerErrorSeverity } from '../peer-scoring/peer_scoring.js';
+import { PeerManager } from '../peer_manager.js';
+import { pingHandler, statusHandler } from '../reqresp/handlers.js';
 import {
   DEFAULT_SUB_PROTOCOL_HANDLERS,
   DEFAULT_SUB_PROTOCOL_VALIDATORS,
@@ -56,14 +58,29 @@ import {
   STATUS_PROTOCOL,
   type SubProtocolMap,
   TX_REQ_PROTOCOL,
-} from './reqresp/interface.js';
-import { ReqResp } from './reqresp/reqresp.js';
-import type { P2PService, PeerDiscoveryService } from './service.js';
+} from '../reqresp/interface.js';
+import { ReqResp } from '../reqresp/reqresp.js';
+import type { P2PService, PeerDiscoveryService } from '../service.js';
+
+interface MessageValidator {
+  validator: {
+    validateTx(tx: Tx): Promise<boolean>;
+  };
+  severity: PeerErrorSeverity;
+}
+
+interface ValidationResult {
+  name: string;
+  isValid: boolean;
+  severity: PeerErrorSeverity;
+}
+
+type ValidationOutcome = { allPassed: true } | { allPassed: false; failure: ValidationResult };
 
 /**
  * Lib P2P implementation of the P2PService interface.
  */
-export class LibP2PService extends WithTracer implements P2PService {
+export class LibP2PService<T extends P2PClientType> extends WithTracer implements P2PService {
   private jobQueue: SerialQueue = new SerialQueue();
   private peerManager: PeerManager;
   private discoveryRunningPromise?: RunningPromise;
@@ -79,20 +96,21 @@ export class LibP2PService extends WithTracer implements P2PService {
   private blockReceivedCallback: (block: BlockProposal) => Promise<BlockAttestation | undefined>;
 
   constructor(
+    private clientType: T,
     private config: P2PConfig,
     private node: PubSubLibp2p,
     private peerDiscoveryService: PeerDiscoveryService,
-    private mempools: MemPools,
+    private mempools: MemPools<T>,
     private l2BlockSource: L2BlockSource,
     private proofVerifier: ClientProtocolCircuitVerifier,
     private worldStateSynchronizer: WorldStateSynchronizer,
     private telemetry: TelemetryClient,
     private requestResponseHandlers: ReqRespSubProtocolHandlers = DEFAULT_SUB_PROTOCOL_HANDLERS,
-    private logger = createDebugLogger('aztec:libp2p_service'),
+    private logger = createLogger('p2p:libp2p_service'),
   ) {
     super(telemetry, 'LibP2PService');
 
-    this.peerManager = new PeerManager(node, peerDiscoveryService, config, logger);
+    this.peerManager = new PeerManager(node, peerDiscoveryService, config, this.tracer, logger);
     this.node.services.pubsub.score.params.appSpecificScore = (peerId: string) => {
       return this.peerManager.getPeerScore(peerId);
     };
@@ -117,38 +135,40 @@ export class LibP2PService extends WithTracer implements P2PService {
       throw new Error('P2P service already started');
     }
 
-    // Log listen & announce addresses
+    // Get listen & announce addresses for logging
     const { tcpListenAddress, tcpAnnounceAddress } = this.config;
-    this.logger.info(`Starting P2P node on ${tcpListenAddress}`);
     if (!tcpAnnounceAddress) {
       throw new Error('Announce address not provided.');
     }
     const announceTcpMultiaddr = convertToMultiaddr(tcpAnnounceAddress, 'tcp');
-    this.logger.info(`Announcing at ${announceTcpMultiaddr}`);
 
     // Start job queue, peer discovery service and libp2p node
     this.jobQueue.start();
     await this.peerDiscoveryService.start();
     await this.node.start();
-    this.logger.info(`Started P2P client with Peer ID ${this.node.peerId.toString()}`);
 
     // Subscribe to standard GossipSub topics by default
-    for (const topic in TopicType) {
+    for (const topic of getTopicTypeForClientType(this.clientType)) {
       this.subscribeToTopic(TopicTypeMap[topic].p2pTopic);
     }
 
+    // Add p2p topic validators
+    this.node.services.pubsub.topicValidators.set(Tx.p2pTopic, this.validatePropagatedTxFromMessage.bind(this));
+
     // add GossipSub listener
     this.node.services.pubsub.addEventListener('gossipsub:message', async e => {
-      const { msg, propagationSource: peerId } = e.detail;
+      const { msg } = e.detail;
       this.logger.trace(`Received PUBSUB message.`);
 
-      await this.jobQueue.put(() => this.handleNewGossipMessage(msg, peerId));
+      await this.jobQueue.put(() => this.handleNewGossipMessage(msg));
     });
 
     // Start running promise for peer discovery
-    this.discoveryRunningPromise = new RunningPromise(() => {
-      this.peerManager.heartbeat();
-    }, this.config.peerCheckIntervalMS);
+    this.discoveryRunningPromise = new RunningPromise(
+      () => this.peerManager.heartbeat(),
+      this.logger,
+      this.config.peerCheckIntervalMS,
+    );
     this.discoveryRunningPromise.start();
 
     // Define the sub protocol validators - This is done within this start() method to gain a callback to the existing validateTx function
@@ -157,6 +177,11 @@ export class LibP2PService extends WithTracer implements P2PService {
       [TX_REQ_PROTOCOL]: this.validateRequestedTx.bind(this),
     };
     await this.reqresp.start(this.requestResponseHandlers, reqrespSubProtocolValidators);
+    this.logger.info(`Started P2P service`, {
+      listen: tcpListenAddress,
+      announce: announceTcpMultiaddr,
+      peerId: this.node.peerId.toString(),
+    });
   }
 
   /**
@@ -175,7 +200,6 @@ export class LibP2PService extends WithTracer implements P2PService {
     this.logger.debug('Stopping LibP2P...');
     await this.stopLibP2P();
     this.logger.info('LibP2P service stopped');
-    this.logger.debug('Stopping request response service...');
   }
 
   /**
@@ -184,11 +208,12 @@ export class LibP2PService extends WithTracer implements P2PService {
    * @param txPool - The transaction pool to be accessed by the service.
    * @returns The new service.
    */
-  public static async new(
+  public static async new<T extends P2PClientType>(
+    clientType: T,
     config: P2PConfig,
     peerDiscoveryService: PeerDiscoveryService,
     peerId: PeerId,
-    mempools: MemPools,
+    mempools: MemPools<T>,
     l2BlockSource: L2BlockSource,
     proofVerifier: ClientProtocolCircuitVerifier,
     worldStateSynchronizer: WorldStateSynchronizer,
@@ -249,6 +274,7 @@ export class LibP2PService extends WithTracer implements P2PService {
           dataTransform: new SnappyTransform(),
           metricsRegister: otelMetricsAdapter,
           metricsTopicStrToLabel: metricsTopicStrToLabels(),
+          asyncValidation: true,
           scoreParams: createPeerScoreParams({
             topics: {
               [Tx.p2pTopic]: createTopicScoreParams({
@@ -297,6 +323,7 @@ export class LibP2PService extends WithTracer implements P2PService {
     };
 
     return new LibP2PService(
+      clientType,
       config,
       node,
       peerDiscoveryService,
@@ -309,6 +336,10 @@ export class LibP2PService extends WithTracer implements P2PService {
     );
   }
 
+  public getPeers(includePending?: boolean): PeerInfo[] {
+    return this.peerManager.getPeers(includePending);
+  }
+
   /**
    * Send Request via the ReqResp service
    * The subprotocol defined will determine the request and response types
@@ -370,12 +401,12 @@ export class LibP2PService extends WithTracer implements P2PService {
    * @param topic - The message's topic.
    * @param data - The message data
    */
-  private async handleNewGossipMessage(message: RawGossipMessage, peerId: PeerId) {
+  private async handleNewGossipMessage(message: RawGossipMessage) {
     if (message.topic === Tx.p2pTopic) {
       const tx = Tx.fromBuffer(Buffer.from(message.data));
-      await this.processTxFromPeer(tx, peerId);
+      await this.processTxFromPeer(tx);
     }
-    if (message.topic === BlockAttestation.p2pTopic) {
+    if (message.topic === BlockAttestation.p2pTopic && this.clientType === P2PClientType.Full) {
       const attestation = BlockAttestation.fromBuffer(Buffer.from(message.data));
       await this.processAttestationFromPeer(attestation);
     }
@@ -404,7 +435,7 @@ export class LibP2PService extends WithTracer implements P2PService {
   }))
   private async processAttestationFromPeer(attestation: BlockAttestation): Promise<void> {
     this.logger.debug(`Received attestation ${attestation.p2pMessageIdentifier()} from external peer.`);
-    await this.mempools.attestationPool.addAttestations([attestation]);
+    await this.mempools.attestationPool!.addAttestations([attestation]);
   }
 
   /**Process block from peer
@@ -462,16 +493,11 @@ export class LibP2PService extends WithTracer implements P2PService {
     });
   }
 
-  private async processTxFromPeer(tx: Tx, peerId: PeerId): Promise<void> {
+  private async processTxFromPeer(tx: Tx): Promise<void> {
     const txHash = tx.getTxHash();
     const txHashString = txHash.toString();
     this.logger.verbose(`Received tx ${txHashString} from external peer.`);
-
-    const isValidTx = await this.validatePropagatedTx(tx, peerId);
-
-    if (isValidTx) {
-      await this.mempools.txPool.addTxs([tx]);
-    }
+    await this.mempools.txPool.addTxs([tx]);
   }
 
   /**
@@ -488,6 +514,9 @@ export class LibP2PService extends WithTracer implements P2PService {
    * @param peerId - The peer ID of the peer that sent the tx.
    * @returns True if the tx is valid, false otherwise.
    */
+  @trackSpan('Libp2pService.validateRequestedTx', (requestedTxHash, _responseTx) => ({
+    [Attributes.TX_HASH]: requestedTxHash.toString(),
+  }))
   private async validateRequestedTx(requestedTxHash: TxHash, responseTx: Tx, peerId: PeerId): Promise<boolean> {
     const proofValidator = new TxProofValidator(this.proofVerifier);
     const validProof = await proofValidator.validateTx(responseTx);
@@ -508,67 +537,150 @@ export class LibP2PService extends WithTracer implements P2PService {
     return true;
   }
 
+  private async validatePropagatedTxFromMessage(
+    propagationSource: PeerId,
+    msg: Message,
+  ): Promise<TopicValidatorResult> {
+    const tx = Tx.fromBuffer(Buffer.from(msg.data));
+    const isValid = await this.validatePropagatedTx(tx, propagationSource);
+    this.logger.trace(`validatePropagatedTx: ${isValid}`, {
+      [Attributes.TX_HASH]: tx.getTxHash().toString(),
+      [Attributes.P2P_ID]: propagationSource.toString(),
+    });
+    return isValid ? TopicValidatorResult.Accept : TopicValidatorResult.Reject;
+  }
+
+  /**
+   * Validate a tx that has been propagated from a peer.
+   * @param tx - The tx to validate.
+   * @param peerId - The peer ID of the peer that sent the tx.
+   * @returns True if the tx is valid, false otherwise.
+   */
+  @trackSpan('Libp2pService.validatePropagatedTx', tx => ({
+    [Attributes.TX_HASH]: tx.getTxHash().toString(),
+  }))
   private async validatePropagatedTx(tx: Tx, peerId: PeerId): Promise<boolean> {
     const blockNumber = (await this.l2BlockSource.getBlockNumber()) + 1;
-    // basic data validation
-    const dataValidator = new DataTxValidator();
-    const validData = await dataValidator.validateTx(tx);
-    if (!validData) {
-      // penalize
-      this.node.services.pubsub.score.markInvalidMessageDelivery(peerId.toString(), Tx.p2pTopic);
-      return false;
+    const messageValidators = this.createMessageValidators(blockNumber);
+    const outcome = await this.runValidations(tx, messageValidators);
+
+    if (outcome.allPassed) {
+      return true;
     }
 
-    // metadata validation
-    const metadataValidator = new MetadataTxValidator(new Fr(this.config.l1ChainId), new Fr(blockNumber));
-    const validMetadata = await metadataValidator.validateTx(tx);
-    if (!validMetadata) {
-      // penalize
-      this.node.services.pubsub.score.markInvalidMessageDelivery(peerId.toString(), Tx.p2pTopic);
-      return false;
+    const { name, severity } = outcome.failure;
+
+    // Double spend validator has a special case handler
+    if (name === 'doubleSpendValidator') {
+      const isValid = await this.handleDoubleSpendFailure(tx, blockNumber, peerId);
+      if (isValid) {
+        return true;
+      }
     }
 
-    // double spend validation
-    const doubleSpendValidator = new DoubleSpendTxValidator({
-      getNullifierIndex: async (nullifier: Fr) => {
-        const merkleTree = this.worldStateSynchronizer.getCommitted();
-        const index = await merkleTree.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
-        return index;
+    this.peerManager.penalizePeer(peerId, severity);
+    return false;
+  }
+
+  /**
+   * Create message validators for the given block number.
+   *
+   * Each validator is a pair of a validator and a severity.
+   * If a validator fails, the peer is penalized with the severity of the validator.
+   *
+   * @param blockNumber - The block number to create validators for.
+   * @returns The message validators.
+   */
+  private createMessageValidators(blockNumber: number): Record<string, MessageValidator> {
+    return {
+      dataValidator: {
+        validator: new DataTxValidator(),
+        severity: PeerErrorSeverity.HighToleranceError,
       },
-    });
-    const validDoubleSpend = await doubleSpendValidator.validateTx(tx);
-    if (!validDoubleSpend) {
-      // check if nullifier is older than 20 blocks
-      if (blockNumber - this.config.severePeerPenaltyBlockLength > 0) {
-        const snapshotValidator = new DoubleSpendTxValidator({
-          getNullifierIndex: async (nullifier: Fr) => {
-            const merkleTree = this.worldStateSynchronizer.getSnapshot(
-              blockNumber - this.config.severePeerPenaltyBlockLength,
-            );
-            const index = await merkleTree.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
-            return index;
+      metadataValidator: {
+        validator: new MetadataTxValidator(new Fr(this.config.l1ChainId), new Fr(blockNumber)),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      proofValidator: {
+        validator: new TxProofValidator(this.proofVerifier),
+        severity: PeerErrorSeverity.MidToleranceError,
+      },
+      doubleSpendValidator: {
+        validator: new DoubleSpendTxValidator({
+          getNullifierIndices: (nullifiers: Buffer[]) => {
+            const merkleTree = this.worldStateSynchronizer.getCommitted();
+            return merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
           },
-        });
-
-        const validSnapshot = await snapshotValidator.validateTx(tx);
-        // High penalty if nullifier is older than 20 blocks
-        if (!validSnapshot) {
-          // penalize
-          this.peerManager.penalizePeer(peerId, PeerErrorSeverity.LowToleranceError);
-          return false;
-        }
-      }
-      // penalize
-      this.peerManager.penalizePeer(peerId, PeerErrorSeverity.HighToleranceError);
+        }),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+    };
+  }
+
+  /**
+   * Run validations on a tx.
+   * @param tx - The tx to validate.
+   * @param messageValidators - The message validators to run.
+   * @returns The validation outcome.
+   */
+  private async runValidations(
+    tx: Tx,
+    messageValidators: Record<string, MessageValidator>,
+  ): Promise<ValidationOutcome> {
+    const validationPromises = Object.entries(messageValidators).map(async ([name, { validator, severity }]) => {
+      const isValid = await validator.validateTx(tx);
+      return { name, isValid, severity };
+    });
+
+    // A promise that resolves when all validations have been run
+    const allValidations = Promise.all(validationPromises);
+
+    // A promise that resolves when the first validation fails
+    const firstFailure = Promise.race(
+      validationPromises.map(async promise => {
+        const result = await promise;
+        return result.isValid ? new Promise(() => {}) : result;
+      }),
+    );
+
+    // Wait for the first validation to fail or all validations to pass
+    const result = await Promise.race([
+      allValidations.then(() => ({ allPassed: true as const })),
+      firstFailure.then(failure => ({ allPassed: false as const, failure: failure as ValidationResult })),
+    ]);
+
+    // If all validations pass, allPassed will be true, if failed, then the failure will be the first validation to fail
+    return result;
+  }
+
+  /**
+   * Handle a double spend failure.
+   *
+   * Double spend failures are managed on their own because they are a special case.
+   * We must check if the double spend is recent or old, if it is past a threshold, then we heavily penalize the peer.
+   *
+   * @param tx - The tx that failed the double spend validator.
+   * @param blockNumber - The block number of the tx.
+   * @param peerId - The peer ID of the peer that sent the tx.
+   * @returns True if the tx is valid, false otherwise.
+   */
+  private async handleDoubleSpendFailure(tx: Tx, blockNumber: number, peerId: PeerId): Promise<boolean> {
+    if (blockNumber <= this.config.severePeerPenaltyBlockLength) {
       return false;
     }
 
-    // proof validation
-    const proofValidator = new TxProofValidator(this.proofVerifier);
-    const validProof = await proofValidator.validateTx(tx);
-    if (!validProof) {
-      // penalize
-      this.peerManager.penalizePeer(peerId, PeerErrorSeverity.MidToleranceError);
+    const snapshotValidator = new DoubleSpendTxValidator({
+      getNullifierIndices: (nullifiers: Buffer[]) => {
+        const merkleTree = this.worldStateSynchronizer.getSnapshot(
+          blockNumber - this.config.severePeerPenaltyBlockLength,
+        );
+        return merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
+      },
+    });
+
+    const validSnapshot = await snapshotValidator.validateTx(tx);
+    if (!validSnapshot) {
+      this.peerManager.penalizePeer(peerId, PeerErrorSeverity.LowToleranceError);
       return false;
     }
 
@@ -583,10 +695,10 @@ export class LibP2PService extends WithTracer implements P2PService {
     const parent = message.constructor as typeof Gossipable;
 
     const identifier = message.p2pMessageIdentifier().toString();
-    this.logger.verbose(`[${identifier}] sending`);
+    this.logger.trace(`Sending message ${identifier}`);
 
     const recipientsNum = await this.publishToTopic(parent.p2pTopic, message.toBuffer());
-    this.logger.verbose(`[${identifier}] sent to ${recipientsNum} peers`);
+    this.logger.debug(`Sent message ${identifier} to ${recipientsNum} peers`);
   }
 
   // Libp2p seems to hang sometimes if new peers are initiating connections.
@@ -597,7 +709,7 @@ export class LibP2PService extends WithTracer implements P2PService {
     });
     try {
       await Promise.race([this.node.stop(), timeout]);
-      this.logger.debug('Libp2p stopped');
+      this.logger.debug('LibP2P stopped');
     } catch (error) {
       this.logger.error('Error during stop or timeout:', error);
     }

package/src/{service → services/peer-scoring}/peer_scoring.ts

@@ -1,4 +1,6 @@
-import { type P2PConfig } from '../config.js';
+import { median } from '@aztec/foundation/collection';
+
+import { type P2PConfig } from '../../config.js';
 
 export enum PeerErrorSeverity {
   /**
@@ -43,7 +45,7 @@ export class PeerScoring {
     };
   }
 
-  updateScore(peerId: string, scoreDelta: number): void {
+  updateScore(peerId: string, scoreDelta: number): number {
     const currentTime = Date.now();
     const lastUpdate = this.lastUpdateTime.get(peerId) || currentTime;
     const timePassed = currentTime - lastUpdate;
@@ -59,6 +61,7 @@ export class PeerScoring {
 
     this.scores.set(peerId, currentScore);
     this.lastUpdateTime.set(peerId, currentTime);
+    return currentScore;
   }
 
   decayAllScores(): void {
@@ -78,4 +81,8 @@ export class PeerScoring {
   getScore(peerId: string): number {
     return this.scores.get(peerId) || 0;
   }
+
+  getStats(): { medianScore: number } {
+    return { medianScore: median(Array.from(this.scores.values())) ?? 0 };
+  }
 }