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

package/src/msg_validators/proposal_validator/proposal_validator_test_suite.ts

@@ -0,0 +1,206 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { type BlockProposal, type CheckpointProposal, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+import type { MockProxy } from 'jest-mock-extended';
+
+export interface ProposalValidatorTestParams<TProposal extends BlockProposal | CheckpointProposal> {
+  validatorFactory: (
+    epochCache: EpochCacheInterface,
+    opts: { txsPermitted: boolean },
+  ) => { validate: (proposal: TProposal) => Promise<PeerErrorSeverity | undefined> };
+  makeProposal: (options?: any) => Promise<TProposal>;
+  makeHeader: (epochNumber: number | bigint, slotNumber: number | bigint, blockNumber: number | bigint) => any;
+  getSigner: () => Secp256k1Signer;
+  getAddress: (signer?: Secp256k1Signer) => EthAddress;
+  getSlot: (slot: number | bigint) => any;
+  getTxHashes: (n: number) => TxHash[];
+  getTxs: () => any[];
+  epochCacheMock: () => MockProxy<EpochCacheInterface>;
+}
+
+export function sharedProposalValidatorTests<TProposal extends BlockProposal | CheckpointProposal>(
+  params: ProposalValidatorTestParams<TProposal>,
+) {
+  const { validatorFactory, makeProposal, makeHeader, getSigner, getAddress, getSlot, getTxHashes, epochCacheMock } =
+    params;
+
+  describe('shared proposal validation logic', () => {
+    let epochCache: MockProxy<EpochCacheInterface>;
+    let validator: { validate: (proposal: TProposal) => Promise<PeerErrorSeverity | undefined> };
+
+    beforeEach(() => {
+      epochCache = epochCacheMock();
+      validator = validatorFactory(epochCache, { txsPermitted: true });
+    });
+
+    it('returns high tolerance error if slot number is not current or next slot', async () => {
+      const header = makeHeader(1, 97, 97);
+      const mockProposal = await makeProposal({ blockHeader: header, lastBlockHeader: header });
+      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+        currentSlot: getSlot(98),
+        nextSlot: getSlot(99),
+        currentProposer: getAddress(),
+        nextProposer: getAddress(),
+      });
+      const result = await validator.validate(mockProposal);
+      expect(result).toBe(PeerErrorSeverity.HighToleranceError);
+    });
+
+    it('returns mid tolerance error if proposer is not current proposer for current slot', async () => {
+      const currentProposer = getSigner();
+      const nextProposer = getSigner();
+      const invalidProposer = getSigner();
+      const header = makeHeader(1, 100, 100);
+      const mockProposal = await makeProposal({
+        blockHeader: header,
+        lastBlockHeader: header,
+        signer: invalidProposer,
+      });
+      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+        currentSlot: getSlot(100),
+        nextSlot: getSlot(101),
+        currentProposer: getAddress(currentProposer),
+        nextProposer: getAddress(nextProposer),
+      });
+      const result = await validator.validate(mockProposal);
+      expect(result).toBe(PeerErrorSeverity.MidToleranceError);
+    });
+
+    it('returns mid tolerance error if proposer is not next proposer for next slot', async () => {
+      const currentProposer = getSigner();
+      const nextProposer = getSigner();
+      const invalidProposer = getSigner();
+      const header = makeHeader(1, 101, 101);
+      const mockProposal = await makeProposal({
+        blockHeader: header,
+        lastBlockHeader: header,
+        signer: invalidProposer,
+      });
+      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+        currentSlot: getSlot(100),
+        nextSlot: getSlot(101),
+        currentProposer: getAddress(currentProposer),
+        nextProposer: getAddress(nextProposer),
+      });
+      const result = await validator.validate(mockProposal);
+      expect(result).toBe(PeerErrorSeverity.MidToleranceError);
+    });
+
+    it('returns mid tolerance error if proposer is current proposer but proposal is for next slot', async () => {
+      const currentProposer = getSigner();
+      const nextProposer = getSigner();
+      const header = makeHeader(1, 101, 101);
+      const mockProposal = await makeProposal({
+        blockHeader: header,
+        lastBlockHeader: header,
+        signer: currentProposer,
+      });
+      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+        currentSlot: getSlot(100),
+        nextSlot: getSlot(101),
+        currentProposer: getAddress(currentProposer),
+        nextProposer: getAddress(nextProposer),
+      });
+      const result = await validator.validate(mockProposal);
+      expect(result).toBe(PeerErrorSeverity.MidToleranceError);
+    });
+
+    it('returns undefined if proposal is valid for current slot and proposer', async () => {
+      const currentProposer = getSigner();
+      const nextProposer = getSigner();
+      const header = makeHeader(1, 100, 100);
+      const mockProposal = await makeProposal({
+        blockHeader: header,
+        lastBlockHeader: header,
+        signer: currentProposer,
+      });
+      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+        currentSlot: getSlot(100),
+        nextSlot: getSlot(101),
+        currentProposer: getAddress(currentProposer),
+        nextProposer: getAddress(nextProposer),
+      });
+      const result = await validator.validate(mockProposal);
+      expect(result).toBeUndefined();
+    });
+
+    it('returns undefined if proposal is valid for next slot and proposer', async () => {
+      const currentProposer = getSigner();
+      const nextProposer = getSigner();
+      const header = makeHeader(1, 101, 101);
+      const mockProposal = await makeProposal({ blockHeader: header, lastBlockHeader: header, signer: nextProposer });
+      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+        currentSlot: getSlot(100),
+        nextSlot: getSlot(101),
+        currentProposer: getAddress(currentProposer),
+        nextProposer: getAddress(nextProposer),
+      });
+      const result = await validator.validate(mockProposal);
+      expect(result).toBeUndefined();
+    });
+
+    describe('transaction permission validation', () => {
+      it('returns mid tolerance error if txs not permitted and proposal contains txHashes', async () => {
+        const currentProposer = getSigner();
+        const validatorWithTxsDisabled = validatorFactory(epochCache, { txsPermitted: false });
+        const header = makeHeader(1, 100, 100);
+        const mockProposal = await makeProposal({
+          blockHeader: header,
+          lastBlockHeader: header,
+          signer: currentProposer,
+          txHashes: getTxHashes(2),
+        });
+        epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+          currentSlot: getSlot(100),
+          nextSlot: getSlot(101),
+          currentProposer: getAddress(currentProposer),
+          nextProposer: getAddress(),
+        });
+        const result = await validatorWithTxsDisabled.validate(mockProposal);
+        expect(result).toBe(PeerErrorSeverity.MidToleranceError);
+      });
+
+      it('returns undefined if txs not permitted but proposal has no txHashes', async () => {
+        const currentProposer = getSigner();
+        const validatorWithTxsDisabled = validatorFactory(epochCache, { txsPermitted: false });
+        const header = makeHeader(1, 100, 100);
+        const mockProposal = await makeProposal({
+          blockHeader: header,
+          lastBlockHeader: header,
+          signer: currentProposer,
+          txHashes: getTxHashes(0),
+        });
+        epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+          currentSlot: getSlot(100),
+          nextSlot: getSlot(101),
+          currentProposer: getAddress(currentProposer),
+          nextProposer: getAddress(),
+        });
+        const result = await validatorWithTxsDisabled.validate(mockProposal);
+        expect(result).toBeUndefined();
+      });
+
+      it('returns undefined if txs permitted and proposal contains txHashes', async () => {
+        const currentProposer = getSigner();
+        const header = makeHeader(1, 100, 100);
+        const mockProposal = await makeProposal({
+          blockHeader: header,
+          lastBlockHeader: header,
+          signer: currentProposer,
+          txHashes: getTxHashes(2),
+        });
+        epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+          currentSlot: getSlot(100),
+          nextSlot: getSlot(101),
+          currentProposer: getAddress(currentProposer),
+          nextProposer: getAddress(),
+        });
+        const result = await validator.validate(mockProposal);
+        expect(result).toBeUndefined();
+      });
+    });
+  });
+}

package/src/msg_validators/tx_validator/data_validator.ts

@@ -31,7 +31,9 @@ export class DataTxValidator implements TxValidator<Tx> {
     if (!tx.getTxHash().equals(expected)) {
       const reason = TX_ERROR_INCORRECT_HASH;
       this.#log.verbose(
-        `Rejecting tx ${tx.getTxHash().toString()}. Reason: ${reason}. Expected hash ${expected.toString()}. Got ${tx.getTxHash().toString()}.`,
+        `Rejecting tx ${tx.getTxHash().toString()}. Reason: ${reason}. Expected hash ${expected.toString()}. Got ${tx
+          .getTxHash()
+          .toString()}.`,
       );
       return reason;
     }
@@ -52,7 +54,9 @@ export class DataTxValidator implements TxValidator<Tx> {
     if (tx.getTotalPublicCalldataCount() > MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS) {
       const reason = TX_ERROR_CALLDATA_COUNT_TOO_LARGE;
       this.#log.verbose(
-        `Rejecting tx ${tx.getTxHash().toString()}. Reason: ${reason}. Expected no greater than ${MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS} fields. Got ${tx.getTotalPublicCalldataCount()}.`,
+        `Rejecting tx ${tx
+          .getTxHash()
+          .toString()}. Reason: ${reason}. Expected no greater than ${MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS} fields. Got ${tx.getTotalPublicCalldataCount()}.`,
       );
       return reason;
     }
@@ -89,7 +93,9 @@ export class DataTxValidator implements TxValidator<Tx> {
         if (expectedHashes.some(h => logHash.value.equals(h))) {
           const matchingLogIndex = expectedHashes.findIndex(l => logHash.value.equals(l));
           this.#log.verbose(
-            `Rejecting tx ${tx.getTxHash().toString()} because of mismatched contract class logs indices. Expected ${i} from the kernel's log hashes. Got ${matchingLogIndex} in the tx.`,
+            `Rejecting tx ${tx
+              .getTxHash()
+              .toString()} because of mismatched contract class logs indices. Expected ${i} from the kernel's log hashes. Got ${matchingLogIndex} in the tx.`,
           );
           return TX_ERROR_CONTRACT_CLASS_LOG_SORTING;
         } else {
@@ -105,7 +111,9 @@ export class DataTxValidator implements TxValidator<Tx> {
       const expectedMinLength = 1 + tx.contractClassLogFields[i].fields.findLastIndex(f => !f.isZero());
       if (logHash.logHash.length < expectedMinLength) {
         this.#log.verbose(
-          `Rejecting tx ${tx.getTxHash().toString()} because of incorrect contract class log length. Expected the length to be at least ${expectedMinLength}. Got ${
+          `Rejecting tx ${tx
+            .getTxHash()
+            .toString()} because of incorrect contract class log length. Expected the length to be at least ${expectedMinLength}. Got ${
             logHash.logHash.length
           }.`,
         );

package/src/msg_validators/tx_validator/fee_payer_balance.ts

@@ -0,0 +1,40 @@
+import { getCallRequestsWithCalldataByPhase } from '@aztec/simulator/server';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
+
+export type FeePayerBalanceDelta = {
+  feeLimit: bigint;
+  claimAmount: bigint;
+};
+
+const increasePublicBalanceSelectorPromise = FunctionSelector.fromSignature('_increase_public_balance((Field),u128)');
+
+export function getTxFeeLimit(tx: Tx): bigint {
+  return tx.data.constants.txContext.gasSettings.getFeeLimit().toBigInt();
+}
+
+export async function getFeePayerClaimAmount(tx: Tx, feeJuiceAddress: AztecAddress): Promise<bigint> {
+  const setupFns = getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP);
+  const increasePublicBalanceSelector = await increasePublicBalanceSelectorPromise;
+  const feePayer = tx.data.feePayer;
+
+  const claimFunctionCall = setupFns.find(
+    fn =>
+      fn.request.contractAddress.equals(feeJuiceAddress) &&
+      fn.request.msgSender.equals(feeJuiceAddress) &&
+      fn.calldata.length > 2 &&
+      fn.functionSelector.equals(increasePublicBalanceSelector) &&
+      fn.args[0].equals(feePayer.toField()) &&
+      !fn.request.isStaticCall,
+  );
+
+  return claimFunctionCall ? claimFunctionCall.args[1].toBigInt() : 0n;
+}
+
+export async function getFeePayerBalanceDelta(tx: Tx, feeJuiceAddress: AztecAddress): Promise<FeePayerBalanceDelta> {
+  return {
+    feeLimit: getTxFeeLimit(tx),
+    claimAmount: await getFeePayerClaimAmount(tx, feeJuiceAddress),
+  };
+}

package/src/msg_validators/tx_validator/gas_validator.ts

@@ -1,8 +1,6 @@
 import { AVM_MAX_PROCESSABLE_L2_GAS, FIXED_DA_GAS, FIXED_L2_GAS } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
-import { getCallRequestsWithCalldataByPhase } from '@aztec/simulator/server';
-import { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { Gas, GasFees } from '@aztec/stdlib/gas';
 import type { PublicStateSource } from '@aztec/stdlib/trees';
@@ -12,11 +10,12 @@ import {
   TX_ERROR_INSUFFICIENT_FEE_PER_GAS,
   TX_ERROR_INSUFFICIENT_GAS_LIMIT,
   type Tx,
-  TxExecutionPhase,
   type TxValidationResult,
   type TxValidator,
 } from '@aztec/stdlib/tx';
 
+import { getFeePayerClaimAmount, getTxFeeLimit } from './fee_payer_balance.js';
+
 export class GasTxValidator implements TxValidator<Tx> {
   #log = createLogger('sequencer:tx_validator:tx_gas');
   #publicDataSource: PublicStateSource;
@@ -93,7 +92,7 @@ export class GasTxValidator implements TxValidator<Tx> {
     const feePayer = tx.data.feePayer;
 
     // Compute the maximum fee that this tx may pay, based on its gasLimits and maxFeePerGas
-    const feeLimit = tx.data.constants.txContext.gasSettings.getFeeLimit();
+    const feeLimit = getTxFeeLimit(tx);
 
     // Read current balance of the feePayer
     const initialBalance = await this.#publicDataSource.storageRead(
@@ -102,30 +101,14 @@ export class GasTxValidator implements TxValidator<Tx> {
     );
 
     // If there is a claim in this tx that increases the fee payer balance in Fee Juice, add it to balance
-    const setupFns = getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP);
-    const increasePublicBalanceSelector = await FunctionSelector.fromSignature(
-      '_increase_public_balance((Field),u128)',
-    );
-
-    // Arguments of the claim function call:
-    // - args[0]: Amount recipient.
-    // - args[1]: Amount being claimed.
-    const claimFunctionCall = setupFns.find(
-      fn =>
-        fn.request.contractAddress.equals(this.#feeJuiceAddress) &&
-        fn.request.msgSender.equals(this.#feeJuiceAddress) &&
-        fn.calldata.length > 2 &&
-        fn.functionSelector.equals(increasePublicBalanceSelector) &&
-        fn.args[0].equals(feePayer.toField()) &&
-        !fn.request.isStaticCall,
-    );
+    const claimAmount = await getFeePayerClaimAmount(tx, this.#feeJuiceAddress);
+    const balance = initialBalance.toBigInt() + claimAmount;
 
-    const balance = claimFunctionCall ? initialBalance.add(claimFunctionCall.args[1]) : initialBalance;
-    if (balance.lt(feeLimit)) {
+    if (balance < feeLimit) {
       this.#log.verbose(`Rejecting transaction due to not enough fee payer balance`, {
         feePayer,
-        balance: balance.toBigInt(),
-        feeLimit: feeLimit.toBigInt(),
+        balance,
+        feeLimit,
       });
       return { result: 'invalid', reason: [TX_ERROR_INSUFFICIENT_FEE_PAYER_BALANCE] };
     }

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -43,7 +43,9 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     // This gets implicitly tested in the proof validator, but we can get a much cheaper check here by looking early at the vk.
     if (!tx.data.constants.vkTreeRoot.equals(this.values.vkTreeRoot)) {
       this.#log.verbose(
-        `Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect vk tree root ${tx.data.constants.vkTreeRoot.toString()} != ${this.values.vkTreeRoot.toString()}`,
+        `Rejecting tx ${
+          'txHash' in tx ? tx.txHash : tx.hash
+        } because of incorrect vk tree root ${tx.data.constants.vkTreeRoot.toString()} != ${this.values.vkTreeRoot.toString()}`,
       );
       return false;
     } else {
@@ -54,7 +56,9 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
   #hasCorrectprotocolContractsHash(tx: T): boolean {
     if (!tx.data.constants.protocolContractsHash.equals(this.values.protocolContractsHash)) {
       this.#log.verbose(
-        `Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect protocol contracts hash ${tx.data.constants.protocolContractsHash.toString()} != ${this.values.protocolContractsHash.toString()}`,
+        `Rejecting tx ${
+          'txHash' in tx ? tx.txHash : tx.hash
+        } because of incorrect protocol contracts hash ${tx.data.constants.protocolContractsHash.toString()} != ${this.values.protocolContractsHash.toString()}`,
       );
       return false;
     }
@@ -64,7 +68,9 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
   #hasCorrectL1ChainId(tx: T): boolean {
     if (!tx.data.constants.txContext.chainId.equals(this.values.l1ChainId)) {
       this.#log.verbose(
-        `Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect L1 chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.values.l1ChainId.toNumber()}`,
+        `Rejecting tx ${
+          'txHash' in tx ? tx.txHash : tx.hash
+        } because of incorrect L1 chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.values.l1ChainId.toNumber()}`,
       );
       return false;
     } else {
@@ -75,7 +81,9 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
   #hasCorrectRollupVersion(tx: T): boolean {
     if (!tx.data.constants.txContext.version.equals(this.values.rollupVersion)) {
       this.#log.verbose(
-        `Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect rollup version ${tx.data.constants.txContext.version.toNumber()} != ${this.values.rollupVersion.toNumber()}`,
+        `Rejecting tx ${
+          'txHash' in tx ? tx.txHash : tx.hash
+        } because of incorrect rollup version ${tx.data.constants.txContext.version.toNumber()} != ${this.values.rollupVersion.toNumber()}`,
       );
       return false;
     } else {

package/src/msg_validators/tx_validator/timestamp_validator.ts

@@ -35,7 +35,9 @@ export class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
         );
       }
       this.#log.verbose(
-        `Rejecting tx ${getTxHash(tx)} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp}, timestamp: ${
+        `Rejecting tx ${getTxHash(
+          tx,
+        )} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp}, timestamp: ${
           this.values.timestamp
         }.`,
       );

package/src/services/dummy_service.ts

@@ -23,6 +23,7 @@ import type { GoodByeReason } from './reqresp/protocols/goodbye.js';
 import { ReqRespStatus } from './reqresp/status.js';
 import {
   type P2PBlockReceivedCallback,
+  type P2PCheckpointReceivedCallback,
   type P2PService,
   type PeerDiscoveryService,
   PeerDiscoveryState,
@@ -74,6 +75,11 @@ export class DummyP2PService implements P2PService {
    */
   public registerBlockReceivedCallback(_callback: P2PBlockReceivedCallback) {}
 
+  /**
+   * Register a callback into the validator client for when a checkpoint proposal is received
+   */
+  public registerCheckpointReceivedCallback(_callback: P2PCheckpointReceivedCallback) {}
+
   /**
    * Sends a request to a peer.
    * @param _protocol - The protocol to send the request on.

package/src/services/encoding.ts

@@ -55,10 +55,12 @@ const DefaultMaxSizesKb: Record<TopicType, number> = {
   // Tx effects should not exceed 128kb, so 512kb for the full tx obj should be sufficient
   [TopicType.tx]: 512,
   // An attestation has roughly 30 fields, which is 1kb, so 5x is plenty
-  [TopicType.block_attestation]: 5,
+  [TopicType.checkpoint_attestation]: 5,
   // Proposals may carry some tx objects, so we allow a larger size capped at 10mb
   // Note this may not be enough for carrying all tx objects in a block
   [TopicType.block_proposal]: 1024 * 10,
+  // TODO(palla/mbps): Check size for checkpoint proposal
+  [TopicType.checkpoint_proposal]: 1024 * 10,
 };
 
 /**

package/src/services/libp2p/instrumentation.ts

@@ -8,7 +8,6 @@ import {
   type ObservableGauge,
   type TelemetryClient,
   type UpDownCounter,
-  ValueType,
 } from '@aztec/telemetry-client';
 
 import { type RecordableHistogram, createHistogram } from 'node:perf_hooks';
@@ -28,81 +27,28 @@ export class P2PInstrumentation {
   constructor(client: TelemetryClient, name: string) {
     const meter = client.getMeter(name);
 
-    this.messageValidationDuration = meter.createHistogram(Metrics.P2P_GOSSIP_MESSAGE_VALIDATION_DURATION, {
-      unit: 'ms',
-      description: 'How long validating a gossiped message takes',
-      valueType: ValueType.INT,
-    });
+    this.messageValidationDuration = meter.createHistogram(Metrics.P2P_GOSSIP_MESSAGE_VALIDATION_DURATION);
 
-    this.messagePrevalidationCount = meter.createUpDownCounter(Metrics.P2P_GOSSIP_MESSAGE_PREVALIDATION_COUNT, {
-      description: 'How many message pass/fail prevalidation',
-      valueType: ValueType.INT,
-    });
+    this.messagePrevalidationCount = meter.createUpDownCounter(Metrics.P2P_GOSSIP_MESSAGE_PREVALIDATION_COUNT);
 
-    this.messageLatency = meter.createHistogram(Metrics.P2P_GOSSIP_MESSAGE_LATENCY, {
-      unit: 'ms',
-      description: 'P2P message latency',
-      valueType: ValueType.INT,
-    });
+    this.messageLatency = meter.createHistogram(Metrics.P2P_GOSSIP_MESSAGE_LATENCY);
 
-    this.txReceivedCount = meter.createUpDownCounter(Metrics.P2P_GOSSIP_TX_RECEIVED_COUNT, {
-      description: 'The number of txs received from the p2p network',
-    });
+    this.txReceivedCount = meter.createUpDownCounter(Metrics.P2P_GOSSIP_TX_RECEIVED_COUNT);
 
     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',
-      }),
+      avg: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_LATENCY_AVG),
+      max: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_LATENCY_MAX),
+      min: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_LATENCY_MIN),
+      p50: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_LATENCY_P50),
+      p90: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_LATENCY_P90),
     };
 
     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',
-      }),
+      avg: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_VALIDATION_DURATION_AVG),
+      max: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_VALIDATION_DURATION_MAX),
+      min: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_VALIDATION_DURATION_MIN),
+      p50: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_VALIDATION_DURATION_P50),
+      p90: meter.createObservableGauge(Metrics.P2P_GOSSIP_AGG_MESSAGE_VALIDATION_DURATION_P90),
     };
 
     meter.addBatchObservableCallback(this.aggregate, [
@@ -156,11 +102,11 @@ export class P2PInstrumentation {
           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 });
+        res.observe(metrics.avg, Math.ceil(histogram.mean), { [Attributes.TOPIC_NAME]: topicName });
+        res.observe(metrics.max, Math.ceil(histogram.max), { [Attributes.TOPIC_NAME]: topicName });
+        res.observe(metrics.min, Math.ceil(histogram.min), { [Attributes.TOPIC_NAME]: topicName });
+        res.observe(metrics.p50, Math.ceil(histogram.percentile(50)), { [Attributes.TOPIC_NAME]: topicName });
+        res.observe(metrics.p90, Math.ceil(histogram.percentile(90)), { [Attributes.TOPIC_NAME]: topicName });
       }
     }
   };