@aztec/p2p 0.0.1-commit.b655e406 → 0.0.1-commit.d3ec352c

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/fields';
 import { toArray } from '@aztec/foundation/iterable';
 import { type Logger, createLogger } from '@aztec/foundation/log';
@@ -37,7 +38,7 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
   txPoolOverflowFactor: number = 1;
 
   /** Index from tx hash to the block number in which they were mined, filtered by mined txs. */
-  #minedTxHashToBlock: AztecAsyncMap<string, number>;
+  #minedTxHashToBlock: AztecAsyncMap<string, BlockNumber>;
 
   /** Index from tx priority (stored as hex) to its tx hash, filtered by pending txs. */
   #pendingTxPriorityToHash: AztecAsyncMultiMap<string, string>;
@@ -49,10 +50,10 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
   #pendingTxHashToHeaderHash: AztecAsyncMap<string, string>;
 
   /** Map from tx hash to the block number it was originally mined in (for soft-deleted txs). */
-  #deletedMinedTxHashes: AztecAsyncMap<string, number>;
+  #deletedMinedTxHashes: AztecAsyncMap<string, BlockNumber>;
 
   /** MultiMap from block number to deleted mined tx hashes for efficient cleanup. */
-  #blockToDeletedMinedTxHash: AztecAsyncMultiMap<number, string>;
+  #blockToDeletedMinedTxHash: AztecAsyncMultiMap<BlockNumber, string>;
 
   /** The cumulative tx size in bytes that the pending txs in the pool take up. */
   #pendingTxSize: AztecAsyncSingleton<number>;
@@ -222,7 +223,7 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
     return vals.map(TxHash.fromString);
   }
 
-  public async getMinedTxHashes(): Promise<[TxHash, number][]> {
+  public async getMinedTxHashes(): Promise<[TxHash, BlockNumber][]> {
     const vals = await toArray(this.#minedTxHashToBlock.entriesAsync());
     return vals.map(([txHash, blockNumber]) => [TxHash.fromString(txHash), blockNumber]);
   }
@@ -441,10 +442,10 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
    * @param blockNumber - Block number threshold. Deleted mined txs from this block or earlier will be permanently deleted.
    * @returns The number of transactions permanently deleted.
    */
-  public async cleanupDeletedMinedTxs(blockNumber: number): Promise<number> {
+  public async cleanupDeletedMinedTxs(blockNumber: BlockNumber): Promise<number> {
     let deletedCount = 0;
     const txHashesToDelete: string[] = [];
-    const blocksToDelete: number[] = [];
+    const blocksToDelete: BlockNumber[] = [];
 
     await this.#store.transactionAsync(async () => {
       // Iterate through all entries and check block numbers

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
@@ -18,10 +19,11 @@ export class InMemoryTxPool extends (EventEmitter as new () => TypedEventEmitter
    * Our tx pool, stored as a Map in-memory, with K: tx hash and V: the transaction.
    */
   private txs: Map<bigint, Tx>;
-  private minedTxs: Map<bigint, number>;
+  private minedTxs: Map<bigint, BlockNumber>;
   private pendingTxs: Set<bigint>;
-  private deletedMinedTxHashes: Map<bigint, number>;
-  private blockToDeletedMinedTxHash: Map<number, Set<bigint>>;
+  private deletedMinedTxHashes: Map<bigint, BlockNumber>;
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+  private blockToDeletedMinedTxHash: Map<BlockNumber, Set<bigint>>;
 
   private metrics: PoolInstrumentation<Tx>;
 
@@ -108,7 +110,7 @@ export class InMemoryTxPool extends (EventEmitter as new () => TypedEventEmitter
     });
   }
 
-  public getMinedTxHashes(): Promise<[TxHash, number][]> {
+  public getMinedTxHashes(): Promise<[TxHash, BlockNumber][]> {
     return Promise.resolve(
       Array.from(this.minedTxs.entries()).map(([txHash, blockNumber]) => [TxHash.fromBigInt(txHash), blockNumber]),
     );
@@ -253,9 +255,9 @@ export class InMemoryTxPool extends (EventEmitter as new () => TypedEventEmitter
    * @param blockNumber - Block number threshold. Deleted mined txs from this block or earlier will be permanently deleted.
    * @returns The number of transactions permanently deleted.
    */
-  public cleanupDeletedMinedTxs(blockNumber: number): Promise<number> {
+  public cleanupDeletedMinedTxs(blockNumber: BlockNumber): Promise<number> {
     let deletedCount = 0;
-    const blocksToDelete: number[] = [];
+    const blocksToDelete: BlockNumber[] = [];
 
     // Find all blocks up to the specified block number
     for (const [block, txHashes] of this.blockToDeletedMinedTxHash.entries()) {

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -1,3 +1,4 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 
@@ -102,7 +103,7 @@ export interface TxPool extends TypedEventEmitter<TxPoolEvents> {
    * Gets the hashes of mined transactions currently in the tx pool.
    * @returns An array of mined transaction hashes found in the tx pool.
    */
-  getMinedTxHashes(): Promise<[tx: TxHash, blockNumber: number][]>;
+  getMinedTxHashes(): Promise<[tx: TxHash, blockNumber: BlockNumber][]>;
 
   /**
    * Returns whether the given tx hash is flagged as pending, mined, or deleted.
@@ -131,5 +132,5 @@ export interface TxPool extends TypedEventEmitter<TxPoolEvents> {
    * @param blockNumber - Block number threshold. Deleted mined txs from this block or earlier will be permanently deleted.
    * @returns The number of transactions permanently deleted.
    */
-  cleanupDeletedMinedTxs(blockNumber: number): Promise<number>;
+  cleanupDeletedMinedTxs(blockNumber: BlockNumber): Promise<number>;
 }

package/src/mem_pools/tx_pool/tx_pool_test_suite.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { unfreeze } from '@aztec/foundation/types';
 import { GasFees } from '@aztec/stdlib/gas';
 import { mockTx } from '@aztec/stdlib/testing';
@@ -13,7 +14,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
   let pool: TxPool;
 
   const minedBlockHeader = BlockHeader.empty({
-    globalVariables: GlobalVariables.empty({ blockNumber: 1, timestamp: 0n }),
+    globalVariables: GlobalVariables.empty({ blockNumber: BlockNumber(1), timestamp: 0n }),
   });
 
   beforeEach(() => {
@@ -261,7 +262,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
       await pool.deleteTxs([txs[0].getTxHash(), txs[1].getTxHash()]);
 
       // Clean up deleted mined txs from block 1 and earlier
-      const deletedCount = await pool.cleanupDeletedMinedTxs(1);
+      const deletedCount = await pool.cleanupDeletedMinedTxs(BlockNumber(1));
 
       // Verify old transactions are permanently deleted
       expect(deletedCount).toBe(2);
@@ -276,7 +277,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
 
       // Mark as mined in block 2
       const laterBlockHeader = BlockHeader.empty({
-        globalVariables: GlobalVariables.empty({ blockNumber: 2, timestamp: 0n }),
+        globalVariables: GlobalVariables.empty({ blockNumber: BlockNumber(2), timestamp: 0n }),
       });
       await pool.markAsMined([txs[0].getTxHash()], laterBlockHeader);
 
@@ -284,7 +285,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
       await pool.deleteTxs([txs[0].getTxHash()]);
 
       // Try to clean up with block 1 (before the mined block)
-      const deletedCount = await pool.cleanupDeletedMinedTxs(1);
+      const deletedCount = await pool.cleanupDeletedMinedTxs(BlockNumber(1));
 
       // Verify no transactions were cleaned up
       expect(deletedCount).toBe(0);

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -4,8 +4,8 @@ import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type BlockAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
 
 export class AttestationValidator implements P2PValidator<BlockAttestation> {
-  private epochCache: EpochCacheInterface;
-  private logger: Logger;
+  protected epochCache: EpochCacheInterface;
+  protected logger: Logger;
 
   constructor(epochCache: EpochCacheInterface) {
     this.epochCache = epochCache;
@@ -13,47 +13,45 @@ export class AttestationValidator implements P2PValidator<BlockAttestation> {
   }
 
   async validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined> {
-    const slotNumberBigInt = message.payload.header.slotNumber.toBigInt();
+    const slotNumber = message.payload.header.slotNumber;
 
     try {
       const { currentProposer, nextProposer, currentSlot, nextSlot } =
         await this.epochCache.getProposerAttesterAddressInCurrentOrNextSlot();
 
-      if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
-        this.logger.warn(
-          `Attestation slot ${slotNumberBigInt} is not current (${currentSlot}) or next (${nextSlot}) slot`,
-        );
+      if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
+        this.logger.warn(`Attestation slot ${slotNumber} is not current (${currentSlot}) or next (${nextSlot}) slot`);
         return PeerErrorSeverity.HighToleranceError;
       }
 
       // Verify the signature is valid
       const attester = message.getSender();
       if (attester === undefined) {
-        this.logger.warn(`Invalid signature in attestation for slot ${slotNumberBigInt}`);
+        this.logger.warn(`Invalid signature in attestation for slot ${slotNumber}`);
         return PeerErrorSeverity.LowToleranceError;
       }
 
       // Verify the attester is in the committee for this slot
-      if (!(await this.epochCache.isInCommittee(slotNumberBigInt, attester))) {
-        this.logger.warn(`Attester ${attester.toString()} is not in committee for slot ${slotNumberBigInt}`);
+      if (!(await this.epochCache.isInCommittee(slotNumber, attester))) {
+        this.logger.warn(`Attester ${attester.toString()} is not in committee for slot ${slotNumber}`);
         return PeerErrorSeverity.HighToleranceError;
       }
 
       // Verify the proposer signature matches the expected proposer for this slot
       const proposer = message.getProposer();
-      const expectedProposer = slotNumberBigInt === currentSlot ? currentProposer : nextProposer;
+      const expectedProposer = slotNumber === currentSlot ? currentProposer : nextProposer;
       if (!expectedProposer) {
-        this.logger.warn(`No proposer defined for slot ${slotNumberBigInt}`);
+        this.logger.warn(`No proposer defined for slot ${slotNumber}`);
         return PeerErrorSeverity.HighToleranceError;
       }
       if (!proposer) {
-        this.logger.warn(`Invalid proposer signature in attestation for slot ${slotNumberBigInt}`);
+        this.logger.warn(`Invalid proposer signature in attestation for slot ${slotNumber}`);
         return PeerErrorSeverity.LowToleranceError;
       }
       if (!proposer.equals(expectedProposer)) {
         this.logger.warn(
           `Proposer signature mismatch in attestation. ` +
-            `Expected ${expectedProposer?.toString() ?? 'none'} but got ${proposer.toString()} for slot ${slotNumberBigInt}`,
+            `Expected ${expectedProposer?.toString() ?? 'none'} but got ${proposer.toString()} for slot ${slotNumber}`,
         );
         return PeerErrorSeverity.HighToleranceError;
       }
@@ -62,7 +60,7 @@ export class AttestationValidator implements P2PValidator<BlockAttestation> {
     } catch (e) {
       // People shouldn't be sending us attestations if the committee doesn't exist
       if (e instanceof NoCommitteeError) {
-        this.logger.warn(`No committee exists for attestation for slot ${slotNumberBigInt}`);
+        this.logger.warn(`No committee exists for attestation for slot ${slotNumber}`);
         return PeerErrorSeverity.LowToleranceError;
       }
       throw e;

package/src/msg_validators/attestation_validator/fisherman_attestation_validator.ts

@@ -0,0 +1,91 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { type BlockAttestation, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { Attributes, Metrics, type TelemetryClient, ValueType } from '@aztec/telemetry-client';
+
+import type { AttestationPool } from '../../mem_pools/attestation_pool/attestation_pool.js';
+import { AttestationValidator } from './attestation_validator.js';
+
+/**
+ * FishermanAttestationValidator extends the base AttestationValidator to add
+ * additional validation for fisherman nodes: verifying that attestations sign
+ * the same payload as the original proposal.
+ * Invalid attestations are rejected (not propagated), but peer penalization is
+ * handled by LibP2PService based on the fishermanMode config to ensure a better
+ * view of the network.
+ */
+export class FishermanAttestationValidator extends AttestationValidator {
+  private invalidAttestationCounter;
+
+  constructor(
+    epochCache: EpochCacheInterface,
+    private attestationPool: AttestationPool,
+    telemetryClient: TelemetryClient,
+  ) {
+    super(epochCache);
+    this.logger = this.logger.createChild('[FISHERMAN]');
+
+    const meter = telemetryClient.getMeter('FishermanAttestationValidator');
+    this.invalidAttestationCounter = meter.createUpDownCounter(Metrics.VALIDATOR_INVALID_ATTESTATION_RECEIVED_COUNT, {
+      description: 'The number of invalid attestations received',
+      valueType: ValueType.INT,
+    });
+  }
+
+  override async validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined> {
+    // First run the standard validation
+    const baseValidationResult = await super.validate(message);
+    if (baseValidationResult !== undefined) {
+      // Track base validation failures (invalid signature, wrong committee, etc.)
+      this.invalidAttestationCounter.add(1, {
+        [Attributes.ERROR_TYPE]: 'base_validation_failed',
+      });
+      return baseValidationResult;
+    }
+
+    // fisherman validation: verify attestation payload matches proposal payload
+    const slotNumberBigInt = message.payload.header.slotNumber;
+    const attester = message.getSender();
+    const proposer = message.getProposer();
+
+    if (!attester || !proposer) {
+      return undefined;
+    }
+
+    const proposalId = message.archive.toString();
+    const proposal = await this.attestationPool.getBlockProposal(proposalId);
+
+    if (proposal) {
+      // Compare the attestation payload with the proposal payload
+      if (!message.payload.equals(proposal.payload)) {
+        this.logger.error(
+          `Attestation payload mismatch for slot ${slotNumberBigInt}! ` +
+            `Attester ${attester.toString()} signed different data than the proposal.`,
+          {
+            slot: slotNumberBigInt.toString(),
+            attester: attester.toString(),
+            proposer: proposer.toString(),
+            proposalArchive: proposal.archive.toString(),
+            attestationArchive: message.archive.toString(),
+            proposalHeader: proposal.payload.header.hash().toString(),
+            attestationHeader: message.payload.header.hash().toString(),
+          },
+        );
+
+        // Track invalid attestation metric
+        this.invalidAttestationCounter.add(1, {
+          [Attributes.ERROR_TYPE]: 'payload_mismatch',
+        });
+
+        // Return error to reject the message, but LibP2PService won't penalize in fisherman mode
+        return PeerErrorSeverity.LowToleranceError;
+      }
+    } else {
+      // We might receive attestations before proposals in some cases
+      this.logger.debug(
+        `Received attestation for slot ${slotNumberBigInt} but proposal not found yet. ` + `Proposal ID: ${proposalId}`,
+      );
+    }
+
+    return undefined;
+  }
+}

package/src/msg_validators/attestation_validator/index.ts

@@ -1 +1,2 @@
 export * from './attestation_validator.js';
+export * from './fisherman_attestation_validator.js';

package/src/msg_validators/block_proposal_validator/block_proposal_validator.ts

@@ -24,26 +24,42 @@ export class BlockProposalValidator implements P2PValidator<BlockProposal> {
       }
 
       // Check if transactions are permitted when the proposal contains transaction hashes
-      if (!this.txsPermitted && block.txHashes.length > 0) {
+      const embeddedTxCount = block.txs?.length ?? 0;
+      if (!this.txsPermitted && (block.txHashes.length > 0 || embeddedTxCount > 0)) {
         this.logger.debug(
           `Penalizing peer for block proposal with ${block.txHashes.length} transaction(s) when transactions are not permitted`,
         );
         return PeerErrorSeverity.MidToleranceError;
       }
 
+      // If there are embedded txs, they must be listed in txHashes; if there are no txHashes, there must be no txs
+      const hashSet = new Set(block.txHashes.map(h => h.toString()));
+      const missingTxHashes =
+        embeddedTxCount > 0
+          ? block.txs!.filter(tx => !hashSet.has(tx.getTxHash().toString())).map(tx => tx.getTxHash().toString())
+          : [];
+      if (embeddedTxCount > 0 && missingTxHashes.length > 0) {
+        this.logger.warn('Penalizing peer for embedded transaction(s) not included in txHashes', {
+          embeddedTxCount,
+          txHashesLength: block.txHashes.length,
+          missingTxHashes,
+        });
+        return PeerErrorSeverity.MidToleranceError;
+      }
+
       const { currentProposer, nextProposer, currentSlot, nextSlot } =
         await this.epochCache.getProposerAttesterAddressInCurrentOrNextSlot();
 
       // Check that the attestation is for the current or next slot
-      const slotNumberBigInt = block.payload.header.slotNumber.toBigInt();
-      if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
-        this.logger.debug(`Penalizing peer for invalid slot number ${slotNumberBigInt}`, { currentSlot, nextSlot });
+      const slotNumber = block.payload.header.slotNumber;
+      if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
+        this.logger.debug(`Penalizing peer for invalid slot number ${slotNumber}`, { currentSlot, nextSlot });
         return PeerErrorSeverity.HighToleranceError;
       }
 
       // Check that the block proposal is from the current or next proposer
-      if (slotNumberBigInt === currentSlot && currentProposer !== undefined && !proposer.equals(currentProposer)) {
-        this.logger.debug(`Penalizing peer for invalid proposer for current slot ${slotNumberBigInt}`, {
+      if (slotNumber === currentSlot && currentProposer !== undefined && !proposer.equals(currentProposer)) {
+        this.logger.debug(`Penalizing peer for invalid proposer for current slot ${slotNumber}`, {
           currentProposer,
           nextProposer,
           proposer: proposer.toString(),
@@ -51,8 +67,8 @@ export class BlockProposalValidator implements P2PValidator<BlockProposal> {
         return PeerErrorSeverity.MidToleranceError;
       }
 
-      if (slotNumberBigInt === nextSlot && nextProposer !== undefined && !proposer.equals(nextProposer)) {
-        this.logger.debug(`Penalizing peer for invalid proposer for next slot ${slotNumberBigInt}`, {
+      if (slotNumber === nextSlot && nextProposer !== undefined && !proposer.equals(nextProposer)) {
+        this.logger.debug(`Penalizing peer for invalid proposer for next slot ${slotNumber}`, {
           currentProposer,
           nextProposer,
           proposer: proposer.toString(),
@@ -64,7 +80,7 @@ export class BlockProposalValidator implements P2PValidator<BlockProposal> {
       if (!(await Promise.all(block.txs?.map(tx => tx.validateTxHash()) ?? [])).every(v => v)) {
         this.logger.warn(`Penalizing peer for invalid tx hashes in block proposal`, {
           proposer,
-          slotNumber: slotNumberBigInt,
+          slotNumber,
         });
         return PeerErrorSeverity.LowToleranceError;
       }

package/src/msg_validators/tx_validator/factory.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/fields';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
@@ -33,7 +34,7 @@ export interface MessageValidator {
 
 export function createTxMessageValidators(
   timestamp: UInt64,
-  blockNumber: number,
+  blockNumber: BlockNumber,
   worldStateSynchronizer: WorldStateSynchronizer,
   gasFees: GasFees,
   l1ChainId: number,

package/src/msg_validators/tx_validator/phases_validator.ts

@@ -26,10 +26,12 @@ export class PhasesTxValidator implements TxValidator<Tx> {
   }
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {
+    this.contractsDB.createCheckpoint();
     try {
       // TODO(@spalladino): We add this just to handle public authwit-check calls during setup
       // which are needed for public FPC flows, but fail if the account contract hasnt been deployed yet,
       // which is what we're trying to do as part of the current txs.
+      // We only need to create/revert checkpoint here because of this addNewContracts call.
       await this.contractsDB.addNewContracts(tx);
 
       if (!tx.data.forPublic) {
@@ -58,7 +60,7 @@ export class PhasesTxValidator implements TxValidator<Tx> {
       this.#log.error(`Error validating phases for tx`, err);
       return { result: 'invalid', reason: [TX_ERROR_DURING_VALIDATION] };
     } finally {
-      this.contractsDB.clearContractsForTx();
+      this.contractsDB.revertCheckpoint();
     }
   }
 

package/src/msg_validators/tx_validator/timestamp_validator.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
 import {
   type AnyTx,
@@ -17,7 +18,7 @@ export class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
       // being built.
       timestamp: UInt64;
       // Block number in which the tx is considered to be included.
-      blockNumber: number;
+      blockNumber: BlockNumber;
     },
   ) {}
 

package/src/services/libp2p/instrumentation.ts

@@ -17,6 +17,7 @@ export class P2PInstrumentation {
   private messageValidationDuration: Histogram;
   private messagePrevalidationCount: UpDownCounter;
   private messageLatency: Histogram;
+  private txReceivedCount: UpDownCounter;
 
   private aggLatencyHisto = new Map<TopicType, RecordableHistogram>();
   private aggValidationHisto = new Map<TopicType, RecordableHistogram>();
@@ -44,6 +45,10 @@ export class P2PInstrumentation {
       valueType: ValueType.INT,
     });
 
+    this.txReceivedCount = meter.createUpDownCounter(Metrics.P2P_GOSSIP_TX_RECEIVED_COUNT, {
+      description: 'The number of txs received from the p2p network',
+    });
+
     this.aggLatencyMetrics = {
       avg: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_LATENCY_AVG, {
         valueType: ValueType.DOUBLE,
@@ -119,6 +124,10 @@ export class P2PInstrumentation {
     validationHistogram.record(Math.max(ms, 1));
   }
 
+  public incrementTxReceived(count: number) {
+    this.txReceivedCount.add(count);
+  }
+
   public incMessagePrevalidationStatus(passed: boolean, topicName: TopicType | undefined) {
     this.messagePrevalidationCount.add(1, { [Attributes.TOPIC_NAME]: topicName, [Attributes.OK]: passed });
   }
@@ -129,7 +138,7 @@ export class P2PInstrumentation {
 
     let latencyHistogram = this.aggLatencyHisto.get(topicName);
     if (!latencyHistogram) {
-      latencyHistogram = createHistogram({ min: 1, max: 24 * 60 * 60 * 1000 }); // 24hrs
+      latencyHistogram = createHistogram({ min: 1, max: 60 * 1000 }); // Max: 1 minute
       this.aggLatencyHisto.set(topicName, latencyHistogram);
     }