@aztec/p2p 0.0.1-commit.e61ad554 → 0.0.1-commit.ee80a48

package/src/msg_validators/proposal_validator/proposal_validator.ts

@@ -24,24 +24,24 @@ export abstract class ProposalValidator<TProposal extends BlockProposal | Checkp
       if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
         // Check if message is for previous slot and within clock tolerance
         if (!isWithinClockTolerance(slotNumber, currentSlot, this.epochCache)) {
-          this.logger.debug(`Penalizing peer for invalid slot number ${slotNumber}`, { currentSlot, nextSlot });
+          this.logger.warn(`Penalizing peer for invalid slot number ${slotNumber}`, { currentSlot, nextSlot });
           return { result: 'reject', severity: PeerErrorSeverity.HighToleranceError };
         }
-        this.logger.debug(`Ignoring proposal for previous slot ${slotNumber} within clock tolerance`);
+        this.logger.verbose(`Ignoring proposal for previous slot ${slotNumber} within clock tolerance`);
         return { result: 'ignore' };
       }
 
       // Signature validity
       const proposer = proposal.getSender();
       if (!proposer) {
-        this.logger.debug(`Penalizing peer for proposal with invalid signature`);
+        this.logger.warn(`Penalizing peer for proposal with invalid signature`);
         return { result: 'reject', severity: PeerErrorSeverity.MidToleranceError };
       }
 
       // Transactions permitted check
       const embeddedTxCount = proposal.txs?.length ?? 0;
       if (!this.txsPermitted && (proposal.txHashes.length > 0 || embeddedTxCount > 0)) {
-        this.logger.debug(
+        this.logger.warn(
           `Penalizing peer for proposal with ${proposal.txHashes.length} transaction(s) when transactions are not permitted`,
         );
         return { result: 'reject', severity: PeerErrorSeverity.MidToleranceError };
@@ -65,7 +65,7 @@ export abstract class ProposalValidator<TProposal extends BlockProposal | Checkp
       // Proposer check
       const expectedProposer = await this.epochCache.getProposerAttesterAddressInSlot(slotNumber);
       if (expectedProposer !== undefined && !proposer.equals(expectedProposer)) {
-        this.logger.debug(`Penalizing peer for invalid proposer for current slot ${slotNumber}`, {
+        this.logger.warn(`Penalizing peer for invalid proposer for current slot ${slotNumber}`, {
           expectedProposer,
           proposer: proposer.toString(),
         });

package/src/msg_validators/tx_validator/archive_cache.ts

@@ -1,5 +1,5 @@
-import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { ArchiveSource } from '@aztec/p2p';
+import type { BlockHash } from '@aztec/stdlib/block';
 import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 
@@ -14,8 +14,8 @@ export class ArchiveCache implements ArchiveSource {
     this.archives = new Map<string, bigint>();
   }
 
-  public async getArchiveIndices(archives: Fr[]): Promise<(bigint | undefined)[]> {
-    const toCheckDb = archives.filter(n => !this.archives.has(n.toString()));
+  public async getArchiveIndices(archives: BlockHash[]): Promise<(bigint | undefined)[]> {
+    const toCheckDb = archives.filter(n => !this.archives.has(n.toString())).map(n => n.toFr());
     const dbHits = await this.db.findLeafIndices(MerkleTreeId.ARCHIVE, toCheckDb);
     dbHits.forEach((x, index) => {
       if (x !== undefined) {

package/src/msg_validators/tx_validator/block_header_validator.ts

@@ -1,23 +1,22 @@
-import type { Fr } from '@aztec/foundation/curves/bn254';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import type { BlockHash } from '@aztec/stdlib/block';
 import { type AnyTx, TX_ERROR_BLOCK_HEADER, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 
 export interface ArchiveSource {
-  getArchiveIndices: (archives: Fr[]) => Promise<(bigint | undefined)[]>;
+  getArchiveIndices: (archives: BlockHash[]) => Promise<(bigint | undefined)[]>;
 }
 
 export class BlockHeaderTxValidator<T extends AnyTx> implements TxValidator<T> {
-  #log = createLogger('p2p:tx_validator:tx_block_header');
+  #log: Logger;
   #archiveSource: ArchiveSource;
 
-  constructor(archiveSource: ArchiveSource) {
+  constructor(archiveSource: ArchiveSource, bindings?: LoggerBindings) {
     this.#archiveSource = archiveSource;
+    this.#log = createLogger('p2p:tx_validator:tx_block_header', bindings);
   }
 
   async validateTx(tx: T): Promise<TxValidationResult> {
-    const [index] = await this.#archiveSource.getArchiveIndices([
-      (await tx.data.constants.anchorBlockHeader.hash()).toField(),
-    ]);
+    const [index] = await this.#archiveSource.getArchiveIndices([await tx.data.constants.anchorBlockHeader.hash()]);
     if (index === undefined) {
       this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for referencing an unknown block header`);
       return { result: 'invalid', reason: [TX_ERROR_BLOCK_HEADER] };

package/src/msg_validators/tx_validator/data_validator.ts

@@ -1,5 +1,5 @@
 import { MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS } from '@aztec/constants';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { computeCalldataHash } from '@aztec/stdlib/hash';
 import {
   TX_ERROR_CALLDATA_COUNT_MISMATCH,
@@ -16,7 +16,11 @@ import {
 } from '@aztec/stdlib/tx';
 
 export class DataTxValidator implements TxValidator<Tx> {
-  #log = createLogger('p2p:tx_validator:tx_data');
+  #log: Logger;
+
+  constructor(bindings?: LoggerBindings) {
+    this.#log = createLogger('p2p:tx_validator:tx_data', bindings);
+  }
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {
     const reason =

package/src/msg_validators/tx_validator/double_spend_validator.ts

@@ -1,4 +1,4 @@
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import {
   type AnyTx,
   TX_ERROR_DUPLICATE_NULLIFIER_IN_TX,
@@ -13,11 +13,12 @@ export interface NullifierSource {
 }
 
 export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
-  #log = createLogger('p2p:tx_validator:tx_double_spend');
+  #log: Logger;
   #nullifierSource: NullifierSource;
 
-  constructor(nullifierSource: NullifierSource) {
+  constructor(nullifierSource: NullifierSource, bindings?: LoggerBindings) {
     this.#nullifierSource = nullifierSource;
+    this.#log = createLogger('p2p:tx_validator:tx_double_spend', bindings);
   }
 
   async validateTx(tx: T): Promise<TxValidationResult> {

package/src/msg_validators/tx_validator/factory.ts

@@ -1,7 +1,8 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import type { LoggerBindings } from '@aztec/foundation/log';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { ProtocolContractAddress, protocolContractsHash } from '@aztec/protocol-contracts';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { GasFees } from '@aztec/stdlib/gas';
 import type {
@@ -11,9 +12,10 @@ import type {
 } from '@aztec/stdlib/interfaces/server';
 import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import { DatabasePublicStateSource, MerkleTreeId } from '@aztec/stdlib/trees';
-import type { Tx, TxValidationResult } from '@aztec/stdlib/tx';
+import type { Tx, TxValidationResult, TxValidator } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
+import { AggregateTxValidator } from './aggregate_tx_validator.js';
 import { ArchiveCache } from './archive_cache.js';
 import { BlockHeaderTxValidator } from './block_header_validator.js';
 import { DataTxValidator } from './data_validator.js';
@@ -21,6 +23,7 @@ import { DoubleSpendTxValidator } from './double_spend_validator.js';
 import { GasTxValidator } from './gas_validator.js';
 import { MetadataTxValidator } from './metadata_validator.js';
 import { PhasesTxValidator } from './phases_validator.js';
+import { SizeTxValidator } from './size_validator.js';
 import { TimestampTxValidator } from './timestamp_validator.js';
 import { TxPermittedValidator } from './tx_permitted_validator.js';
 import { TxProofValidator } from './tx_proof_validator.js';
@@ -44,43 +47,53 @@ export function createTxMessageValidators(
   proofVerifier: ClientProtocolCircuitVerifier,
   txsPermitted: boolean,
   allowedInSetup: AllowedElement[] = [],
+  bindings?: LoggerBindings,
 ): Record<string, MessageValidator>[] {
   const merkleTree = worldStateSynchronizer.getCommitted();
 
   return [
     {
       txsPermittedValidator: {
-        validator: new TxPermittedValidator(txsPermitted),
+        validator: new TxPermittedValidator(txsPermitted, bindings),
         severity: PeerErrorSeverity.MidToleranceError,
       },
       dataValidator: {
-        validator: new DataTxValidator(),
+        validator: new DataTxValidator(bindings),
         severity: PeerErrorSeverity.HighToleranceError,
       },
       metadataValidator: {
-        validator: new MetadataTxValidator({
-          l1ChainId: new Fr(l1ChainId),
-          rollupVersion: new Fr(rollupVersion),
-          protocolContractsHash,
-          vkTreeRoot: getVKTreeRoot(),
-        }),
+        validator: new MetadataTxValidator(
+          {
+            l1ChainId: new Fr(l1ChainId),
+            rollupVersion: new Fr(rollupVersion),
+            protocolContractsHash,
+            vkTreeRoot: getVKTreeRoot(),
+          },
+          bindings,
+        ),
         severity: PeerErrorSeverity.HighToleranceError,
       },
       timestampValidator: {
-        validator: new TimestampTxValidator<Tx>({
-          timestamp,
-          blockNumber,
-        }),
+        validator: new TimestampTxValidator<Tx>(
+          {
+            timestamp,
+            blockNumber,
+          },
+          bindings,
+        ),
         severity: PeerErrorSeverity.MidToleranceError,
       },
       doubleSpendValidator: {
-        validator: new DoubleSpendTxValidator({
-          nullifiersExist: async (nullifiers: Buffer[]) => {
-            const merkleTree = worldStateSynchronizer.getCommitted();
-            const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
-            return indices.map(index => index !== undefined);
+        validator: new DoubleSpendTxValidator(
+          {
+            nullifiersExist: async (nullifiers: Buffer[]) => {
+              const merkleTree = worldStateSynchronizer.getCommitted();
+              const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
+              return indices.map(index => index !== undefined);
+            },
           },
-        }),
+          bindings,
+        ),
         severity: PeerErrorSeverity.HighToleranceError,
       },
       gasValidator: {
@@ -88,23 +101,51 @@ export function createTxMessageValidators(
           new DatabasePublicStateSource(merkleTree),
           ProtocolContractAddress.FeeJuice,
           gasFees,
+          bindings,
         ),
         severity: PeerErrorSeverity.HighToleranceError,
       },
       phasesValidator: {
-        validator: new PhasesTxValidator(contractDataSource, allowedInSetup, timestamp),
+        validator: new PhasesTxValidator(contractDataSource, allowedInSetup, timestamp, bindings),
         severity: PeerErrorSeverity.MidToleranceError,
       },
       blockHeaderValidator: {
-        validator: new BlockHeaderTxValidator(new ArchiveCache(merkleTree)),
+        validator: new BlockHeaderTxValidator(new ArchiveCache(merkleTree), bindings),
         severity: PeerErrorSeverity.HighToleranceError,
       },
     },
     {
       proofValidator: {
-        validator: new TxProofValidator(proofVerifier),
+        validator: new TxProofValidator(proofVerifier, bindings),
         severity: PeerErrorSeverity.MidToleranceError,
       },
     },
   ];
 }
+
+export function createTxReqRespValidator(
+  verifier: ClientProtocolCircuitVerifier,
+  {
+    l1ChainId,
+    rollupVersion,
+  }: {
+    l1ChainId: number;
+    rollupVersion: number;
+  },
+  bindings?: LoggerBindings,
+): TxValidator {
+  return new AggregateTxValidator(
+    new MetadataTxValidator(
+      {
+        l1ChainId: new Fr(l1ChainId),
+        rollupVersion: new Fr(rollupVersion),
+        protocolContractsHash,
+        vkTreeRoot: getVKTreeRoot(),
+      },
+      bindings,
+    ),
+    new SizeTxValidator(bindings),
+    new DataTxValidator(bindings),
+    new TxProofValidator(verifier, bindings),
+  );
+}

package/src/msg_validators/tx_validator/gas_validator.ts

@@ -1,5 +1,5 @@
 import { AVM_MAX_PROCESSABLE_L2_GAS, FIXED_DA_GAS, FIXED_L2_GAS } from '@aztec/constants';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { Gas, GasFees } from '@aztec/stdlib/gas';
@@ -17,12 +17,18 @@ import {
 import { getFeePayerClaimAmount, getTxFeeLimit } from './fee_payer_balance.js';
 
 export class GasTxValidator implements TxValidator<Tx> {
-  #log = createLogger('sequencer:tx_validator:tx_gas');
+  #log: Logger;
   #publicDataSource: PublicStateSource;
   #feeJuiceAddress: AztecAddress;
   #gasFees: GasFees;
 
-  constructor(publicDataSource: PublicStateSource, feeJuiceAddress: AztecAddress, gasFees: GasFees) {
+  constructor(
+    publicDataSource: PublicStateSource,
+    feeJuiceAddress: AztecAddress,
+    gasFees: GasFees,
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('sequencer:tx_validator:tx_gas', bindings);
     this.#publicDataSource = publicDataSource;
     this.#feeJuiceAddress = feeJuiceAddress;
     this.#gasFees = gasFees;

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -1,5 +1,5 @@
 import type { Fr } from '@aztec/foundation/curves/bn254';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import {
   type AnyTx,
   TX_ERROR_INCORRECT_L1_CHAIN_ID,
@@ -11,7 +11,7 @@ import {
 } from '@aztec/stdlib/tx';
 
 export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
-  #log = createLogger('p2p:tx_validator:tx_metadata');
+  #log: Logger;
 
   constructor(
     private values: {
@@ -20,7 +20,10 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
       vkTreeRoot: Fr;
       protocolContractsHash: Fr;
     },
-  ) {}
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('p2p:tx_validator:tx_metadata', bindings);
+  }
 
   validateTx(tx: T): Promise<TxValidationResult> {
     const errors = [];

package/src/msg_validators/tx_validator/phases_validator.ts

@@ -1,4 +1,4 @@
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { PublicContractsDB, getCallRequestsWithCalldataByPhase } from '@aztec/simulator/server';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
@@ -14,15 +14,17 @@ import {
 import type { UInt64 } from '@aztec/stdlib/types';
 
 export class PhasesTxValidator implements TxValidator<Tx> {
-  #log = createLogger('sequencer:tx_validator:tx_phases');
+  #log: Logger;
   private contractsDB: PublicContractsDB;
 
   constructor(
     contracts: ContractDataSource,
     private setupAllowList: AllowedElement[],
     private timestamp: UInt64,
+    bindings?: LoggerBindings,
   ) {
-    this.contractsDB = new PublicContractsDB(contracts);
+    this.#log = createLogger('sequencer:tx_validator:tx_phases', bindings);
+    this.contractsDB = new PublicContractsDB(contracts, bindings);
   }
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {

package/src/msg_validators/tx_validator/size_validator.ts

@@ -1,9 +1,13 @@
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { MAX_TX_SIZE_KB } from '@aztec/stdlib/p2p';
 import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 
 export class SizeTxValidator implements TxValidator<Tx> {
-  #log = createLogger('sequencer:tx_validator:tx_size');
+  #log: Logger;
+
+  constructor(bindings?: LoggerBindings) {
+    this.#log = createLogger('p2p:tx_validator:tx_size', bindings);
+  }
 
   validateTx(tx: Tx): Promise<TxValidationResult> {
     const txSize = tx.getSize();

package/src/msg_validators/tx_validator/timestamp_validator.ts

@@ -1,5 +1,5 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import {
   type AnyTx,
   TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP,
@@ -10,7 +10,7 @@ import {
 import type { UInt64 } from '@aztec/stdlib/types';
 
 export class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
-  #log = createLogger('p2p:tx_validator:timestamp');
+  #log: Logger;
 
   constructor(
     private values: {
@@ -20,7 +20,10 @@ export class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
       // Block number in which the tx is considered to be included.
       blockNumber: BlockNumber;
     },
-  ) {}
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('p2p:tx_validator:timestamp', bindings);
+  }
 
   validateTx(tx: T): Promise<TxValidationResult> {
     const includeByTimestamp = tx.data.includeByTimestamp;

package/src/msg_validators/tx_validator/tx_permitted_validator.ts

@@ -1,10 +1,15 @@
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import type { Tx, TxValidationResult, TxValidator } from '@aztec/stdlib/tx';
 
 export class TxPermittedValidator implements TxValidator<Tx> {
-  #log = createLogger('p2p:tx_validator:tx_permitted');
+  #log: Logger;
 
-  constructor(private permitted: boolean) {}
+  constructor(
+    private permitted: boolean,
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('p2p:tx_validator:tx_permitted', bindings);
+  }
 
   validateTx(tx: Tx): Promise<TxValidationResult> {
     if (!this.permitted) {

package/src/msg_validators/tx_validator/tx_proof_validator.ts

@@ -1,11 +1,16 @@
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
 import { TX_ERROR_INVALID_PROOF, Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 
 export class TxProofValidator implements TxValidator<Tx> {
-  #log = createLogger('p2p:tx_validator:private_proof');
+  #log: Logger;
 
-  constructor(private verifier: ClientProtocolCircuitVerifier) {}
+  constructor(
+    private verifier: ClientProtocolCircuitVerifier,
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('p2p:tx_validator:proof', bindings);
+  }
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {
     const result = await this.verifier.verifyProof(tx);

package/src/services/data_store.ts

@@ -24,6 +24,7 @@ class KeyNotFoundError extends Error {
 }
 
 export class AztecDatastore implements Datastore {
+  #db: AztecAsyncKVStore;
   #memoryDatastore: Map<string, MemoryItem>;
   #dbDatastore: AztecAsyncMap<string, Uint8Array>;
 
@@ -32,9 +33,9 @@ export class AztecDatastore implements Datastore {
   private maxMemoryItems: number;
 
   constructor(db: AztecAsyncKVStore, { maxMemoryItems } = { maxMemoryItems: 50 }) {
+    this.#db = db;
     this.#memoryDatastore = new Map();
     this.#dbDatastore = db.openMap('p2p_datastore');
-
     this.maxMemoryItems = maxMemoryItems;
   }
 
@@ -106,13 +107,15 @@ export class AztecDatastore implements Datastore {
         });
       },
       commit: async () => {
-        for (const op of this.#batchOps) {
-          if (op.type === 'put' && op.value) {
-            await this.put(op.key, op.value);
-          } else if (op.type === 'del') {
-            await this.delete(op.key);
+        await this.#db.transactionAsync(async () => {
+          for (const op of this.#batchOps) {
+            if (op.type === 'put' && op.value) {
+              await this.put(op.key, op.value);
+            } else if (op.type === 'del') {
+              await this.delete(op.key);
+            }
           }
-        }
+        });
         this.#batchOps = []; // Clear operations after commit
       },
     };

package/src/services/discv5/discV5_service.ts

@@ -87,7 +87,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       this.packageVersion,
     ));
 
-    const metricsRegistry = new OtelMetricsAdapter(telemetry);
+    const metricsRegistry = new OtelMetricsAdapter(telemetry, this.logger.getBindings());
     this.discv5 = Discv5.create({
       enr: this.enr,
       peerId,

package/src/services/dummy_service.ts

@@ -8,7 +8,9 @@ import type { ENR } from '@nethermindeth/enr';
 import EventEmitter from 'events';
 
 import type { PeerManagerInterface } from './peer-manager/interface.js';
+import type { BatchTxRequesterLibP2PService } from './reqresp/batch-tx-requester/interface.js';
 import type { P2PReqRespConfig } from './reqresp/config.js';
+import type { ConnectionSampler } from './reqresp/connection-sampler/connection_sampler.js';
 import { type AuthRequest, StatusMessage } from './reqresp/index.js';
 import type {
   ReqRespInterface,
@@ -106,6 +108,15 @@ export class DummyP2PService implements P2PService {
     return Promise.resolve([]);
   }
 
+  public sendRequestToPeer(
+    _peerId: PeerId,
+    _subProtocol: ReqRespSubProtocol,
+    _payload: Buffer,
+    _dialTimeout?: number,
+  ): Promise<ReqRespResponse> {
+    return Promise.resolve({ status: ReqRespStatus.SUCCESS, data: Buffer.from([]) });
+  }
+
   /**
    * Returns the ENR of the peer.
    * @returns The ENR of the peer, otherwise undefined.
@@ -118,6 +129,10 @@ export class DummyP2PService implements P2PService {
     return Promise.resolve();
   }
 
+  validatePropagatedTx(_tx: Tx, _peerId: PeerId): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+
   addReqRespSubProtocol(
     _subProtocol: ReqRespSubProtocol,
     _handler: ReqRespSubProtocolHandler,
@@ -132,6 +147,27 @@ export class DummyP2PService implements P2PService {
 
   //this is no-op
   registerThisValidatorAddresses(_address: EthAddress[]): void {}
+
+  /**
+   * Get dummy BatchTxRequesterLibP2PService for testing
+   */
+  getBatchTxRequesterService(): BatchTxRequesterLibP2PService {
+    return {
+      reqResp: this, // The dummy service implements ReqRespInterface
+      connectionSampler: new DummyReqResp().getConnectionSampler(),
+      txValidatorConfig: {
+        l1ChainId: 1,
+        rollupVersion: 1,
+        proofVerifier: {
+          verifyProof: () => Promise.resolve({ valid: true, durationMs: 0, totalDurationMs: 0 }),
+          stop: () => Promise.resolve(),
+        },
+      },
+      peerScoring: {
+        penalizePeer: (_peerId, _penalty) => {},
+      },
+    };
+  }
 }
 
 /**
@@ -268,6 +304,15 @@ export class DummyReqResp implements ReqRespInterface {
     return Promise.resolve({ status: ReqRespStatus.SUCCESS, data: Buffer.from([]) });
   }
 
+  /**
+   * Get dummy connection sampler for testing
+   */
+  getConnectionSampler(): Pick<ConnectionSampler, 'getPeerListSortedByConnectionCountAsc'> {
+    return {
+      getPeerListSortedByConnectionCountAsc: () => [],
+    };
+  }
+
   addSubProtocol(
     _subProtocol: ReqRespSubProtocol,
     _handler: ReqRespSubProtocolHandler,

package/src/services/libp2p/instrumentation.ts

@@ -8,6 +8,7 @@ import {
   type ObservableGauge,
   type TelemetryClient,
   type UpDownCounter,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
 import { type RecordableHistogram, createHistogram } from 'node:perf_hooks';
@@ -29,11 +30,23 @@ export class P2PInstrumentation {
 
     this.messageValidationDuration = meter.createHistogram(Metrics.P2P_GOSSIP_MESSAGE_VALIDATION_DURATION);
 
-    this.messagePrevalidationCount = meter.createUpDownCounter(Metrics.P2P_GOSSIP_MESSAGE_PREVALIDATION_COUNT);
+    this.messagePrevalidationCount = createUpDownCounterWithDefault(
+      meter,
+      Metrics.P2P_GOSSIP_MESSAGE_PREVALIDATION_COUNT,
+      {
+        [Attributes.TOPIC_NAME]: [
+          TopicType.tx,
+          TopicType.block_proposal,
+          TopicType.checkpoint_proposal,
+          TopicType.checkpoint_attestation,
+        ],
+        [Attributes.OK]: [true, false],
+      },
+    );
 
     this.messageLatency = meter.createHistogram(Metrics.P2P_GOSSIP_MESSAGE_LATENCY);
 
-    this.txReceivedCount = meter.createUpDownCounter(Metrics.P2P_GOSSIP_TX_RECEIVED_COUNT);
+    this.txReceivedCount = createUpDownCounterWithDefault(meter, Metrics.P2P_GOSSIP_TX_RECEIVED_COUNT);
 
     this.aggLatencyMetrics = {
       avg: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_LATENCY_AVG),