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

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -1,5 +1,5 @@
 import type { Fr } from '@aztec/foundation/curves/bn254';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import {
   type AnyTx,
   TX_ERROR_INCORRECT_L1_CHAIN_ID,
@@ -11,7 +11,7 @@ import {
 } from '@aztec/stdlib/tx';
 
 export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
-  #log = createLogger('p2p:tx_validator:tx_metadata');
+  #log: Logger;
 
   constructor(
     private values: {
@@ -20,7 +20,10 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
       vkTreeRoot: Fr;
       protocolContractsHash: Fr;
     },
-  ) {}
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('p2p:tx_validator:tx_metadata', bindings);
+  }
 
   validateTx(tx: T): Promise<TxValidationResult> {
     const errors = [];
@@ -43,7 +46,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 +59,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 +71,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 +84,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/phases_validator.ts

@@ -1,4 +1,4 @@
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { PublicContractsDB, getCallRequestsWithCalldataByPhase } from '@aztec/simulator/server';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
@@ -14,15 +14,17 @@ import {
 import type { UInt64 } from '@aztec/stdlib/types';
 
 export class PhasesTxValidator implements TxValidator<Tx> {
-  #log = createLogger('sequencer:tx_validator:tx_phases');
+  #log: Logger;
   private contractsDB: PublicContractsDB;
 
   constructor(
     contracts: ContractDataSource,
     private setupAllowList: AllowedElement[],
     private timestamp: UInt64,
+    bindings?: LoggerBindings,
   ) {
-    this.contractsDB = new PublicContractsDB(contracts);
+    this.#log = createLogger('sequencer:tx_validator:tx_phases', bindings);
+    this.contractsDB = new PublicContractsDB(contracts, bindings);
   }
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {

package/src/msg_validators/tx_validator/size_validator.ts

@@ -0,0 +1,22 @@
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { MAX_TX_SIZE_KB } from '@aztec/stdlib/p2p';
+import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+
+export class SizeTxValidator implements TxValidator<Tx> {
+  #log: Logger;
+
+  constructor(bindings?: LoggerBindings) {
+    this.#log = createLogger('p2p:tx_validator:tx_size', bindings);
+  }
+
+  validateTx(tx: Tx): Promise<TxValidationResult> {
+    const txSize = tx.getSize();
+    if (txSize > MAX_TX_SIZE_KB * 1024) {
+      this.#log.verbose(
+        `Rejecting transaction ${tx.getTxHash().toString()}. Reason: size above size limit. ${txSize}bytes > ${MAX_TX_SIZE_KB}Kb`,
+      );
+      return Promise.resolve({ result: 'invalid', reason: ['Transaction size above size limit'] });
+    }
+    return Promise.resolve({ result: 'valid' });
+  }
+}

package/src/msg_validators/tx_validator/timestamp_validator.ts

@@ -1,5 +1,5 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import {
   type AnyTx,
   TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP,
@@ -10,7 +10,7 @@ import {
 import type { UInt64 } from '@aztec/stdlib/types';
 
 export class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
-  #log = createLogger('p2p:tx_validator:timestamp');
+  #log: Logger;
 
   constructor(
     private values: {
@@ -20,7 +20,10 @@ export class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
       // Block number in which the tx is considered to be included.
       blockNumber: BlockNumber;
     },
-  ) {}
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('p2p:tx_validator:timestamp', bindings);
+  }
 
   validateTx(tx: T): Promise<TxValidationResult> {
     const includeByTimestamp = tx.data.includeByTimestamp;
@@ -35,7 +38,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/msg_validators/tx_validator/tx_permitted_validator.ts

@@ -1,10 +1,15 @@
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import type { Tx, TxValidationResult, TxValidator } from '@aztec/stdlib/tx';
 
 export class TxPermittedValidator implements TxValidator<Tx> {
-  #log = createLogger('p2p:tx_validator:tx_permitted');
+  #log: Logger;
 
-  constructor(private permitted: boolean) {}
+  constructor(
+    private permitted: boolean,
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('p2p:tx_validator:tx_permitted', bindings);
+  }
 
   validateTx(tx: Tx): Promise<TxValidationResult> {
     if (!this.permitted) {

package/src/msg_validators/tx_validator/tx_proof_validator.ts

@@ -1,11 +1,16 @@
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
 import { TX_ERROR_INVALID_PROOF, Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 
 export class TxProofValidator implements TxValidator<Tx> {
-  #log = createLogger('p2p:tx_validator:private_proof');
+  #log: Logger;
 
-  constructor(private verifier: ClientProtocolCircuitVerifier) {}
+  constructor(
+    private verifier: ClientProtocolCircuitVerifier,
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('p2p:tx_validator:proof', bindings);
+  }
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {
     const result = await this.verifier.verifyProof(tx);

package/src/services/discv5/discV5_service.ts

@@ -87,7 +87,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       this.packageVersion,
     ));
 
-    const metricsRegistry = new OtelMetricsAdapter(telemetry);
+    const metricsRegistry = new OtelMetricsAdapter(telemetry, this.logger.getBindings());
     this.discv5 = Discv5.create({
       enr: this.enr,
       peerId,

package/src/services/dummy_service.ts

@@ -8,7 +8,9 @@ import type { ENR } from '@nethermindeth/enr';
 import EventEmitter from 'events';
 
 import type { PeerManagerInterface } from './peer-manager/interface.js';
+import type { BatchTxRequesterLibP2PService } from './reqresp/batch-tx-requester/interface.js';
 import type { P2PReqRespConfig } from './reqresp/config.js';
+import type { ConnectionSampler } from './reqresp/connection-sampler/connection_sampler.js';
 import { type AuthRequest, StatusMessage } from './reqresp/index.js';
 import type {
   ReqRespInterface,
@@ -23,6 +25,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 +77,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.
@@ -100,6 +108,15 @@ export class DummyP2PService implements P2PService {
     return Promise.resolve([]);
   }
 
+  public sendRequestToPeer(
+    _peerId: PeerId,
+    _subProtocol: ReqRespSubProtocol,
+    _payload: Buffer,
+    _dialTimeout?: number,
+  ): Promise<ReqRespResponse> {
+    return Promise.resolve({ status: ReqRespStatus.SUCCESS, data: Buffer.from([]) });
+  }
+
   /**
    * Returns the ENR of the peer.
    * @returns The ENR of the peer, otherwise undefined.
@@ -112,6 +129,10 @@ export class DummyP2PService implements P2PService {
     return Promise.resolve();
   }
 
+  validatePropagatedTx(_tx: Tx, _peerId: PeerId): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+
   addReqRespSubProtocol(
     _subProtocol: ReqRespSubProtocol,
     _handler: ReqRespSubProtocolHandler,
@@ -126,6 +147,27 @@ export class DummyP2PService implements P2PService {
 
   //this is no-op
   registerThisValidatorAddresses(_address: EthAddress[]): void {}
+
+  /**
+   * Get dummy BatchTxRequesterLibP2PService for testing
+   */
+  getBatchTxRequesterService(): BatchTxRequesterLibP2PService {
+    return {
+      reqResp: this, // The dummy service implements ReqRespInterface
+      connectionSampler: new DummyReqResp().getConnectionSampler(),
+      txValidatorConfig: {
+        l1ChainId: 1,
+        rollupVersion: 1,
+        proofVerifier: {
+          verifyProof: () => Promise.resolve({ valid: true, durationMs: 0, totalDurationMs: 0 }),
+          stop: () => Promise.resolve(),
+        },
+      },
+      peerScoring: {
+        penalizePeer: (_peerId, _penalty) => {},
+      },
+    };
+  }
 }
 
 /**
@@ -262,6 +304,15 @@ export class DummyReqResp implements ReqRespInterface {
     return Promise.resolve({ status: ReqRespStatus.SUCCESS, data: Buffer.from([]) });
   }
 
+  /**
+   * Get dummy connection sampler for testing
+   */
+  getConnectionSampler(): Pick<ConnectionSampler, 'getPeerListSortedByConnectionCountAsc'> {
+    return {
+      getPeerListSortedByConnectionCountAsc: () => [],
+    };
+  }
+
   addSubProtocol(
     _subProtocol: ReqRespSubProtocol,
     _handler: ReqRespSubProtocolHandler,

package/src/services/encoding.ts

@@ -1,7 +1,7 @@
 // Taken from lodestar: https://github.com/ChainSafe/lodestar
 import { sha256 } from '@aztec/foundation/crypto/sha256';
 import { createLogger } from '@aztec/foundation/log';
-import { TopicType, getTopicFromString } from '@aztec/stdlib/p2p';
+import { MAX_TX_SIZE_KB, TopicType, getTopicFromString } from '@aztec/stdlib/p2p';
 
 import type { RPC } from '@chainsafe/libp2p-gossipsub/message';
 import type { DataTransform } from '@chainsafe/libp2p-gossipsub/types';
@@ -52,13 +52,14 @@ export function getMsgIdFn(message: Message) {
 }
 
 const DefaultMaxSizesKb: Record<TopicType, number> = {
-  // Tx effects should not exceed 128kb, so 512kb for the full tx obj should be sufficient
-  [TopicType.tx]: 512,
+  [TopicType.tx]: MAX_TX_SIZE_KB,
   // 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,7 @@ import {
   type ObservableGauge,
   type TelemetryClient,
   type UpDownCounter,
-  ValueType,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
 import { type RecordableHistogram, createHistogram } from 'node:perf_hooks';
@@ -28,81 +28,40 @@ 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 = createUpDownCounterWithDefault(
+      meter,
+      Metrics.P2P_GOSSIP_MESSAGE_PREVALIDATION_COUNT,
+      {
+        [Attributes.TOPIC_NAME]: [
+          TopicType.tx,
+          TopicType.block_proposal,
+          TopicType.checkpoint_proposal,
+          TopicType.checkpoint_attestation,
+        ],
+        [Attributes.OK]: [true, false],
+      },
+    );
 
-    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 = createUpDownCounterWithDefault(meter, 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 +115,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 });
       }
     }
   };