@aztec/p2p 4.0.0-nightly.20250907 → 4.0.0-nightly.20260107

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -1,17 +1,14 @@
-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_INCORRECT_L1_CHAIN_ID,
-  TX_ERROR_INCORRECT_PROTOCOL_CONTRACT_TREE_ROOT,
+  TX_ERROR_INCORRECT_PROTOCOL_CONTRACTS_HASH,
   TX_ERROR_INCORRECT_ROLLUP_VERSION,
   TX_ERROR_INCORRECT_VK_TREE_ROOT,
-  TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP,
   type TxValidationResult,
   type TxValidator,
-  getTxHash,
 } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
 
 export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
   #log = createLogger('p2p:tx_validator:tx_metadata');
@@ -20,13 +17,8 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     private values: {
       l1ChainId: Fr;
       rollupVersion: Fr;
-      // Timestamp at which we will validate that the tx is not expired. This is typically the timestamp of the block
-      // being built.
-      timestamp: UInt64;
-      // Block number in which the tx is considered to be included.
-      blockNumber: number;
       vkTreeRoot: Fr;
-      protocolContractTreeRoot: Fr;
+      protocolContractsHash: Fr;
     },
   ) {}
 
@@ -38,14 +30,11 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     if (!this.#hasCorrectRollupVersion(tx)) {
       errors.push(TX_ERROR_INCORRECT_ROLLUP_VERSION);
     }
-    if (!this.#isValidForTimestamp(tx)) {
-      errors.push(TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP);
-    }
     if (!this.#hasCorrectVkTreeRoot(tx)) {
       errors.push(TX_ERROR_INCORRECT_VK_TREE_ROOT);
     }
-    if (!this.#hasCorrectProtocolContractTreeRoot(tx)) {
-      errors.push(TX_ERROR_INCORRECT_PROTOCOL_CONTRACT_TREE_ROOT);
+    if (!this.#hasCorrectprotocolContractsHash(tx)) {
+      errors.push(TX_ERROR_INCORRECT_PROTOCOL_CONTRACTS_HASH);
     }
     return Promise.resolve(errors.length > 0 ? { result: 'invalid', reason: errors } : { result: 'valid' });
   }
@@ -62,10 +51,10 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     }
   }
 
-  #hasCorrectProtocolContractTreeRoot(tx: T): boolean {
-    if (!tx.data.constants.protocolContractTreeRoot.equals(this.values.protocolContractTreeRoot)) {
+  #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 contract tree root ${tx.data.constants.protocolContractTreeRoot.toString()} != ${this.values.protocolContractTreeRoot.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;
     }
@@ -83,29 +72,6 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     }
   }
 
-  #isValidForTimestamp(tx: T): boolean {
-    const includeByTimestamp = tx.data.includeByTimestamp;
-    // If building block 1, we skip the expiration check. For details on why see the `validate_include_by_timestamp`
-    // function in `noir-projects/noir-protocol-circuits/crates/rollup-lib/src/base/components/validation_requests.nr`.
-    const buildingBlock1 = this.values.blockNumber === 1;
-
-    if (!buildingBlock1 && includeByTimestamp < this.values.timestamp) {
-      if (tx.data.constants.historicalHeader.globalVariables.blockNumber === 0) {
-        this.#log.warn(
-          `A tx built against a genesis block failed to be included in block 1 which is the only block in which txs built against a genesis block are allowed to be included.`,
-        );
-      }
-      this.#log.verbose(
-        `Rejecting tx ${getTxHash(tx)} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp}, timestamp: ${
-          this.values.timestamp
-        }.`,
-      );
-      return false;
-    } else {
-      return true;
-    }
-  }
-
   #hasCorrectRollupVersion(tx: T): boolean {
     if (!tx.data.constants.txContext.version.equals(this.values.rollupVersion)) {
       this.#log.verbose(

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

@@ -0,0 +1,47 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { createLogger } from '@aztec/foundation/log';
+import {
+  type AnyTx,
+  TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP,
+  type TxValidationResult,
+  type TxValidator,
+  getTxHash,
+} from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+export class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
+  #log = createLogger('p2p:tx_validator:timestamp');
+
+  constructor(
+    private values: {
+      // Timestamp at which we will validate that the tx is not expired. This is typically the timestamp of the block
+      // being built.
+      timestamp: UInt64;
+      // Block number in which the tx is considered to be included.
+      blockNumber: BlockNumber;
+    },
+  ) {}
+
+  validateTx(tx: T): Promise<TxValidationResult> {
+    const includeByTimestamp = tx.data.includeByTimestamp;
+    // If building block 1, we skip the expiration check. For details on why see the `validate_include_by_timestamp`
+    // function in `noir-projects/noir-protocol-circuits/crates/rollup-lib/src/base/components/validation_requests.nr`.
+    const buildingBlock1 = this.values.blockNumber === 1;
+
+    if (!buildingBlock1 && includeByTimestamp < this.values.timestamp) {
+      if (tx.data.constants.anchorBlockHeader.globalVariables.blockNumber === 0) {
+        this.#log.warn(
+          `A tx built against a genesis block failed to be included in block 1 which is the only block in which txs built against a genesis block are allowed to be included.`,
+        );
+      }
+      this.#log.verbose(
+        `Rejecting tx ${getTxHash(tx)} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp}, timestamp: ${
+          this.values.timestamp
+        }.`,
+      );
+      return Promise.resolve({ result: 'invalid', reason: [TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP] });
+    } else {
+      return Promise.resolve({ result: 'valid' });
+    }
+  }
+}

package/src/services/discv5/discV5_service.ts

@@ -3,10 +3,10 @@ import { sleep } from '@aztec/foundation/sleep';
 import { type ComponentsVersions, checkCompressedComponentVersion } from '@aztec/stdlib/versioning';
 import { OtelMetricsAdapter, type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
-import { Discv5, type Discv5EventEmitter, type IDiscv5CreateOptions } from '@chainsafe/discv5';
-import { ENR, SignableENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
 import { type Multiaddr, multiaddr } from '@multiformats/multiaddr';
+import { Discv5, type Discv5EventEmitter, type IDiscv5CreateOptions } from '@nethermindeth/discv5';
+import { ENR, SignableENR } from '@nethermindeth/enr';
 import EventEmitter from 'events';
 
 import type { P2PConfig } from '../../config.js';

package/src/services/dummy_service.ts

@@ -3,8 +3,8 @@ import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
 import type { Gossipable, PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
 
-import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
+import type { ENR } from '@nethermindeth/enr';
 import EventEmitter from 'events';
 
 import type { PeerManagerInterface } from './peer-manager/interface.js';

package/src/services/encoding.ts

@@ -1,5 +1,7 @@
 // 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';
 
 import type { RPC } from '@chainsafe/libp2p-gossipsub/message';
 import type { DataTransform } from '@chainsafe/libp2p-gossipsub/types';
@@ -49,31 +51,104 @@ export function getMsgIdFn(message: Message) {
   return sha256(Buffer.concat(vec)).subarray(0, 20);
 }
 
+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,
+  // 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,
+};
+
 /**
  * Snappy transform for libp2p gossipsub
  */
 export class SnappyTransform implements DataTransform {
+  constructor(
+    private maxSizesKb: Record<TopicType, number> = DefaultMaxSizesKb,
+    private defaultMaxSizeKb: number = 10 * 1024,
+    private logger = createLogger('p2p:snappy-transform'),
+  ) {}
+
   // Topic string included to satisfy DataTransform interface
-  inboundTransform(_topicStr: string, data: Uint8Array): Uint8Array {
-    return this.inboundTransformNoTopic(Buffer.from(data));
+  inboundTransform(topicStr: string, data: Uint8Array): Uint8Array {
+    const topic = getTopicFromString(topicStr);
+    return this.inboundTransformData(Buffer.from(data), topic);
   }
 
-  public inboundTransformNoTopic(data: Buffer): Buffer {
+  public inboundTransformData(data: Buffer, topic?: TopicType): Buffer {
     if (data.length === 0) {
       return data;
     }
+    const maxSizeKb = this.maxSizesKb[topic!] ?? this.defaultMaxSizeKb;
+    const { decompressedSize } = readSnappyPreamble(data);
+    if (decompressedSize > maxSizeKb * 1024) {
+      this.logger.warn(`Decompressed size ${decompressedSize} exceeds maximum allowed size of ${maxSizeKb}kb`);
+      throw new Error(`Decompressed size ${decompressedSize} exceeds maximum allowed size of ${maxSizeKb}kb`);
+    }
+
     return Buffer.from(uncompressSync(data, { asBuffer: true }));
   }
 
   // Topic string included to satisfy DataTransform interface
   outboundTransform(_topicStr: string, data: Uint8Array): Uint8Array {
-    return this.outboundTransformNoTopic(Buffer.from(data));
+    return this.outboundTransformData(Buffer.from(data));
   }
 
-  public outboundTransformNoTopic(data: Buffer): Buffer {
+  public outboundTransformData(data: Buffer): Buffer {
     if (data.length === 0) {
       return data;
     }
     return Buffer.from(compressSync(data));
   }
 }
+
+/**
+ * Reads the Snappy preamble from compressed data and returns the expected decompressed size.
+ *
+ * The Snappy format starts with a little-endian varint encoding the uncompressed length.
+ * Varints consist of a series of bytes where:
+ * - Lower 7 bits contain data
+ * - Upper bit (0x80) is set if more bytes follow
+ *
+ * @param data - The compressed data starting with the Snappy preamble
+ * @returns Object containing the decompressed size and the number of bytes read from the preamble
+ * @throws Error if the data is too short or the varint is invalid
+ */
+export function readSnappyPreamble(data: Uint8Array): { decompressedSize: number; bytesRead: number } {
+  if (data.length === 0) {
+    throw new Error('Cannot read preamble from empty data');
+  }
+
+  let result = 0;
+  let shift = 0;
+  let bytesRead = 0;
+
+  // Maximum varint length for 32-bit value is 5 bytes
+  // (7 bits per byte, so 5 bytes = 35 bits, enough for 2^32 - 1)
+  const maxBytes = 5;
+
+  for (let i = 0; i < Math.min(data.length, maxBytes); i++) {
+    const byte = data[i];
+    bytesRead++;
+
+    // Extract lower 7 bits and add to result with appropriate shift
+    // Use >>> 0 to convert to unsigned 32-bit integer to avoid sign issues
+    result = (result | ((byte & 0x7f) << shift)) >>> 0;
+
+    // If upper bit is not set, we're done
+    if ((byte & 0x80) === 0) {
+      return { decompressedSize: result, bytesRead };
+    }
+
+    shift += 7;
+  }
+
+  // If we get here, either we ran out of data or the varint is too long
+  if (bytesRead >= maxBytes) {
+    throw new Error('Varint is too long (max 5 bytes for 32-bit value)');
+  }
+
+  throw new Error('Incomplete varint: data ended before varint termination');
+}

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