@aztec/p2p 1.0.0-staging.2 → 1.0.0

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -8,7 +8,7 @@ import type { MerkleTreeReadOperations, WorldStateSynchronizer } from '@aztec/st
 import { ClientIvcProof } from '@aztec/stdlib/proofs';
 import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
 import { DatabasePublicStateSource } from '@aztec/stdlib/trees';
-import { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import assert from 'assert';
@@ -129,14 +129,8 @@ export class AztecKVTxPool implements TxPool {
     }
     return true;
   }
-  /**
-   * Marks transactions as mined in a block and updates the pool state accordingly.
-   * Removes the transactions from the pending set and adds them to the mined set.
-   * Also evicts any transactions that become invalid after the block is mined.
-   * @param txHashes - Array of transaction hashes that were mined
-   * @param blockHeader - The header of the block the transactions were mined in
-   */
-  public async markAsMined(txHashes: TxHash[], blockHeader: BlockHeader): Promise<void> {
+
+  public async markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void> {
     if (txHashes.length === 0) {
       return Promise.resolve();
     }
@@ -148,7 +142,7 @@ export class AztecKVTxPool implements TxPool {
       let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
       for (const hash of txHashes) {
         const key = hash.toString();
-        await this.#minedTxHashToBlock.set(key, blockHeader.globalVariables.blockNumber);
+        await this.#minedTxHashToBlock.set(key, blockNumber);
 
         const tx = await this.getPendingTxByHash(hash);
         if (tx) {
@@ -161,7 +155,7 @@ export class AztecKVTxPool implements TxPool {
       }
       await this.#pendingTxSize.set(pendingTxSize);
 
-      await this.evictInvalidTxsAfterMining(txHashes, blockHeader, minedNullifiers, minedFeePayers);
+      await this.evictInvalidTxsAfterMining(txHashes, blockNumber, minedNullifiers, minedFeePayers);
     });
     // We update this after the transaction above. This ensures that the non-evictable transactions are not evicted
     // until any that have been mined are marked as such.
@@ -541,15 +535,15 @@ export class AztecKVTxPool implements TxPool {
    * Eviction criteria includes:
    *   - txs with nullifiers that are already included in the mined block
    *   - txs with an insufficient fee payer balance
-   *   - txs with an expiration timestamp lower than that of the mined block
+   *   - txs with a max block number lower than the mined block
    *
    * @param minedTxHashes - The tx hashes of the txs mined in the block.
-   * @param blockHeader - The header of the mined block.
+   * @param blockNumber - The block number of the mined block.
    * @returns The total number of txs evicted from the pool.
    */
   private async evictInvalidTxsAfterMining(
     minedTxHashes: TxHash[],
-    blockHeader: BlockHeader,
+    blockNumber: number,
     minedNullifiers: Set<string>,
     minedFeePayers: Set<string>,
   ): Promise<number> {
@@ -557,8 +551,6 @@ export class AztecKVTxPool implements TxPool {
       return 0;
     }
 
-    const { blockNumber, timestamp } = blockHeader.globalVariables;
-
     // Wait for world state to be synced to at least the mined block number
     await this.#worldStateSynchronizer.syncImmediate(blockNumber);
 
@@ -590,12 +582,10 @@ export class AztecKVTxPool implements TxPool {
         continue;
       }
 
-      // Evict pending txs with an expiration timestamp less than or equal to the mined block timestamp
-      const includeByTimestamp = tx.data.rollupValidationRequests.includeByTimestamp;
-      if (includeByTimestamp.isSome && includeByTimestamp.value <= timestamp) {
-        this.#log.verbose(
-          `Evicting tx ${txHash} from pool due to the tx being expired (includeByTimestamp: ${includeByTimestamp.value}, mined block timestamp: ${timestamp})`,
-        );
+      // Evict pending txs with a max block number less than or equal to the mined block
+      const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
+      if (maxBlockNumber.isSome && maxBlockNumber.value <= blockNumber) {
+        this.#log.verbose(`Evicting tx ${txHash} from pool due to an invalid max block number`);
         txsToEvict.push(TxHash.fromString(txHash));
         continue;
       }

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -1,6 +1,6 @@
 import { createLogger } from '@aztec/foundation/log';
 import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
-import { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
@@ -47,10 +47,10 @@ export class InMemoryTxPool implements TxPool {
     return Promise.resolve(this.txs.size === 0);
   }
 
-  public markAsMined(txHashes: TxHash[], blockHeader: BlockHeader): Promise<void> {
+  public markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void> {
     const keys = txHashes.map(x => x.toBigInt());
     for (const key of keys) {
-      this.minedTxs.set(key, blockHeader.globalVariables.blockNumber);
+      this.minedTxs.set(key, blockNumber);
       this.pendingTxs.delete(key);
     }
     return Promise.resolve();

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -1,4 +1,4 @@
-import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
+import type { Tx, TxHash } from '@aztec/stdlib/tx';
 
 export type TxPoolOptions = {
   maxTxPoolSize?: number;
@@ -48,9 +48,8 @@ export interface TxPool {
   /**
    * Marks the set of txs as mined, as opposed to pending.
    * @param txHashes - Hashes of the txs to flag as mined.
-   * @param blockHeader - The header of the mined block.
    */
-  markAsMined(txHashes: TxHash[], blockHeader: BlockHeader): Promise<void>;
+  markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void>;
 
   /**
    * Moves mined txs back to the pending set in the case of a reorg.

package/src/mem_pools/tx_pool/tx_pool_test_suite.ts

@@ -1,7 +1,7 @@
 import { unfreeze } from '@aztec/foundation/types';
 import { GasFees } from '@aztec/stdlib/gas';
 import { mockTx } from '@aztec/stdlib/testing';
-import { BlockHeader, GlobalVariables, type Tx } from '@aztec/stdlib/tx';
+import type { Tx } from '@aztec/stdlib/tx';
 
 import type { TxPool } from './tx_pool.js';
 
@@ -12,10 +12,6 @@ import type { TxPool } from './tx_pool.js';
 export function describeTxPool(getTxPool: () => TxPool) {
   let pool: TxPool;
 
-  const minedBlockHeader = BlockHeader.empty({
-    globalVariables: GlobalVariables.empty({ blockNumber: 1, timestamp: 0n }),
-  });
-
   beforeEach(() => {
     pool = getTxPool();
   });
@@ -47,7 +43,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     const tx2 = await mockTx(2);
 
     await pool.addTxs([tx1, tx2]);
-    await pool.markAsMined([await tx1.getTxHash()], minedBlockHeader);
+    await pool.markAsMined([await tx1.getTxHash()], 1);
 
     await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toEqual(tx1);
     await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('mined');
@@ -61,7 +57,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     const tx2 = await mockTx(2);
 
     await pool.addTxs([tx1, tx2]);
-    await pool.markAsMined([await tx1.getTxHash()], minedBlockHeader);
+    await pool.markAsMined([await tx1.getTxHash()], 1);
 
     await pool.markMinedAsPending([await tx1.getTxHash()]);
     await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
@@ -78,7 +74,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     const someTxHashThatThisPeerDidNotSee = await tx2.getTxHash();
     await pool.addTxs([tx1]);
     // this peer knows that tx2 was mined, but it does not have the tx object
-    await pool.markAsMined([await tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], minedBlockHeader);
+    await pool.markAsMined([await tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], 1);
     expect(await pool.getMinedTxHashes()).toEqual(
       expect.arrayContaining([
         [await tx1.getTxHash(), 1],

package/src/msg_validators/tx_validator/factory.ts

@@ -11,7 +11,6 @@ import type {
 import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import { DatabasePublicStateSource, MerkleTreeId } from '@aztec/stdlib/trees';
 import type { Tx, TxValidationResult } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
 
 import { ArchiveCache } from './archive_cache.js';
 import { BlockHeaderTxValidator } from './block_header_validator.js';
@@ -30,7 +29,6 @@ export interface MessageValidator {
 }
 
 export function createTxMessageValidators(
-  timestamp: UInt64,
   blockNumber: number,
   worldStateSynchronizer: WorldStateSynchronizer,
   gasFees: GasFees,
@@ -53,7 +51,6 @@ export function createTxMessageValidators(
         validator: new MetadataTxValidator({
           l1ChainId: new Fr(l1ChainId),
           rollupVersion: new Fr(rollupVersion),
-          timestamp,
           blockNumber,
           protocolContractTreeRoot,
           vkTreeRoot: getVKTreeRoot(),
@@ -79,7 +76,7 @@ export function createTxMessageValidators(
         severity: PeerErrorSeverity.HighToleranceError,
       },
       phasesValidator: {
-        validator: new PhasesTxValidator(contractDataSource, allowedInSetup, timestamp),
+        validator: new PhasesTxValidator(contractDataSource, allowedInSetup, blockNumber),
         severity: PeerErrorSeverity.MidToleranceError,
       },
       blockHeaderValidator: {

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -6,12 +6,11 @@ import {
   TX_ERROR_INCORRECT_PROTOCOL_CONTRACT_TREE_ROOT,
   TX_ERROR_INCORRECT_ROLLUP_VERSION,
   TX_ERROR_INCORRECT_VK_TREE_ROOT,
-  TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP,
+  TX_ERROR_INVALID_MAX_BLOCK_NUMBER,
   Tx,
   type TxValidationResult,
   type TxValidator,
 } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
 
 export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
   #log = createLogger('p2p:tx_validator:tx_metadata');
@@ -20,10 +19,6 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     private values: {
       l1ChainId: Fr;
       rollupVersion: Fr;
-      // Timestamp at which we will validate that the tx is not expired. This is typically the timestamp of the block
-      // being built.
-      timestamp: UInt64;
-      // Block number in which the tx is considered to be included.
       blockNumber: number;
       vkTreeRoot: Fr;
       protocolContractTreeRoot: Fr;
@@ -38,8 +33,8 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     if (!(await this.#hasCorrectRollupVersion(tx))) {
       errors.push(TX_ERROR_INCORRECT_ROLLUP_VERSION);
     }
-    if (!(await this.#isValidForTimestamp(tx))) {
-      errors.push(TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP);
+    if (!(await this.#isValidForBlockNumber(tx))) {
+      errors.push(TX_ERROR_INVALID_MAX_BLOCK_NUMBER);
     }
     if (!(await this.#hasCorrectVkTreeRoot(tx))) {
       errors.push(TX_ERROR_INCORRECT_VK_TREE_ROOT);
@@ -89,20 +84,14 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     }
   }
 
-  async #isValidForTimestamp(tx: T): Promise<boolean> {
-    const includeByTimestamp = tx.data.rollupValidationRequests.includeByTimestamp;
-    // If building block 1, we skip the expiration check. For details on why see the `validate_include_by_timestamp`
-    // function in `noir-projects/noir-protocol-circuits/crates/rollup-lib/src/base/components/validation_requests.nr`.
-    const buildingBlock1 = this.values.blockNumber === 1;
+  async #isValidForBlockNumber(tx: T): Promise<boolean> {
+    const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
 
-    if (!buildingBlock1 && includeByTimestamp.isSome && includeByTimestamp.value < this.values.timestamp) {
-      if (tx.data.constants.historicalHeader.globalVariables.blockNumber === 0) {
-        this.#log.warn(
-          `A tx built against a genesis block failed to be included in block 1 which is the only block in which txs built against a genesis block are allowed to be included.`,
-        );
-      }
+    if (maxBlockNumber.isSome && maxBlockNumber.value < this.values.blockNumber) {
       this.#log.verbose(
-        `Rejecting tx ${await Tx.getHash(tx)} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp.value}, timestamp: ${this.values.timestamp}.`,
+        `Rejecting tx ${await Tx.getHash(tx)} for low max block number. Tx max block number: ${
+          maxBlockNumber.value
+        }, current block number: ${this.values.blockNumber}.`,
       );
       return false;
     } else {

package/src/msg_validators/tx_validator/phases_validator.ts

@@ -11,7 +11,6 @@ import {
   type TxValidationResult,
   type TxValidator,
 } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
 
 export class PhasesTxValidator implements TxValidator<Tx> {
   #log = createLogger('sequencer:tx_validator:tx_phases');
@@ -20,7 +19,7 @@ export class PhasesTxValidator implements TxValidator<Tx> {
   constructor(
     contracts: ContractDataSource,
     private setupAllowList: AllowedElement[],
-    private timestamp: UInt64,
+    private blockNumber: number,
   ) {
     this.contractsDB = new PublicContractsDB(contracts);
   }
@@ -87,7 +86,7 @@ export class PhasesTxValidator implements TxValidator<Tx> {
         }
       }
 
-      const contractClass = await this.contractsDB.getContractInstance(contractAddress, this.timestamp);
+      const contractClass = await this.contractsDB.getContractInstance(contractAddress, this.blockNumber);
 
       if (!contractClass) {
         throw new Error(`Contract not found: ${contractAddress}`);

package/src/services/libp2p/instrumentation.ts

@@ -1,28 +1,17 @@
 import type { Timer } from '@aztec/foundation/timer';
-import { TopicType } from '@aztec/stdlib/p2p';
+import type { TopicType } from '@aztec/stdlib/p2p';
 import {
   Attributes,
-  type BatchObservableResult,
   type Histogram,
   Metrics,
-  type ObservableGauge,
   type TelemetryClient,
   type UpDownCounter,
   ValueType,
 } from '@aztec/telemetry-client';
 
-import { type RecordableHistogram, createHistogram } from 'node:perf_hooks';
-
 export class P2PInstrumentation {
   private messageValidationDuration: Histogram;
   private messagePrevalidationCount: UpDownCounter;
-  private messageLatency: Histogram;
-
-  private aggLatencyHisto = new Map<TopicType, RecordableHistogram>();
-  private aggValidationHisto = new Map<TopicType, RecordableHistogram>();
-
-  private aggLatencyMetrics: Record<'min' | 'max' | 'p50' | 'p90' | 'avg', ObservableGauge>;
-  private aggValidationMetrics: Record<'min' | 'max' | 'p50' | 'p90' | 'avg', ObservableGauge>;
 
   constructor(client: TelemetryClient, name: string) {
     const meter = client.getMeter(name);
@@ -37,122 +26,14 @@ export class P2PInstrumentation {
       description: 'How many message pass/fail prevalidation',
       valueType: ValueType.INT,
     });
-
-    this.messageLatency = meter.createHistogram(Metrics.P2P_GOSSIP_MESSAGE_LATENCY, {
-      unit: 'ms',
-      description: 'P2P message latency',
-      valueType: ValueType.INT,
-    });
-
-    this.aggLatencyMetrics = {
-      avg: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_LATENCY_AVG, {
-        valueType: ValueType.DOUBLE,
-        description: 'AVG msg latency',
-        unit: 'ms',
-      }),
-      max: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_LATENCY_MAX, {
-        valueType: ValueType.DOUBLE,
-        description: 'MAX msg latency',
-        unit: 'ms',
-      }),
-      min: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_LATENCY_MIN, {
-        valueType: ValueType.DOUBLE,
-        description: 'MIN msg latency',
-        unit: 'ms',
-      }),
-      p50: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_LATENCY_P50, {
-        valueType: ValueType.DOUBLE,
-        description: 'P50 msg latency',
-        unit: 'ms',
-      }),
-      p90: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_LATENCY_P90, {
-        valueType: ValueType.DOUBLE,
-        description: 'P90 msg latency',
-        unit: 'ms',
-      }),
-    };
-
-    this.aggValidationMetrics = {
-      avg: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_VALIDATION_DURATION_AVG, {
-        valueType: ValueType.DOUBLE,
-        description: 'AVG msg validation',
-        unit: 'ms',
-      }),
-      max: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_VALIDATION_DURATION_MAX, {
-        valueType: ValueType.DOUBLE,
-        description: 'MAX msg validation',
-        unit: 'ms',
-      }),
-      min: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_VALIDATION_DURATION_MIN, {
-        valueType: ValueType.DOUBLE,
-        description: 'MIN msg validation',
-        unit: 'ms',
-      }),
-      p50: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_VALIDATION_DURATION_P50, {
-        valueType: ValueType.DOUBLE,
-        description: 'P50 msg validation',
-        unit: 'ms',
-      }),
-      p90: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_VALIDATION_DURATION_P90, {
-        valueType: ValueType.DOUBLE,
-        description: 'P90 msg validation',
-        unit: 'ms',
-      }),
-    };
-
-    meter.addBatchObservableCallback(this.aggregate, [
-      ...Object.values(this.aggValidationMetrics),
-      ...Object.values(this.aggLatencyMetrics),
-    ]);
   }
 
   public recordMessageValidation(topicName: TopicType, timerOrMs: Timer | number) {
-    const ms = Math.ceil(typeof timerOrMs === 'number' ? timerOrMs : timerOrMs.ms());
-    this.messageValidationDuration.record(ms, { [Attributes.TOPIC_NAME]: topicName });
-
-    let validationHistogram = this.aggValidationHisto.get(topicName);
-    if (!validationHistogram) {
-      validationHistogram = createHistogram({ min: 1, max: 5 * 60 * 1000 }); // 5 mins
-      this.aggValidationHisto.set(topicName, validationHistogram);
-    }
-
-    validationHistogram.record(Math.max(ms, 1));
+    const ms = typeof timerOrMs === 'number' ? timerOrMs : timerOrMs.ms();
+    this.messageValidationDuration.record(Math.ceil(ms), { [Attributes.TOPIC_NAME]: topicName });
   }
 
   public incMessagePrevalidationStatus(passed: boolean, topicName: TopicType | undefined) {
     this.messagePrevalidationCount.add(1, { [Attributes.TOPIC_NAME]: topicName, [Attributes.OK]: passed });
   }
-
-  public recordMessageLatency(topicName: TopicType, timerOrMs: Timer | number) {
-    const ms = Math.ceil(typeof timerOrMs === 'number' ? timerOrMs : timerOrMs.ms());
-    this.messageLatency.record(ms, { [Attributes.TOPIC_NAME]: topicName });
-
-    let latencyHistogram = this.aggLatencyHisto.get(topicName);
-    if (!latencyHistogram) {
-      latencyHistogram = createHistogram({ min: 1, max: 24 * 60 * 60 * 1000 }); // 24hrs
-      this.aggLatencyHisto.set(topicName, latencyHistogram);
-    }
-
-    latencyHistogram.record(Math.max(ms, 1));
-  }
-
-  private aggregate = (res: BatchObservableResult) => {
-    for (const [metrics, histograms] of [
-      [this.aggLatencyMetrics, this.aggLatencyHisto],
-      [this.aggValidationMetrics, this.aggValidationHisto],
-    ] as const) {
-      for (const topicName of Object.values(TopicType)) {
-        const histogram = histograms.get(topicName);
-        if (!histogram) {
-          continue;
-        }
-
-        res.observe(metrics.avg, histogram.mean, { [Attributes.TOPIC_NAME]: topicName });
-        res.observe(metrics.max, histogram.max, { [Attributes.TOPIC_NAME]: topicName });
-        res.observe(metrics.min, histogram.min, { [Attributes.TOPIC_NAME]: topicName });
-        res.observe(metrics.p50, histogram.percentile(50), { [Attributes.TOPIC_NAME]: topicName });
-        res.observe(metrics.p90, histogram.percentile(90), { [Attributes.TOPIC_NAME]: topicName });
-      }
-    }
-  };
 }

package/src/services/libp2p/libp2p_service.ts

@@ -23,7 +23,6 @@ import {
 } from '@aztec/stdlib/p2p';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { Tx, type TxHash, type TxValidationResult } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
 import { compressComponentVersions } from '@aztec/stdlib/versioning';
 import { Attributes, OtelMetricsAdapter, type TelemetryClient, WithTracer, trackSpan } from '@aztec/telemetry-client';
 
@@ -126,7 +125,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     private peerManager: PeerManagerInterface,
     protected mempools: MemPools<T>,
     private archiver: L2BlockSource & ContractDataSource,
-    private epochCache: EpochCacheInterface,
+    epochCache: EpochCacheInterface,
     private proofVerifier: ClientProtocolCircuitVerifier,
     private worldStateSynchronizer: WorldStateSynchronizer,
     telemetry: TelemetryClient,
@@ -537,11 +536,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     return result.recipients.length;
   }
 
-  protected preValidateReceivedMessage(
-    msg: Message,
-    msgId: string,
-    source: PeerId,
-  ): { result: boolean; topicType?: TopicType } {
+  protected preValidateReceivedMessage(msg: Message, msgId: string, source: PeerId) {
     let topicType: TopicType | undefined;
 
     switch (msg.topic) {
@@ -564,12 +559,12 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     if (!validator || !validator.addMessage(msgId)) {
       this.instrumentation.incMessagePrevalidationStatus(false, topicType);
       this.node.services.pubsub.reportMessageValidationResult(msgId, source.toString(), TopicValidatorResult.Ignore);
-      return { result: false, topicType };
+      return false;
     }
 
     this.instrumentation.incMessagePrevalidationStatus(true, topicType);
 
-    return { result: true, topicType };
+    return true;
   }
 
   /**
@@ -587,15 +582,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       messageLatency,
     });
 
-    const preValidationResult = this.preValidateReceivedMessage(msg, msgId, source);
-
-    if (!preValidationResult.result) {
+    if (!this.preValidateReceivedMessage(msg, msgId, source)) {
       return;
-    } else if (preValidationResult.topicType !== undefined) {
-      // guard against clock skew & DST
-      if (messageLatency > 0) {
-        this.instrumentation.recordMessageLatency(preValidationResult.topicType, messageLatency);
-      }
     }
 
     if (msg.topic === this.topicStrings[TopicType.tx]) {
@@ -839,11 +827,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     [Attributes.TX_HASH]: (await tx.getTxHash()).toString(),
   }))
   private async validatePropagatedTx(tx: Tx, peerId: PeerId): Promise<boolean> {
-    const currentBlockNumber = await this.archiver.getBlockNumber();
-
-    // We accept transactions if they are not expired by the next slot (checked based on the IncludeByTimestamp field)
-    const { ts: nextSlotTimestamp } = this.epochCache.getEpochAndSlotInNextL1Slot();
-    const messageValidators = await this.createMessageValidators(currentBlockNumber, nextSlotTimestamp);
+    const blockNumber = (await this.archiver.getBlockNumber()) + 1;
+    const messageValidators = await this.createMessageValidators(blockNumber);
 
     for (const validator of messageValidators) {
       const outcome = await this.runValidations(tx, validator);
@@ -856,8 +841,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
 
       // Double spend validator has a special case handler
       if (name === 'doubleSpendValidator') {
-        const txBlockNumber = currentBlockNumber + 1; // tx is expected to be in the next block
-        severity = await this.handleDoubleSpendFailure(tx, txBlockNumber);
+        severity = await this.handleDoubleSpendFailure(tx, blockNumber);
       }
 
       this.peerManager.penalizePeer(peerId, severity);
@@ -878,11 +862,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   }
 
   public async validate(txs: Tx[]): Promise<void> {
-    const currentBlockNumber = await this.archiver.getBlockNumber();
-
-    // We accept transactions if they are not expired by the next slot (checked based on the IncludeByTimestamp field)
-    const { ts: nextSlotTimestamp } = this.epochCache.getEpochAndSlotInNextL1Slot();
-    const messageValidators = await this.createMessageValidators(currentBlockNumber, nextSlotTimestamp);
+    const blockNumber = (await this.archiver.getBlockNumber()) + 1;
+    const messageValidators = await this.createMessageValidators(blockNumber);
 
     await Promise.all(
       txs.map(async tx => {
@@ -897,27 +878,20 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   }
 
   /**
-   * Create message validators for the given block number and timestamp.
+   * 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 currentBlockNumber - The current synced block number.
-   * @param nextSlotTimestamp - The timestamp of the next slot (used to validate txs are not expired).
+   * @param blockNumber - The block number to create validators for.
    * @returns The message validators.
    */
-  private async createMessageValidators(
-    currentBlockNumber: number,
-    nextSlotTimestamp: UInt64,
-  ): Promise<Record<string, MessageValidator>[]> {
-    const gasFees = await this.getGasFees(currentBlockNumber);
+  private async createMessageValidators(blockNumber: number): Promise<Record<string, MessageValidator>[]> {
+    const gasFees = await this.getGasFees(blockNumber - 1);
     const allowedInSetup = this.config.txPublicSetupAllowList ?? (await getDefaultAllowedSetupFunctions());
 
-    const blockNumberInWhichTheTxIsConsideredToBeIncluded = currentBlockNumber + 1;
-
     return createTxMessageValidators(
-      nextSlotTimestamp,
-      blockNumberInWhichTheTxIsConsideredToBeIncluded,
+      blockNumber,
       this.worldStateSynchronizer,
       gasFees,
       this.config.l1ChainId,

package/src/test-helpers/make-test-p2p-clients.ts

@@ -1,6 +1,5 @@
 import { MockL2BlockSource } from '@aztec/archiver/test';
 import type { EpochCache } from '@aztec/epoch-cache';
-import { SecretValue } from '@aztec/foundation/config';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
@@ -79,7 +78,7 @@ export async function makeTestP2PClient(
   const config: P2PConfig & DataStoreConfig = {
     ...p2pBaseConfig,
     p2pEnabled: true,
-    peerIdPrivateKey: new SecretValue(peerIdPrivateKey),
+    peerIdPrivateKey,
     p2pIp: `127.0.0.1`,
     listenAddress: `127.0.0.1`,
     p2pPort: port,

package/src/test-helpers/reqresp-nodes.ts

@@ -1,6 +1,5 @@
 import type { EpochCache } from '@aztec/epoch-cache';
 import { timesParallel } from '@aztec/foundation/collection';
-import { SecretValue } from '@aztec/foundation/config';
 import { createLogger } from '@aztec/foundation/log';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
@@ -126,7 +125,7 @@ export async function createTestLibP2PService<T extends P2PClientType>(
     peerCheckIntervalMS: 1000,
     maxPeerCount: 5,
     p2pEnabled: true,
-    peerIdPrivateKey: new SecretValue(Buffer.from(peerId.privateKey!).toString('hex')),
+    peerIdPrivateKey: Buffer.from(peerId.privateKey!).toString('hex'),
     bootstrapNodeEnrVersionCheck: false,
     ...chainConfig,
   } as P2PConfig & DataStoreConfig;
@@ -279,7 +278,7 @@ export function createBootstrapNodeConfig(privateKey: string, port: number, chai
     l1ChainId: chainConfig.l1ChainId,
     p2pIp: '127.0.0.1',
     p2pPort: port,
-    peerIdPrivateKey: new SecretValue(privateKey),
+    peerIdPrivateKey: privateKey,
     dataDirectory: undefined,
     dataStoreMapSizeKB: 0,
     bootstrapNodes: [],

package/src/testbench/p2p_client_testbench_worker.ts

@@ -82,7 +82,6 @@ function mockEpochCache(): EpochCacheInterface {
         currentSlot: 0n,
         nextSlot: 0n,
       }),
-    getEpochAndSlotInNextL1Slot: () => ({ epoch: 0n, slot: 0n, ts: 0n, now: 0n }),
     isInCommittee: () => Promise.resolve(false),
   };
 }

package/src/testbench/worker_client_manager.ts

@@ -1,4 +1,3 @@
-import { SecretValue } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Logger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
@@ -56,7 +55,7 @@ class WorkerClientManager {
     return {
       ...getP2PDefaultConfig(),
       p2pEnabled: true,
-      peerIdPrivateKey: new SecretValue(this.peerIdPrivateKeys[clientIndex]),
+      peerIdPrivateKey: this.peerIdPrivateKeys[clientIndex],
       listenAddress: '127.0.0.1',
       p2pIp: '127.0.0.1',
       p2pPort: port,