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

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(() => {
@@ -25,7 +26,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
   });
 
   it('adds txs to the pool as pending', async () => {
-    const tx1 = await mockTx();
+    const tx1 = await mockTx(1);
 
     await pool.addTxs([tx1]);
     const poolTx = await pool.getTxByHash(tx1.getTxHash());
@@ -36,9 +37,9 @@ export function describeTxPool(getTxPool: () => TxPool) {
   });
 
   it('emits txs-added event with new txs', async () => {
-    const tx1 = await mockTx(); // existing and pending
-    const tx2 = await mockTx(); // mined but not known
-    const tx3 = await mockTx(); // brand new
+    const tx1 = await mockTx(1); // existing and pending
+    const tx2 = await mockTx(2); // mined but not known
+    const tx3 = await mockTx(3); // brand new
 
     await pool.addTxs([tx1]);
     await pool.markAsMined([tx2.getTxHash()], minedBlockHeader);
@@ -51,10 +52,11 @@ export function describeTxPool(getTxPool: () => TxPool) {
     await pool.addTxs([tx1, tx2, tx3]);
     expect(txsFromEvent).toBeDefined();
     expect(txsFromEvent).toHaveLength(2);
-    expect(txsFromEvent).toEqual(expect.arrayContaining([tx2, tx3]));
+    const eventHashes = txsFromEvent!.map(tx => tx.getTxHash());
+    expect(eventHashes).toEqual(expect.arrayContaining([tx2.getTxHash(), tx3.getTxHash()]));
   });
 
-  it('permanently deletes pending txs and soft-deletes mined txs', async () => {
+  it('removes txs from the pool', async () => {
     const pendingTx = await mockTx(1);
     const minedTx = await mockTx(2);
 
@@ -82,7 +84,8 @@ export function describeTxPool(getTxPool: () => TxPool) {
     await pool.addTxs([tx1, tx2]);
     await pool.markAsMined([tx1.getTxHash()], minedBlockHeader);
 
-    await expect(pool.getTxByHash(tx1.getTxHash())).resolves.toEqual(tx1);
+    const retrievedTx = await pool.getTxByHash(tx1.getTxHash());
+    expect(retrievedTx?.getTxHash()).toEqual(tx1.getTxHash());
     await expect(pool.getTxStatus(tx1.getTxHash())).resolves.toEqual('mined');
     await expect(pool.getMinedTxHashes()).resolves.toEqual([[tx1.getTxHash(), 1]]);
     await expect(pool.getPendingTxHashes()).resolves.toEqual([tx2.getTxHash()]);
@@ -96,7 +99,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     await pool.addTxs([tx1, tx2]);
     await pool.markAsMined([tx1.getTxHash()], minedBlockHeader);
 
-    await pool.markMinedAsPending([tx1.getTxHash()]);
+    await pool.markMinedAsPending([tx1.getTxHash()], BlockNumber(1));
     await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
     const pending = await pool.getPendingTxHashes();
     expect(pending).toHaveLength(2);
@@ -120,7 +123,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     );
 
     // reorg: both txs should now become available again
-    await pool.markMinedAsPending([tx1.getTxHash(), someTxHashThatThisPeerDidNotSee]);
+    await pool.markMinedAsPending([tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], BlockNumber(1));
     await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
     await expect(pool.getPendingTxHashes()).resolves.toEqual([tx1.getTxHash()]); // tx2 is not in the pool
     await expect(pool.getPendingTxCount()).resolves.toEqual(1);
@@ -135,7 +138,8 @@ export function describeTxPool(getTxPool: () => TxPool) {
 
     const poolTxs = await pool.getAllTxs();
     expect(poolTxs).toHaveLength(3);
-    expect(poolTxs).toEqual(expect.arrayContaining([tx1, tx2, tx3]));
+    const poolHashes = poolTxs.map(tx => tx.getTxHash());
+    expect(poolHashes).toEqual(expect.arrayContaining([tx1.getTxHash(), tx2.getTxHash(), tx3.getTxHash()]));
     await expect(pool.getPendingTxCount()).resolves.toEqual(3);
   });
 
@@ -162,17 +166,19 @@ export function describeTxPool(getTxPool: () => TxPool) {
 
     const requestedTxs = await pool.getTxsByHash([tx1.getTxHash(), tx3.getTxHash()]);
     expect(requestedTxs).toHaveLength(2);
-    expect(requestedTxs).toEqual(expect.arrayContaining([tx1, tx3]));
+    const requestedHashes = requestedTxs.map(tx => tx!.getTxHash());
+    expect(requestedHashes).toEqual(expect.arrayContaining([tx1.getTxHash(), tx3.getTxHash()]));
   });
 
   it('returns a large number of transactions by their hash', async () => {
-    const numTxs = 1000;
+    const numTxs = 1_000;
     const txs = await Promise.all(Array.from({ length: numTxs }, (_, i) => mockTx(i)));
     const hashes = txs.map(tx => tx.getTxHash());
     await pool.addTxs(txs);
     const requestedTxs = await pool.getTxsByHash(hashes);
     expect(requestedTxs).toHaveLength(numTxs);
-    expect(requestedTxs).toEqual(expect.arrayContaining(txs));
+    const requestedHashes = requestedTxs.map(tx => tx!.getTxHash());
+    expect(requestedHashes).toEqual(expect.arrayContaining(hashes));
   });
 
   it('returns whether or not txs exist', async () => {
@@ -261,7 +267,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 +282,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 +290,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

@@ -1,11 +1,11 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { NoCommitteeError } from '@aztec/ethereum';
+import { NoCommitteeError } from '@aztec/ethereum/contracts';
 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

@@ -1,5 +1,5 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { NoCommitteeError } from '@aztec/ethereum';
+import { NoCommitteeError } from '@aztec/ethereum/contracts';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type BlockProposal, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
 
@@ -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/archive_cache.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { ArchiveSource } from '@aztec/p2p';
 import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
 import { MerkleTreeId } from '@aztec/stdlib/trees';

package/src/msg_validators/tx_validator/block_header_validator.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { type AnyTx, TX_ERROR_BLOCK_HEADER, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 

package/src/msg_validators/tx_validator/factory.ts

@@ -1,4 +1,5 @@
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
@@ -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/metadata_validator.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import {
   type AnyTx,

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/test_utils.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { HashedValues, type Tx } from '@aztec/stdlib/tx';

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/encoding.ts

@@ -1,5 +1,5 @@
 // Taken from lodestar: https://github.com/ChainSafe/lodestar
-import { sha256 } from '@aztec/foundation/crypto';
+import { sha256 } from '@aztec/foundation/crypto/sha256';
 import { createLogger } from '@aztec/foundation/log';
 import { TopicType, getTopicFromString } from '@aztec/stdlib/p2p';
 

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);
     }