@aztec/p2p 1.0.0 → 1.1.2

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 { Tx, TxHash } from '@aztec/stdlib/tx';
+import { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import assert from 'assert';
@@ -129,8 +129,14 @@ export class AztecKVTxPool implements TxPool {
     }
     return true;
   }
-
-  public async markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void> {
+  /**
+   * 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> {
     if (txHashes.length === 0) {
       return Promise.resolve();
     }
@@ -142,7 +148,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, blockNumber);
+        await this.#minedTxHashToBlock.set(key, blockHeader.globalVariables.blockNumber);
 
         const tx = await this.getPendingTxByHash(hash);
         if (tx) {
@@ -155,7 +161,7 @@ export class AztecKVTxPool implements TxPool {
       }
       await this.#pendingTxSize.set(pendingTxSize);
 
-      await this.evictInvalidTxsAfterMining(txHashes, blockNumber, minedNullifiers, minedFeePayers);
+      await this.evictInvalidTxsAfterMining(txHashes, blockHeader, 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.
@@ -535,15 +541,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 a max block number lower than the mined block
+   *   - txs with an expiration timestamp lower than that of the mined block
    *
    * @param minedTxHashes - The tx hashes of the txs mined in the block.
-   * @param blockNumber - The block number of the mined block.
+   * @param blockHeader - The header of the mined block.
    * @returns The total number of txs evicted from the pool.
    */
   private async evictInvalidTxsAfterMining(
     minedTxHashes: TxHash[],
-    blockNumber: number,
+    blockHeader: BlockHeader,
     minedNullifiers: Set<string>,
     minedFeePayers: Set<string>,
   ): Promise<number> {
@@ -551,6 +557,8 @@ 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);
 
@@ -582,10 +590,12 @@ export class AztecKVTxPool implements TxPool {
         continue;
       }
 
-      // 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`);
+      // 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})`,
+        );
         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 { Tx, TxHash } from '@aztec/stdlib/tx';
+import { BlockHeader, 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[], blockNumber: number): Promise<void> {
+  public markAsMined(txHashes: TxHash[], blockHeader: BlockHeader): Promise<void> {
     const keys = txHashes.map(x => x.toBigInt());
     for (const key of keys) {
-      this.minedTxs.set(key, blockNumber);
+      this.minedTxs.set(key, blockHeader.globalVariables.blockNumber);
       this.pendingTxs.delete(key);
     }
     return Promise.resolve();

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -1,4 +1,4 @@
-import type { Tx, TxHash } from '@aztec/stdlib/tx';
+import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 
 export type TxPoolOptions = {
   maxTxPoolSize?: number;
@@ -48,8 +48,9 @@ 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[], blockNumber: number): Promise<void>;
+  markAsMined(txHashes: TxHash[], blockHeader: BlockHeader): 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 type { Tx } from '@aztec/stdlib/tx';
+import { BlockHeader, GlobalVariables, type Tx } from '@aztec/stdlib/tx';
 
 import type { TxPool } from './tx_pool.js';
 
@@ -12,6 +12,10 @@ 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();
   });
@@ -43,7 +47,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     const tx2 = await mockTx(2);
 
     await pool.addTxs([tx1, tx2]);
-    await pool.markAsMined([await tx1.getTxHash()], 1);
+    await pool.markAsMined([await tx1.getTxHash()], minedBlockHeader);
 
     await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toEqual(tx1);
     await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('mined');
@@ -57,7 +61,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     const tx2 = await mockTx(2);
 
     await pool.addTxs([tx1, tx2]);
-    await pool.markAsMined([await tx1.getTxHash()], 1);
+    await pool.markAsMined([await tx1.getTxHash()], minedBlockHeader);
 
     await pool.markMinedAsPending([await tx1.getTxHash()]);
     await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
@@ -74,7 +78,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], 1);
+    await pool.markAsMined([await tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], minedBlockHeader);
     expect(await pool.getMinedTxHashes()).toEqual(
       expect.arrayContaining([
         [await tx1.getTxHash(), 1],

package/src/msg_validators/tx_validator/factory.ts

@@ -11,6 +11,7 @@ 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';
@@ -29,6 +30,7 @@ export interface MessageValidator {
 }
 
 export function createTxMessageValidators(
+  timestamp: UInt64,
   blockNumber: number,
   worldStateSynchronizer: WorldStateSynchronizer,
   gasFees: GasFees,
@@ -51,6 +53,7 @@ export function createTxMessageValidators(
         validator: new MetadataTxValidator({
           l1ChainId: new Fr(l1ChainId),
           rollupVersion: new Fr(rollupVersion),
+          timestamp,
           blockNumber,
           protocolContractTreeRoot,
           vkTreeRoot: getVKTreeRoot(),
@@ -76,7 +79,7 @@ export function createTxMessageValidators(
         severity: PeerErrorSeverity.HighToleranceError,
       },
       phasesValidator: {
-        validator: new PhasesTxValidator(contractDataSource, allowedInSetup, blockNumber),
+        validator: new PhasesTxValidator(contractDataSource, allowedInSetup, timestamp),
         severity: PeerErrorSeverity.MidToleranceError,
       },
       blockHeaderValidator: {

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -6,11 +6,12 @@ import {
   TX_ERROR_INCORRECT_PROTOCOL_CONTRACT_TREE_ROOT,
   TX_ERROR_INCORRECT_ROLLUP_VERSION,
   TX_ERROR_INCORRECT_VK_TREE_ROOT,
-  TX_ERROR_INVALID_MAX_BLOCK_NUMBER,
+  TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP,
   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');
@@ -19,6 +20,10 @@ 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;
@@ -33,8 +38,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.#isValidForBlockNumber(tx))) {
-      errors.push(TX_ERROR_INVALID_MAX_BLOCK_NUMBER);
+    if (!(await this.#isValidForTimestamp(tx))) {
+      errors.push(TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP);
     }
     if (!(await this.#hasCorrectVkTreeRoot(tx))) {
       errors.push(TX_ERROR_INCORRECT_VK_TREE_ROOT);
@@ -84,14 +89,20 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     }
   }
 
-  async #isValidForBlockNumber(tx: T): Promise<boolean> {
-    const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
+  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;
 
-    if (maxBlockNumber.isSome && maxBlockNumber.value < this.values.blockNumber) {
+    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.`,
+        );
+      }
       this.#log.verbose(
-        `Rejecting tx ${await Tx.getHash(tx)} for low max block number. Tx max block number: ${
-          maxBlockNumber.value
-        }, current block number: ${this.values.blockNumber}.`,
+        `Rejecting tx ${await Tx.getHash(tx)} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp.value}, timestamp: ${this.values.timestamp}.`,
       );
       return false;
     } else {

package/src/msg_validators/tx_validator/phases_validator.ts

@@ -11,6 +11,7 @@ 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');
@@ -19,7 +20,7 @@ export class PhasesTxValidator implements TxValidator<Tx> {
   constructor(
     contracts: ContractDataSource,
     private setupAllowList: AllowedElement[],
-    private blockNumber: number,
+    private timestamp: UInt64,
   ) {
     this.contractsDB = new PublicContractsDB(contracts);
   }
@@ -86,7 +87,7 @@ export class PhasesTxValidator implements TxValidator<Tx> {
         }
       }
 
-      const contractClass = await this.contractsDB.getContractInstance(contractAddress, this.blockNumber);
+      const contractClass = await this.contractsDB.getContractInstance(contractAddress, this.timestamp);
 
       if (!contractClass) {
         throw new Error(`Contract not found: ${contractAddress}`);

package/src/services/libp2p/instrumentation.ts

@@ -1,17 +1,28 @@
 import type { Timer } from '@aztec/foundation/timer';
-import type { TopicType } from '@aztec/stdlib/p2p';
+import { 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);
@@ -26,14 +37,122 @@ 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 = typeof timerOrMs === 'number' ? timerOrMs : timerOrMs.ms();
-    this.messageValidationDuration.record(Math.ceil(ms), { [Attributes.TOPIC_NAME]: topicName });
+    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));
   }
 
   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 || histogram.count === 0) {
+          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,6 +23,7 @@ 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';
 
@@ -125,7 +126,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     private peerManager: PeerManagerInterface,
     protected mempools: MemPools<T>,
     private archiver: L2BlockSource & ContractDataSource,
-    epochCache: EpochCacheInterface,
+    private epochCache: EpochCacheInterface,
     private proofVerifier: ClientProtocolCircuitVerifier,
     private worldStateSynchronizer: WorldStateSynchronizer,
     telemetry: TelemetryClient,
@@ -536,7 +537,11 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     return result.recipients.length;
   }
 
-  protected preValidateReceivedMessage(msg: Message, msgId: string, source: PeerId) {
+  protected preValidateReceivedMessage(
+    msg: Message,
+    msgId: string,
+    source: PeerId,
+  ): { result: boolean; topicType?: TopicType } {
     let topicType: TopicType | undefined;
 
     switch (msg.topic) {
@@ -559,12 +564,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 false;
+      return { result: false, topicType };
     }
 
     this.instrumentation.incMessagePrevalidationStatus(true, topicType);
 
-    return true;
+    return { result: true, topicType };
   }
 
   /**
@@ -582,8 +587,15 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       messageLatency,
     });
 
-    if (!this.preValidateReceivedMessage(msg, msgId, source)) {
+    const preValidationResult = this.preValidateReceivedMessage(msg, msgId, source);
+
+    if (!preValidationResult.result) {
       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]) {
@@ -827,8 +839,11 @@ 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 blockNumber = (await this.archiver.getBlockNumber()) + 1;
-    const messageValidators = await this.createMessageValidators(blockNumber);
+    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);
 
     for (const validator of messageValidators) {
       const outcome = await this.runValidations(tx, validator);
@@ -841,7 +856,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
 
       // Double spend validator has a special case handler
       if (name === 'doubleSpendValidator') {
-        severity = await this.handleDoubleSpendFailure(tx, blockNumber);
+        const txBlockNumber = currentBlockNumber + 1; // tx is expected to be in the next block
+        severity = await this.handleDoubleSpendFailure(tx, txBlockNumber);
       }
 
       this.peerManager.penalizePeer(peerId, severity);
@@ -862,8 +878,11 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   }
 
   public async validate(txs: Tx[]): Promise<void> {
-    const blockNumber = (await this.archiver.getBlockNumber()) + 1;
-    const messageValidators = await this.createMessageValidators(blockNumber);
+    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);
 
     await Promise.all(
       txs.map(async tx => {
@@ -878,20 +897,27 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   }
 
   /**
-   * Create message validators for the given block number.
+   * Create message validators for the given block number and timestamp.
    *
    * Each validator is a pair of a validator and a severity.
    * If a validator fails, the peer is penalized with the severity of the validator.
    *
-   * @param blockNumber - The block number to create validators for.
+   * @param currentBlockNumber - The current synced block number.
+   * @param nextSlotTimestamp - The timestamp of the next slot (used to validate txs are not expired).
    * @returns The message validators.
    */
-  private async createMessageValidators(blockNumber: number): Promise<Record<string, MessageValidator>[]> {
-    const gasFees = await this.getGasFees(blockNumber - 1);
+  private async createMessageValidators(
+    currentBlockNumber: number,
+    nextSlotTimestamp: UInt64,
+  ): Promise<Record<string, MessageValidator>[]> {
+    const gasFees = await this.getGasFees(currentBlockNumber);
     const allowedInSetup = this.config.txPublicSetupAllowList ?? (await getDefaultAllowedSetupFunctions());
 
+    const blockNumberInWhichTheTxIsConsideredToBeIncluded = currentBlockNumber + 1;
+
     return createTxMessageValidators(
-      blockNumber,
+      nextSlotTimestamp,
+      blockNumberInWhichTheTxIsConsideredToBeIncluded,
       this.worldStateSynchronizer,
       gasFees,
       this.config.l1ChainId,

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

@@ -1,5 +1,6 @@
 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';
@@ -78,7 +79,7 @@ export async function makeTestP2PClient(
   const config: P2PConfig & DataStoreConfig = {
     ...p2pBaseConfig,
     p2pEnabled: true,
-    peerIdPrivateKey,
+    peerIdPrivateKey: new SecretValue(peerIdPrivateKey),
     p2pIp: `127.0.0.1`,
     listenAddress: `127.0.0.1`,
     p2pPort: port,

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

@@ -1,5 +1,6 @@
 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';
@@ -125,7 +126,7 @@ export async function createTestLibP2PService<T extends P2PClientType>(
     peerCheckIntervalMS: 1000,
     maxPeerCount: 5,
     p2pEnabled: true,
-    peerIdPrivateKey: Buffer.from(peerId.privateKey!).toString('hex'),
+    peerIdPrivateKey: new SecretValue(Buffer.from(peerId.privateKey!).toString('hex')),
     bootstrapNodeEnrVersionCheck: false,
     ...chainConfig,
   } as P2PConfig & DataStoreConfig;
@@ -278,7 +279,7 @@ export function createBootstrapNodeConfig(privateKey: string, port: number, chai
     l1ChainId: chainConfig.l1ChainId,
     p2pIp: '127.0.0.1',
     p2pPort: port,
-    peerIdPrivateKey: privateKey,
+    peerIdPrivateKey: new SecretValue(privateKey),
     dataDirectory: undefined,
     dataStoreMapSizeKB: 0,
     bootstrapNodes: [],

package/src/testbench/p2p_client_testbench_worker.ts

@@ -82,6 +82,7 @@ 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,3 +1,4 @@
+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';
@@ -55,7 +56,7 @@ class WorkerClientManager {
     return {
       ...getP2PDefaultConfig(),
       p2pEnabled: true,
-      peerIdPrivateKey: this.peerIdPrivateKeys[clientIndex],
+      peerIdPrivateKey: new SecretValue(this.peerIdPrivateKeys[clientIndex]),
       listenAddress: '127.0.0.1',
       p2pIp: '127.0.0.1',
       p2pPort: port,