@aztec/p2p 0.84.0 → 0.85.0

package/src/msg_validators/tx_validator/block_header_validator.ts

@@ -1,6 +1,6 @@
 import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
-import { type AnyTx, Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import { type AnyTx, TX_ERROR_BLOCK_HEADER, Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 
 export interface ArchiveSource {
   getArchiveIndices: (archives: Fr[]) => Promise<(bigint | undefined)[]>;
@@ -18,7 +18,7 @@ export class BlockHeaderTxValidator<T extends AnyTx> implements TxValidator<T> {
     const [index] = await this.#archiveSource.getArchiveIndices([await tx.data.constants.historicalHeader.hash()]);
     if (index === undefined) {
       this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for referencing an unknown block header`);
-      return { result: 'invalid', reason: ['Block header not found'] };
+      return { result: 'invalid', reason: [TX_ERROR_BLOCK_HEADER] };
     }
     return { result: 'valid' };
   }

package/src/msg_validators/tx_validator/data_validator.ts

@@ -1,7 +1,18 @@
 import { MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
 import { computeCalldataHash } from '@aztec/stdlib/hash';
-import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import {
+  TX_ERROR_CALLDATA_COUNT_MISMATCH,
+  TX_ERROR_CALLDATA_COUNT_TOO_LARGE,
+  TX_ERROR_CONTRACT_CLASS_LOGS,
+  TX_ERROR_CONTRACT_CLASS_LOG_COUNT,
+  TX_ERROR_CONTRACT_CLASS_LOG_LENGTH,
+  TX_ERROR_CONTRACT_CLASS_LOG_SORTING,
+  TX_ERROR_INCORRECT_CALLDATA,
+  Tx,
+  type TxValidationResult,
+  type TxValidator,
+} from '@aztec/stdlib/tx';
 
 export class DataTxValidator implements TxValidator<Tx> {
   #log = createLogger('p2p:tx_validator:tx_data');
@@ -14,7 +25,7 @@ export class DataTxValidator implements TxValidator<Tx> {
 
   async #hasCorrectCalldata(tx: Tx): Promise<TxValidationResult> {
     if (tx.publicFunctionCalldata.length !== tx.numberOfPublicCalls()) {
-      const reason = 'Wrong number of calldata for public calls';
+      const reason = TX_ERROR_CALLDATA_COUNT_MISMATCH;
       this.#log.warn(
         `Rejecting tx ${await Tx.getHash(tx)}. Reason: ${reason}. Expected ${tx.numberOfPublicCalls()}. Got ${
           tx.publicFunctionCalldata.length
@@ -24,7 +35,7 @@ export class DataTxValidator implements TxValidator<Tx> {
     }
 
     if (tx.getTotalPublicCalldataCount() > MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS) {
-      const reason = 'Total calldata too large for enqueued public calls';
+      const reason = TX_ERROR_CALLDATA_COUNT_TOO_LARGE;
       this.#log.warn(
         `Rejecting tx ${await Tx.getHash(
           tx,
@@ -38,7 +49,7 @@ export class DataTxValidator implements TxValidator<Tx> {
       const { request, calldata } = callRequests[i];
       const hash = await computeCalldataHash(calldata);
       if (!hash.equals(request.calldataHash)) {
-        const reason = 'Incorrect calldata for public call';
+        const reason = TX_ERROR_INCORRECT_CALLDATA;
         this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)}. Reason: ${reason}. Call request index: ${i}.`);
         return { result: 'invalid', reason: [reason] };
       }
@@ -56,7 +67,7 @@ export class DataTxValidator implements TxValidator<Tx> {
           contractClassLogsHashes.length
         }. Got ${hashedContractClasslogs.length}.`,
       );
-      return { result: 'invalid', reason: ['Mismatched number of contract class logs'] };
+      return { result: 'invalid', reason: [TX_ERROR_CONTRACT_CLASS_LOG_COUNT] };
     }
     for (const [i, logHash] of contractClassLogsHashes.entries()) {
       const hashedLog = hashedContractClasslogs[i];
@@ -68,14 +79,14 @@ export class DataTxValidator implements TxValidator<Tx> {
               tx,
             )} because of mismatched contract class logs indices. Expected ${i} from the kernel's log hashes. Got ${matchingLogIndex} in the tx.`,
           );
-          return { result: 'invalid', reason: ['Incorrectly sorted contract class logs'] };
+          return { result: 'invalid', reason: [TX_ERROR_CONTRACT_CLASS_LOG_SORTING] };
         } else {
           this.#log.warn(
             `Rejecting tx ${await Tx.getHash(tx)} because of mismatched contract class logs. Expected hash ${
               logHash.value
             } from the kernels. Got ${hashedLog} in the tx.`,
           );
-          return { result: 'invalid', reason: ['Mismatched contract class logs'] };
+          return { result: 'invalid', reason: [TX_ERROR_CONTRACT_CLASS_LOGS] };
         }
       }
       if (logHash.logHash.length !== tx.contractClassLogs[i].getEmittedLength()) {
@@ -84,7 +95,7 @@ export class DataTxValidator implements TxValidator<Tx> {
             logHash.logHash.length
           } from the kernel's log hashes. Got ${tx.contractClassLogs[i].getEmittedLength()} in the tx.`,
         );
-        return { result: 'invalid', reason: ['Mismatched contract class logs length'] };
+        return { result: 'invalid', reason: [TX_ERROR_CONTRACT_CLASS_LOG_LENGTH] };
       }
     }
     return { result: 'valid' };

package/src/msg_validators/tx_validator/double_spend_validator.ts

@@ -1,5 +1,12 @@
 import { createLogger } from '@aztec/foundation/log';
-import { type AnyTx, Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import {
+  type AnyTx,
+  TX_ERROR_DUPLICATE_NULLIFIER_IN_TX,
+  TX_ERROR_EXISTING_NULLIFIER,
+  Tx,
+  type TxValidationResult,
+  type TxValidator,
+} from '@aztec/stdlib/tx';
 
 export interface NullifierSource {
   nullifiersExist: (nullifiers: Buffer[]) => Promise<boolean[]>;
@@ -20,12 +27,12 @@ export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
     const uniqueNullifiers = new Set(nullifiers);
     if (uniqueNullifiers.size !== nullifiers.length) {
       this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for emitting duplicate nullifiers`);
-      return { result: 'invalid', reason: ['Duplicate nullifier in tx'] };
+      return { result: 'invalid', reason: [TX_ERROR_DUPLICATE_NULLIFIER_IN_TX] };
     }
 
     if ((await this.#nullifierSource.nullifiersExist(nullifiers.map(n => n.toBuffer()))).some(Boolean)) {
       this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for repeating a nullifier`);
-      return { result: 'invalid', reason: ['Existing nullifier'] };
+      return { result: 'invalid', reason: [TX_ERROR_EXISTING_NULLIFIER] };
     }
 
     return { result: 'valid' };

package/src/msg_validators/tx_validator/gas_validator.ts

@@ -1,11 +1,20 @@
+import { FIXED_DA_GAS, FIXED_L2_GAS } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
 import { getCallRequestsWithCalldataByPhase } from '@aztec/simulator/server';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { GasFees } from '@aztec/stdlib/gas';
+import { Gas, GasFees } from '@aztec/stdlib/gas';
 import type { PublicStateSource } from '@aztec/stdlib/trees';
-import { type Tx, TxExecutionPhase, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import {
+  TX_ERROR_INSUFFICIENT_FEE_PAYER_BALANCE,
+  TX_ERROR_INSUFFICIENT_FEE_PER_GAS,
+  TX_ERROR_INSUFFICIENT_GAS_LIMIT,
+  type Tx,
+  TxExecutionPhase,
+  type TxValidationResult,
+  type TxValidator,
+} from '@aztec/stdlib/tx';
 
 export class GasTxValidator implements TxValidator<Tx> {
   #log = createLogger('sequencer:tx_validator:tx_gas');
@@ -20,10 +29,14 @@ export class GasTxValidator implements TxValidator<Tx> {
   }
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {
+    const gasLimitValidation = this.#validateMinGasLimit(tx);
+    if (gasLimitValidation.result === 'invalid') {
+      return Promise.resolve(gasLimitValidation);
+    }
     if (await this.#shouldSkip(tx)) {
-      return Promise.resolve({ result: 'skipped', reason: ['Insufficient fee per gas'] });
+      return Promise.resolve({ result: 'skipped', reason: [TX_ERROR_INSUFFICIENT_FEE_PER_GAS] });
     }
-    return this.#validateTxFee(tx);
+    return this.validateTxFee(tx);
   }
 
   /**
@@ -50,7 +63,24 @@ export class GasTxValidator implements TxValidator<Tx> {
     return notEnoughMaxFees;
   }
 
-  async #validateTxFee(tx: Tx): Promise<TxValidationResult> {
+  /**
+   * Check whether the tx's gas limit is above the minimum amount.
+   */
+  #validateMinGasLimit(tx: Tx): TxValidationResult {
+    const gasLimits = tx.data.constants.txContext.gasSettings.gasLimits;
+    const minGasLimits = new Gas(FIXED_DA_GAS, FIXED_L2_GAS);
+
+    if (minGasLimits.gtAny(gasLimits)) {
+      this.#log.warn(`Rejecting transaction due to the gas limit(s) not being above the minimum gas limit`, {
+        gasLimits,
+        minGasLimits,
+      });
+      return { result: 'invalid', reason: [TX_ERROR_INSUFFICIENT_GAS_LIMIT] };
+    }
+    return { result: 'valid' };
+  }
+
+  public async validateTxFee(tx: Tx): Promise<TxValidationResult> {
     const feePayer = tx.data.feePayer;
 
     // Compute the maximum fee that this tx may pay, based on its gasLimits and maxFeePerGas
@@ -88,7 +118,7 @@ export class GasTxValidator implements TxValidator<Tx> {
         balance: balance.toBigInt(),
         feeLimit: feeLimit.toBigInt(),
       });
-      return { result: 'invalid', reason: ['Insufficient fee payer balance'] };
+      return { result: 'invalid', reason: [TX_ERROR_INSUFFICIENT_FEE_PAYER_BALANCE] };
     }
     return { result: 'valid' };
   }

package/src/msg_validators/tx_validator/index.ts

@@ -8,3 +8,4 @@ export * from './gas_validator.js';
 export * from './phases_validator.js';
 export * from './test_utils.js';
 export * from './allowed_public_setup.js';
+export * from './archive_cache.js';

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -1,6 +1,14 @@
 import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
-import { type AnyTx, Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import {
+  type AnyTx,
+  TX_ERROR_INCORRECT_CHAIN_ID,
+  TX_ERROR_INCORRECT_ROLLUP_VERSION,
+  TX_ERROR_INVALID_BLOCK_NUMBER,
+  Tx,
+  type TxValidationResult,
+  type TxValidator,
+} from '@aztec/stdlib/tx';
 
 export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
   #log = createLogger('p2p:tx_validator:tx_metadata');
@@ -10,13 +18,13 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
   async validateTx(tx: T): Promise<TxValidationResult> {
     const errors = [];
     if (!(await this.#hasCorrectChainId(tx))) {
-      errors.push('Incorrect chain id');
+      errors.push(TX_ERROR_INCORRECT_CHAIN_ID);
     }
     if (!(await this.#hasCorrectRollupVersion(tx))) {
-      errors.push('Incorrect rollup version');
+      errors.push(TX_ERROR_INCORRECT_ROLLUP_VERSION);
     }
     if (!(await this.#isValidForBlockNumber(tx))) {
-      errors.push('Invalid block number');
+      errors.push(TX_ERROR_INVALID_BLOCK_NUMBER);
     }
     return errors.length > 0 ? { result: 'invalid', reason: errors } : { result: 'valid' };
   }

package/src/msg_validators/tx_validator/phases_validator.ts

@@ -4,6 +4,8 @@ import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
 import {
   type PublicCallRequestWithCalldata,
+  TX_ERROR_DURING_VALIDATION,
+  TX_ERROR_SETUP_FUNCTION_NOT_ALLOWED,
   Tx,
   TxExecutionPhase,
   type TxValidationResult,
@@ -42,11 +44,14 @@ export class PhasesTxValidator implements TxValidator<Tx> {
             { allowList: this.setupAllowList },
           );
 
-          return { result: 'invalid', reason: ['Setup function not on allow list'] };
+          return { result: 'invalid', reason: [TX_ERROR_SETUP_FUNCTION_NOT_ALLOWED] };
         }
       }
 
       return { result: 'valid' };
+    } catch (err) {
+      this.#log.error(`Error validating phases for tx`, err);
+      return { result: 'invalid', reason: [TX_ERROR_DURING_VALIDATION] };
     } finally {
       this.contractsDB.clearContractsForTx();
     }

package/src/msg_validators/tx_validator/tx_proof_validator.ts

@@ -1,6 +1,6 @@
 import { createLogger } from '@aztec/foundation/log';
 import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
-import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+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');
@@ -10,7 +10,7 @@ export class TxProofValidator implements TxValidator<Tx> {
   async validateTx(tx: Tx): Promise<TxValidationResult> {
     if (!(await this.verifier.verifyProof(tx))) {
       this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for invalid proof`);
-      return { result: 'invalid', reason: ['Invalid proof'] };
+      return { result: 'invalid', reason: [TX_ERROR_INVALID_PROOF] };
     }
     this.#log.trace(`Accepted ${await Tx.getHash(tx)} with valid proof`);
     return { result: 'valid' };

package/src/services/discv5/discV5_service.ts

@@ -32,9 +32,8 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
 
   private currentState = PeerDiscoveryState.STOPPED;
 
-  public readonly bootstrapNodes: string[] = [];
   private bootstrapNodePeerIds: PeerId[] = [];
-  private bootstrapNodeEnrs: ENR[] = [];
+  public bootstrapNodeEnrs: ENR[] = [];
 
   private startTime = 0;
 
@@ -53,8 +52,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
   ) {
     super();
     const { p2pIp, p2pPort, bootstrapNodes } = config;
-    this.bootstrapNodes = bootstrapNodes ?? [];
-    this.bootstrapNodeEnrs = this.bootstrapNodes.map(x => ENR.decodeTxt(x));
+    this.bootstrapNodeEnrs = bootstrapNodes.map(x => ENR.decodeTxt(x));
     // create ENR from PeerId
     this.enr = SignableENR.createFromPeerId(peerId);
     // Add aztec identification to ENR
@@ -117,7 +115,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     // We want to update our tcp port to match the udp port
     const multiAddrTcp = multiaddr(convertToMultiaddr(m.nodeAddress().address, this.config.p2pPort, 'tcp'));
     this.enr.setLocationMultiaddr(multiAddrTcp);
-    this.logger.info('Multiaddr updated', { multiaddr: multiaddr.toString() });
+    this.logger.info('Multiaddr updated', { multiaddr: multiAddrTcp.toString() });
   }
 
   public async start(): Promise<void> {
@@ -138,10 +136,14 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     this.currentState = PeerDiscoveryState.RUNNING;
 
     // Add bootnode ENR if provided
-    if (this.bootstrapNodes?.length) {
+    if (this.bootstrapNodeEnrs?.length) {
       // Do this conversion once since it involves an async function call
       this.bootstrapNodePeerIds = await Promise.all(this.bootstrapNodeEnrs.map(enr => enr.peerId()));
-      this.logger.info(`Adding ${this.bootstrapNodes} bootstrap nodes ENRs: ${this.bootstrapNodes.join(', ')}`);
+      this.logger.info(
+        `Adding ${this.bootstrapNodeEnrs.length} bootstrap nodes ENRs: ${this.bootstrapNodeEnrs
+          .map(enr => enr.encodeTxt())
+          .join(', ')}`,
+      );
       for (const enr of this.bootstrapNodeEnrs) {
         try {
           if (this.config.bootstrapNodeEnrVersionCheck) {
@@ -244,7 +246,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     // Check the peer is an aztec peer
     const value = enr.kvs.get(AZTEC_ENR_KEY);
     if (!value) {
-      this.logger.warn(`Peer node ${enr.nodeId} does not have aztec key in ENR`);
+      this.logger.debug(`Peer node ${enr.nodeId} does not have aztec key in ENR`);
       return false;
     }
 

package/src/services/dummy_service.ts

@@ -2,6 +2,7 @@ import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
 import type { BlockAttestation, BlockProposal, Gossipable } from '@aztec/stdlib/p2p';
 import { TxHash } from '@aztec/stdlib/tx';
 
+import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
 import EventEmitter from 'events';
 
@@ -90,7 +91,7 @@ export class DummyP2PService implements P2PService {
  */
 export class DummyPeerDiscoveryService extends EventEmitter implements PeerDiscoveryService {
   private currentState = PeerDiscoveryState.STOPPED;
-  public bootstrapNodes: string[] = [];
+  public bootstrapNodeEnrs: ENR[] = [];
 
   /**
    * Starts the dummy implementation.

package/src/services/libp2p/libp2p_service.ts

@@ -86,7 +86,7 @@ type ValidationOutcome = { allPassed: true } | { allPassed: false; failure: Vali
 /**
  * Lib P2P implementation of the P2PService interface.
  */
-export class LibP2PService<T extends P2PClientType> extends WithTracer implements P2PService {
+export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends WithTracer implements P2PService {
   private jobQueue: SerialQueue = new SerialQueue();
   private peerManager: PeerManager;
   private discoveryRunningPromise?: RunningPromise;
@@ -115,15 +115,15 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
   constructor(
     private clientType: T,
     private config: P2PConfig,
-    private node: PubSubLibp2p,
+    protected node: PubSubLibp2p,
     private peerDiscoveryService: PeerDiscoveryService,
-    private mempools: MemPools<T>,
+    protected mempools: MemPools<T>,
     private archiver: L2BlockSource & ContractDataSource,
     epochCache: EpochCacheInterface,
     private proofVerifier: ClientProtocolCircuitVerifier,
     private worldStateSynchronizer: WorldStateSynchronizer,
     telemetry: TelemetryClient,
-    private logger = createLogger('p2p:libp2p_service'),
+    protected logger = createLogger('p2p:libp2p_service'),
   ) {
     super(telemetry, 'LibP2PService');
 
@@ -187,7 +187,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
 
     const otelMetricsAdapter = new OtelMetricsAdapter(telemetry);
 
-    const bootstrapNodes = peerDiscoveryService.bootstrapNodes;
+    const bootstrapNodes = peerDiscoveryService.bootstrapNodeEnrs.map(enr => enr.encodeTxt());
 
     // If trusted peers are provided, also provide them to the p2p service
     bootstrapNodes.push(...config.trustedPeers);
@@ -482,7 +482,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
    * @param topic - The message's topic.
    * @param data - The message data
    */
-  private async handleNewGossipMessage(msg: Message, msgId: string, source: PeerId) {
+  protected async handleNewGossipMessage(msg: Message, msgId: string, source: PeerId) {
     if (msg.topic === Tx.p2pTopic) {
       await this.handleGossipedTx(msg, msgId, source);
     }
@@ -496,7 +496,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     return;
   }
 
-  private async validateReceivedMessage<T>(
+  protected async validateReceivedMessage<T>(
     validationFunc: () => Promise<{ result: boolean; obj: T }>,
     msgId: string,
     source: PeerId,
@@ -516,7 +516,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     return resultAndObj;
   }
 
-  private async handleGossipedTx(msg: Message, msgId: string, source: PeerId) {
+  protected async handleGossipedTx(msg: Message, msgId: string, source: PeerId) {
     const validationFunc = async () => {
       const tx = Tx.fromBuffer(Buffer.from(msg.data));
       const result = await this.validatePropagatedTx(tx, source);
@@ -792,7 +792,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
   ): Promise<ValidationOutcome> {
     const validationPromises = Object.entries(messageValidators).map(async ([name, { validator, severity }]) => {
       const { result } = await validator.validateTx(tx);
-      return { name, isValid: result === 'valid', severity };
+      return { name, isValid: result !== 'invalid', severity };
     });
 
     // A promise that resolves when all validations have been run

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

@@ -49,7 +49,7 @@ export class PeerManager {
     handleConnectedPeerEvent: (e: CustomEvent<PeerId>) => void;
     handleDisconnectedPeerEvent: (e: CustomEvent<PeerId>) => void;
     handleDiscoveredPeer: (enr: ENR) => Promise<void>;
-  } = {} as any;
+  };
 
   constructor(
     private libP2PNode: PubSubLibp2p,

package/src/services/service.ts

@@ -108,5 +108,5 @@ export interface PeerDiscoveryService extends EventEmitter {
 
   getEnr(): ENR | undefined;
 
-  bootstrapNodes: string[];
+  bootstrapNodeEnrs: ENR[];
 }

package/src/testbench/p2p_client_testbench_worker.ts

@@ -10,17 +10,25 @@ import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
-import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import { P2PClientType } from '@aztec/stdlib/p2p';
 import { Tx, TxStatus } from '@aztec/stdlib/tx';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import type { Message, PeerId } from '@libp2p/interface';
+import { TopicValidatorResult } from '@libp2p/interface';
 
 import type { P2PConfig } from '../config.js';
 import { createP2PClient } from '../index.js';
 import type { AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
+import type { MemPools } from '../mem_pools/interface.js';
 import type { TxPool } from '../mem_pools/tx_pool/index.js';
+import { LibP2PService } from '../services/libp2p/libp2p_service.js';
+import type { PeerDiscoveryService } from '../services/service.js';
 import { AlwaysTrueCircuitVerifier } from '../test-helpers/reqresp-nodes.js';
+import type { PubSubLibp2p } from '../util.js';
 
 // Simple mock implementation
 function mockTxPool(): TxPool {
@@ -69,6 +77,72 @@ function mockEpochCache(): EpochCacheInterface {
   };
 }
 
+class TestLibP2PService<T extends P2PClientType = P2PClientType.Full> extends LibP2PService<T> {
+  private disableTxValidation: boolean;
+  private gossipMessageCount: number = 0;
+
+  constructor(
+    clientType: T,
+    config: P2PConfig,
+    node: PubSubLibp2p,
+    peerDiscoveryService: PeerDiscoveryService,
+    mempools: MemPools<T>,
+    archiver: L2BlockSource & ContractDataSource,
+    epochCache: EpochCacheInterface,
+    proofVerifier: ClientProtocolCircuitVerifier,
+    worldStateSynchronizer: WorldStateSynchronizer,
+    telemetry: TelemetryClient,
+    logger = createLogger('p2p:test:libp2p_service'),
+    disableTxValidation = true,
+  ) {
+    super(
+      clientType,
+      config,
+      node,
+      peerDiscoveryService,
+      mempools,
+      archiver,
+      epochCache,
+      proofVerifier,
+      worldStateSynchronizer,
+      telemetry,
+      logger,
+    );
+    this.disableTxValidation = disableTxValidation;
+  }
+
+  public getGossipMessageCount(): number {
+    return this.gossipMessageCount;
+  }
+
+  public setDisableTxValidation(disable: boolean): void {
+    this.disableTxValidation = disable;
+  }
+
+  protected override async handleGossipedTx(msg: Message, msgId: string, source: PeerId) {
+    if (this.disableTxValidation) {
+      const tx = Tx.fromBuffer(Buffer.from(msg.data));
+      this.node.services.pubsub.reportMessageValidationResult(msgId, source.toString(), TopicValidatorResult.Accept);
+
+      const txHash = await tx.getTxHash();
+      const txHashString = txHash.toString();
+      this.logger.verbose(`Received tx ${txHashString} from external peer ${source.toString()}.`);
+      await this.mempools.txPool.addTxs([tx]);
+    } else {
+      await super.handleGossipedTx(msg, msgId, source);
+    }
+  }
+
+  protected override async handleNewGossipMessage(msg: Message, msgId: string, source: PeerId) {
+    this.gossipMessageCount++;
+    process.send!({
+      type: 'GOSSIP_RECEIVED',
+      count: this.gossipMessageCount,
+    });
+    await super.handleNewGossipMessage(msg, msgId, source);
+  }
+}
+
 // eslint-disable-next-line @typescript-eslint/no-misused-promises
 process.on('message', async msg => {
   const { type, config, clientIndex } = msg as { type: string; config: P2PConfig; clientIndex: number };
@@ -80,11 +154,11 @@ process.on('message', async msg => {
       const epochCache = mockEpochCache();
       const worldState = {} as WorldStateSynchronizer;
       const l2BlockSource = new MockL2BlockSource();
-      await l2BlockSource.createBlocks(100);
 
       const proofVerifier = new AlwaysTrueCircuitVerifier();
       const kvStore = await openTmpStore(`test-${clientIndex}`);
       const logger = createLogger(`p2p:${clientIndex}`);
+      const telemetry = getTelemetryClient();
 
       const deps = {
         txPool,
@@ -100,23 +174,30 @@ process.on('message', async msg => {
         proofVerifier,
         worldState,
         epochCache,
-        undefined,
+        telemetry,
         deps,
       );
 
-      // Create spy for gossip messages
-      let gossipMessageCount = 0;
-      (client as any).p2pService.handleNewGossipMessage = (msg: Message, msgId: string, source: PeerId) => {
-        gossipMessageCount++;
-        process.send!({
-          type: 'GOSSIP_RECEIVED',
-          count: gossipMessageCount,
-        });
-        return (client as any).p2pService.constructor.prototype.handleNewGossipMessage.apply(
-          (client as any).p2pService,
-          [msg, msgId, source],
-        );
-      };
+      const _client = client as any;
+
+      // Create test service with validation disabled
+      const testService = new TestLibP2PService(
+        P2PClientType.Full,
+        config,
+        (client as any).p2pService.node,
+        (client as any).p2pService.peerDiscoveryService,
+        (client as any).p2pService.mempools,
+        (client as any).p2pService.archiver,
+        epochCache,
+        proofVerifier,
+        worldState,
+        telemetry,
+        logger,
+        true, // disable validation
+      );
+
+      // Replace the existing p2pService with our test version
+      (client as any).p2pService = testService;
 
       await client.start();
       // Wait until the client is ready

package/src/testbench/parse_log_file.ts

@@ -37,7 +37,7 @@ function getTimestamp(line: string): number | null {
 }
 
 /**
- * Parses a single log line. If the line contains an "rpc.from" event,
+ * Parses a single log line. If the line contains an "Received tx" event,
  * it extracts the timestamp and the peer ID.
  */
 function parseReceivedTx(line: string): LogEvent | null {
@@ -52,9 +52,9 @@ function parseReceivedTx(line: string): LogEvent | null {
     return null;
   }
 
-  // TODO: this is not correct - it is just the tx hash for now
-  // Extract the peer ID after "Received tx"
-  const peerIdMatch = line.match(/p2p:(\d+):/);
+  // Extract the peer ID from the log line
+  // Example format: "module":"p2p:1","msg":"Received tx 0x0feeafa65f25fd8d613fe4aca44fd65fe41c149ef1941e2019d40925c40748f9 from external peer 16Uiu2HAm8w4oxXF3TwDKoGL9U66thMXWqCgPnb2CgkYwmUqFCWbC."
+  const peerIdMatch = line.match(/"module":"p2p:(\d+)"/);
   if (!peerIdMatch) {
     logger.error('No peer Number found in received tx log');
     return null;

package/src/testbench/testbench.ts

@@ -42,7 +42,7 @@ async function main() {
     logger.info('Transaction sent from client 0');
 
     // Give time for message propagation
-    await sleep(30000);
+    await sleep(10000);
     logger.info('Checking message propagation results');
 
     // Check message propagation results