@aztec/p2p 0.0.1-commit.6d3c34e → 0.0.1-commit.6d63667d

package/src/services/libp2p/libp2p_service.ts

@@ -6,7 +6,6 @@ import { type Logger, createLibp2pComponentLogger, createLogger } from '@aztec/f
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { Timer } from '@aztec/foundation/timer';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
 import type { EthAddress, L2Block, L2BlockSource } from '@aztec/stdlib/block';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
@@ -20,6 +19,7 @@ import {
   type Gossipable,
   P2PClientType,
   P2PMessage,
+  type ValidationResult as P2PValidationResult,
   PeerErrorSeverity,
   TopicType,
   createTopicString,
@@ -60,23 +60,21 @@ import { createLibp2p } from 'libp2p';
 
 import type { P2PConfig } from '../../config.js';
 import { ProposalSlotCapExceededError } from '../../errors/attestation-pool.error.js';
-import type { MemPools } from '../../mem_pools/interface.js';
+import type { MemPools } from '../../mem_pools/index.js';
 import {
   BlockProposalValidator,
   CheckpointAttestationValidator,
   CheckpointProposalValidator,
+  DoubleSpendTxValidator,
   FishermanAttestationValidator,
+  getDefaultAllowedSetupFunctions,
 } from '../../msg_validators/index.js';
 import { MessageSeenValidator } from '../../msg_validators/msg_seen_validator/msg_seen_validator.js';
-import { getDefaultAllowedSetupFunctions } from '../../msg_validators/tx_validator/allowed_public_setup.js';
-import { type MessageValidator, createTxMessageValidators } from '../../msg_validators/tx_validator/factory.js';
 import {
-  AggregateTxValidator,
-  DataTxValidator,
-  DoubleSpendTxValidator,
-  MetadataTxValidator,
-  TxProofValidator,
-} from '../../msg_validators/tx_validator/index.js';
+  type MessageValidator,
+  createTxMessageValidators,
+  createTxReqRespValidator,
+} from '../../msg_validators/tx_validator/factory.js';
 import { GossipSubEvent } from '../../types/index.js';
 import { type PubSubLibp2p, convertToMultiaddr } from '../../util.js';
 import { getVersions } from '../../versioning.js';
@@ -87,29 +85,31 @@ import { gossipScoreThresholds } from '../gossipsub/scoring.js';
 import type { PeerManagerInterface } from '../peer-manager/interface.js';
 import { PeerManager } from '../peer-manager/peer_manager.js';
 import { PeerScoring } from '../peer-manager/peer_scoring.js';
+import type { BatchTxRequesterLibP2PService } from '../reqresp/batch-tx-requester/interface.js';
 import type { P2PReqRespConfig } from '../reqresp/config.js';
 import {
   DEFAULT_SUB_PROTOCOL_VALIDATORS,
   type ReqRespInterface,
+  type ReqRespResponse,
   ReqRespSubProtocol,
   type ReqRespSubProtocolHandler,
   type ReqRespSubProtocolHandlers,
   type ReqRespSubProtocolValidators,
   type SubProtocolMap,
   ValidationError,
-} from '../reqresp/interface.js';
-import { reqRespBlockTxsHandler } from '../reqresp/protocols/block_txs/block_txs_handler.js';
-import { reqGoodbyeHandler } from '../reqresp/protocols/goodbye.js';
+} from '../reqresp/index.js';
 import {
   AuthRequest,
   BlockTxsRequest,
   BlockTxsResponse,
   StatusMessage,
   pingHandler,
+  reqGoodbyeHandler,
   reqRespBlockHandler,
+  reqRespBlockTxsHandler,
   reqRespStatusHandler,
   reqRespTxHandler,
-} from '../reqresp/protocols/index.js';
+} from '../reqresp/index.js';
 import { ReqResp } from '../reqresp/reqresp.js';
 import type {
   P2PBlockReceivedCallback,
@@ -284,14 +284,14 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
 
     const datastore = new AztecDatastore(peerStore);
 
-    const otelMetricsAdapter = new OtelMetricsAdapter(telemetry);
+    const otelMetricsAdapter = new OtelMetricsAdapter(telemetry, logger.getBindings());
 
     const peerDiscoveryService = new DiscV5Service(
       peerId,
       config,
       packageVersion,
       telemetry,
-      createLogger(`${logger.module}:discv5_service`),
+      createLogger(`${logger.module}:discv5_service`, logger.getBindings()),
     );
 
     // Seed libp2p's bootstrap discovery with private and trusted peers
@@ -452,7 +452,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
           connectionManager: components.connectionManager,
         }),
       },
-      logger: createLibp2pComponentLogger(logger.module),
+      logger: createLibp2pComponentLogger(logger.module, logger.getBindings()),
     });
 
     const peerScoring = new PeerScoring(config, telemetry);
@@ -524,7 +524,11 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     };
 
     if (!this.config.disableTransactions) {
-      const blockTxsHandler = reqRespBlockTxsHandler(this.mempools.attestationPool, this.mempools.txPool);
+      const blockTxsHandler = reqRespBlockTxsHandler(
+        this.mempools.attestationPool,
+        this.archiver,
+        this.mempools.txPool,
+      );
       requestResponseHandlers[ReqRespSubProtocol.BLOCK_TXS] = blockTxsHandler.bind(this);
     }
 
@@ -640,6 +644,15 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     return this.reqresp.sendBatchRequest(protocol, requests, pinnedPeerId);
   }
 
+  public sendRequestToPeer(
+    peerId: PeerId,
+    subProtocol: ReqRespSubProtocol,
+    payload: Buffer,
+    dialTimeout?: number,
+  ): Promise<ReqRespResponse> {
+    return this.reqresp.sendRequestToPeer(peerId, subProtocol, payload, dialTimeout);
+  }
+
   /**
    * Get the ENR of the node
    * @returns The ENR of the node
@@ -923,7 +936,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     const validationFunc: () => Promise<ReceivedMessageValidationResult<CheckpointAttestation>> = async () => {
       const attestation = CheckpointAttestation.fromBuffer(payloadData);
       const pool = this.mempools.attestationPool;
-      const isValid = await this.validateCheckpointAttestation(source, attestation);
+      const validationResult = await this.validateCheckpointAttestation(source, attestation);
+      const isValid = validationResult.result === 'accept';
       const exists = isValid && (await pool.hasCheckpointAttestation(attestation));
 
       let canAdd = true;
@@ -942,9 +956,9 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
         [Attributes.P2P_ID]: source.toString(),
       });
 
-      if (!isValid) {
+      if (validationResult.result === 'reject') {
         return { result: TopicValidatorResult.Reject };
-      } else if (exists) {
+      } else if (validationResult.result === 'ignore' || exists) {
         return { result: TopicValidatorResult.Ignore, obj: attestation };
       } else if (!canAdd) {
         this.logger.warn(`Dropping checkpoint attestation due to per-(slot, proposalId) attestation cap`, {
@@ -985,7 +999,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   private async processBlockFromPeer(payloadData: Buffer, msgId: string, source: PeerId): Promise<void> {
     const validationFunc: () => Promise<ReceivedMessageValidationResult<BlockProposal>> = async () => {
       const block = BlockProposal.fromBuffer(payloadData);
-      const isValid = await this.validateBlockProposal(source, block);
+      const validationResult = await this.validateBlockProposal(source, block);
+      const isValid = validationResult.result === 'accept';
       const pool = this.mempools.attestationPool;
 
       const exists = isValid && (await pool.hasBlockProposal(block));
@@ -999,9 +1014,9 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
         [Attributes.P2P_ID]: source.toString(),
       });
 
-      if (!isValid) {
+      if (validationResult.result === 'reject') {
         return { result: TopicValidatorResult.Reject };
-      } else if (exists) {
+      } else if (validationResult.result === 'ignore' || exists) {
         return { result: TopicValidatorResult.Ignore, obj: block };
       } else if (!canAdd) {
         this.peerManager.penalizePeer(source, PeerErrorSeverity.MidToleranceError);
@@ -1081,7 +1096,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     // TODO(palla/mbps): This pattern is repeated across multiple message handlers, consider abstracting it.
     const validationFunc: () => Promise<ReceivedMessageValidationResult<CheckpointProposal>> = async () => {
       const checkpoint = CheckpointProposal.fromBuffer(payloadData);
-      const isValid = await this.validateCheckpointProposal(source, checkpoint);
+      const validationResult = await this.validateCheckpointProposal(source, checkpoint);
+      const isValid = validationResult.result === 'accept';
       const pool = this.mempools.attestationPool;
 
       const exists = isValid && (await pool.hasCheckpointProposal(checkpoint));
@@ -1095,9 +1111,9 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
         [Attributes.P2P_ID]: source.toString(),
       });
 
-      if (!isValid) {
+      if (validationResult.result === 'reject') {
         return { result: TopicValidatorResult.Reject };
-      } else if (exists) {
+      } else if (validationResult.result === 'ignore' || exists) {
         return { result: TopicValidatorResult.Ignore, obj: checkpoint };
       } else if (!canAdd) {
         this.peerManager.penalizePeer(source, PeerErrorSeverity.MidToleranceError);
@@ -1202,7 +1218,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
    * @returns True if the requested block transactions are valid, false otherwise.
    */
   @trackSpan('Libp2pService.validateRequestedBlockTxs', request => ({
-    [Attributes.BLOCK_HASH]: request.blockHash.toString(),
+    [Attributes.BLOCK_ARCHIVE]: request.archiveRoot.toString(),
   }))
   private async validateRequestedBlockTxs(
     request: BlockTxsRequest,
@@ -1212,10 +1228,10 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     const requestedTxValidator = this.createRequestedTxValidator();
 
     try {
-      if (!response.blockHash.equals(request.blockHash)) {
+      if (!response.archiveRoot.equals(request.archiveRoot)) {
         this.peerManager.penalizePeer(peerId, PeerErrorSeverity.MidToleranceError);
         throw new ValidationError(
-          `Received block txs for unexpected block: expected ${request.blockHash.toString()}, got ${response.blockHash.toString()}`,
+          `Received block txs for unexpected archive root: expected ${request.archiveRoot.toString()}, got ${response.archiveRoot.toString()}`,
         );
       }
 
@@ -1245,7 +1261,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       }
 
       // Given proposal (should have locally), ensure returned txs are valid subset and match request indices
-      const proposal = await this.mempools.attestationPool.getBlockProposal(request.blockHash.toString());
+      const proposal = await this.mempools.attestationPool.getBlockProposal(request.archiveRoot.toString());
       if (proposal) {
         // Build intersected indices
         const intersectIdx = request.txIndices.getTrueIndices().filter(i => response.txIndices.isSet(i));
@@ -1265,7 +1281,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       } else {
         // No local proposal, cannot check the membership/order of the returned txs
         this.logger.warn(
-          `Block proposal not found for block hash ${request.blockHash.toString()}; cannot validate membership/order of returned txs`,
+          `Block proposal not found for archive root ${request.archiveRoot.toString()}; cannot validate membership/order of returned txs`,
         );
         return false;
       }
@@ -1304,7 +1320,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     const requested = new Set(requestedTxHash.map(h => h.toString()));
     const requestedTxValidator = this.createRequestedTxValidator();
 
-    //TODO: (mralj) - this is somewhat naive implementation, if single tx is invlid we consider the whole response invalid.
+    //TODO: (mralj) - this is somewhat naive implementation, if single tx is invalid we consider the whole response invalid.
     // I think we should still extract the valid txs and return them, so that we can still use the response.
     try {
       await Promise.all(responseTx.map(tx => this.validateRequestedTx(tx, peerId, requestedTxValidator, requested)));
@@ -1367,27 +1383,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     }
   }
 
-  private createRequestedTxValidator(): TxValidator {
-    return new AggregateTxValidator(
-      new DataTxValidator(),
-      new MetadataTxValidator({
-        l1ChainId: new Fr(this.config.l1ChainId),
-        rollupVersion: new Fr(this.config.rollupVersion),
-        protocolContractsHash,
-        vkTreeRoot: getVKTreeRoot(),
-      }),
-      new TxProofValidator(this.proofVerifier),
-    );
-  }
-
   private async validateRequestedTx(tx: Tx, peerId: PeerId, txValidator: TxValidator, requested?: Set<`0x${string}`>) {
     const penalize = (severity: PeerErrorSeverity) => this.peerManager.penalizePeer(peerId, severity);
-
-    if (!(await tx.validateTxHash())) {
-      penalize(PeerErrorSeverity.MidToleranceError);
-      throw new ValidationError(`Received tx with invalid hash ${tx.getTxHash().toString()}.`);
-    }
-
     if (requested && !requested.has(tx.getTxHash().toString())) {
       penalize(PeerErrorSeverity.MidToleranceError);
       throw new ValidationError(`Received tx with hash ${tx.getTxHash().toString()} that was not requested.`);
@@ -1400,6 +1397,13 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     }
   }
 
+  private createRequestedTxValidator(): TxValidator {
+    return createTxReqRespValidator(this.proofVerifier, {
+      l1ChainId: this.config.l1ChainId,
+      rollupVersion: this.config.rollupVersion,
+    });
+  }
+
   @trackSpan('Libp2pService.validatePropagatedTx', tx => ({
     [Attributes.TX_HASH]: tx.getTxHash().toString(),
   }))
@@ -1442,6 +1446,22 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     return gasFees;
   }
 
+  /**
+   * Get the BatchTxRequesterLibP2PService dependencies for creating BatchTxRequester instances
+   */
+  public getBatchTxRequesterService(): BatchTxRequesterLibP2PService {
+    return {
+      reqResp: this.reqresp,
+      connectionSampler: this.reqresp.getConnectionSampler(),
+      txValidatorConfig: {
+        l1ChainId: this.config.l1ChainId,
+        rollupVersion: this.config.rollupVersion,
+        proofVerifier: this.proofVerifier,
+      },
+      peerScoring: this.peerManager,
+    };
+  }
+
   public async validate(txs: Tx[]): Promise<void> {
     const currentBlockNumber = await this.archiver.getBlockNumber();
 
@@ -1492,6 +1512,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       this.proofVerifier,
       !this.config.disableTransactions,
       allowedInSetup,
+      this.logger.getBindings(),
     );
   }
 
@@ -1545,15 +1566,18 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       return PeerErrorSeverity.HighToleranceError;
     }
 
-    const snapshotValidator = new DoubleSpendTxValidator({
-      nullifiersExist: async (nullifiers: Buffer[]) => {
-        const merkleTree = this.worldStateSynchronizer.getSnapshot(
-          BlockNumber(blockNumber - this.config.doubleSpendSeverePeerPenaltyWindow),
-        );
-        const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
-        return indices.map(index => index !== undefined);
+    const snapshotValidator = new DoubleSpendTxValidator(
+      {
+        nullifiersExist: async (nullifiers: Buffer[]) => {
+          const merkleTree = this.worldStateSynchronizer.getSnapshot(
+            BlockNumber(blockNumber - this.config.doubleSpendSeverePeerPenaltyWindow),
+          );
+          const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
+          return indices.map(index => index !== undefined);
+        },
       },
-    });
+      this.logger.getBindings(),
+    );
 
     const validSnapshot = await snapshotValidator.validateTx(tx);
     if (validSnapshot.result !== 'valid') {
@@ -1574,15 +1598,18 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     [Attributes.BLOCK_ARCHIVE]: attestation.archive.toString(),
     [Attributes.P2P_ID]: await attestation.p2pMessageLoggingIdentifier().then(i => i.toString()),
   }))
-  public async validateCheckpointAttestation(peerId: PeerId, attestation: CheckpointAttestation): Promise<boolean> {
-    const severity = await this.checkpointAttestationValidator.validate(attestation);
-    if (severity) {
+  public async validateCheckpointAttestation(
+    peerId: PeerId,
+    attestation: CheckpointAttestation,
+  ): Promise<P2PValidationResult> {
+    const result = await this.checkpointAttestationValidator.validate(attestation);
+
+    if (result.result === 'reject') {
       this.logger.debug(`Penalizing peer ${peerId} for checkpoint attestation validation failure`);
-      this.peerManager.penalizePeer(peerId, severity);
-      return false;
+      this.peerManager.penalizePeer(peerId, result.severity);
     }
 
-    return true;
+    return result;
   }
 
   /**
@@ -1594,15 +1621,15 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   @trackSpan('Libp2pService.validateBlockProposal', (_peerId, block) => ({
     [Attributes.SLOT_NUMBER]: block.slotNumber.toString(),
   }))
-  public async validateBlockProposal(peerId: PeerId, block: BlockProposal): Promise<boolean> {
-    const severity = await this.blockProposalValidator.validate(block);
-    if (severity) {
+  public async validateBlockProposal(peerId: PeerId, block: BlockProposal): Promise<P2PValidationResult> {
+    const result = await this.blockProposalValidator.validate(block);
+
+    if (result.result === 'reject') {
       this.logger.debug(`Penalizing peer ${peerId} for block proposal validation failure`);
-      this.peerManager.penalizePeer(peerId, severity);
-      return false;
+      this.peerManager.penalizePeer(peerId, result.severity);
     }
 
-    return true;
+    return result;
   }
 
   /**
@@ -1614,15 +1641,18 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   @trackSpan('Libp2pService.validateCheckpointProposal', (_peerId, checkpoint) => ({
     [Attributes.SLOT_NUMBER]: checkpoint.slotNumber.toString(),
   }))
-  public async validateCheckpointProposal(peerId: PeerId, checkpoint: CheckpointProposal): Promise<boolean> {
-    const severity = await this.checkpointProposalValidator.validate(checkpoint);
-    if (severity) {
+  public async validateCheckpointProposal(
+    peerId: PeerId,
+    checkpoint: CheckpointProposal,
+  ): Promise<P2PValidationResult> {
+    const result = await this.checkpointProposalValidator.validate(checkpoint);
+
+    if (result.result === 'reject') {
       this.logger.debug(`Penalizing peer ${peerId} for checkpoint proposal validation failure`);
-      this.peerManager.penalizePeer(peerId, severity);
-      return false;
+      this.peerManager.penalizePeer(peerId, result.severity);
     }
 
-    return true;
+    return result;
   }
 
   public getPeerScore(peerId: PeerId): number {

package/src/services/peer-manager/metrics.ts

@@ -6,12 +6,13 @@ import {
   type TelemetryClient,
   type Tracer,
   type UpDownCounter,
+  createUpDownCounterWithDefault,
   getTelemetryClient,
 } from '@aztec/telemetry-client';
 
 import type { PeerId } from '@libp2p/interface';
 
-import { type GoodByeReason, prettyGoodbyeReason } from '../reqresp/protocols/index.js';
+import { GoodByeReason, prettyGoodbyeReason } from '../reqresp/protocols/index.js';
 
 export class PeerManagerMetrics {
   private sentGoodbyes: UpDownCounter;
@@ -31,10 +32,26 @@ export class PeerManagerMetrics {
     this.tracer = telemetryClient.getTracer(name);
 
     const meter = telemetryClient.getMeter(name);
-    this.sentGoodbyes = meter.createUpDownCounter(Metrics.PEER_MANAGER_GOODBYES_SENT);
-    this.receivedGoodbyes = meter.createUpDownCounter(Metrics.PEER_MANAGER_GOODBYES_RECEIVED);
+    const goodbyeReasonAttrs = {
+      [Attributes.P2P_GOODBYE_REASON]: [
+        prettyGoodbyeReason(GoodByeReason.SHUTDOWN),
+        prettyGoodbyeReason(GoodByeReason.MAX_PEERS),
+        prettyGoodbyeReason(GoodByeReason.LOW_SCORE),
+        prettyGoodbyeReason(GoodByeReason.BANNED),
+        prettyGoodbyeReason(GoodByeReason.WRONG_NETWORK),
+        prettyGoodbyeReason(GoodByeReason.UNKNOWN),
+      ],
+    };
+    this.sentGoodbyes = createUpDownCounterWithDefault(meter, Metrics.PEER_MANAGER_GOODBYES_SENT, goodbyeReasonAttrs);
+    this.receivedGoodbyes = createUpDownCounterWithDefault(
+      meter,
+      Metrics.PEER_MANAGER_GOODBYES_RECEIVED,
+      goodbyeReasonAttrs,
+    );
     this.peerCount = meter.createGauge(Metrics.PEER_MANAGER_PEER_COUNT);
-    this.lowScoreDisconnects = meter.createUpDownCounter(Metrics.PEER_MANAGER_LOW_SCORE_DISCONNECTS);
+    this.lowScoreDisconnects = createUpDownCounterWithDefault(meter, Metrics.PEER_MANAGER_LOW_SCORE_DISCONNECTS, {
+      [Attributes.P2P_PEER_SCORE_STATE]: ['Banned', 'Disconnect'],
+    });
     this.peerConnectionDuration = meter.createHistogram(Metrics.PEER_MANAGER_PEER_CONNECTION_DURATION);
   }
 

package/src/services/peer-manager/peer_scoring.ts

@@ -6,6 +6,7 @@ import {
   Metrics,
   type TelemetryClient,
   type UpDownCounter,
+  createUpDownCounterWithDefault,
   getTelemetryClient,
 } from '@aztec/telemetry-client';
 
@@ -52,7 +53,9 @@ export class PeerScoring {
 
     const meter = telemetry.getMeter('PeerScoring');
 
-    this.peerStateCounter = meter.createUpDownCounter(Metrics.P2P_PEER_STATE_COUNT);
+    this.peerStateCounter = createUpDownCounterWithDefault(meter, Metrics.P2P_PEER_STATE_COUNT, {
+      [Attributes.P2P_PEER_SCORE_STATE]: ['Healthy', 'Disconnect', 'Banned'],
+    });
   }
 
   public penalizePeer(peerId: PeerId, penalty: PeerErrorSeverity) {