@aztec/p2p 0.0.0-test.0 → 0.0.1-commit.24de95ac

package/src/services/encoding.ts

@@ -1,5 +1,7 @@
 // Taken from lodestar: https://github.com/ChainSafe/lodestar
 import { sha256 } from '@aztec/foundation/crypto';
+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/index.ts

@@ -1,2 +1,6 @@
 export * from './service.js';
 export * from './libp2p/libp2p_service.js';
+export * from './tx_provider.js';
+export * from './dummy_service.js';
+export * from './reqresp/index.js';
+export * from './tx_collection/index.js';

package/src/services/libp2p/instrumentation.ts

@@ -0,0 +1,158 @@
+import type { Timer } from '@aztec/foundation/timer';
+import { TopicType } from '@aztec/stdlib/p2p';
+import {
+  Attributes,
+  type BatchObservableResult,
+  type Histogram,
+  Metrics,
+  type ObservableGauge,
+  type TelemetryClient,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+import { type RecordableHistogram, createHistogram } from 'node:perf_hooks';
+
+export class P2PInstrumentation {
+  private messageValidationDuration: Histogram;
+  private messagePrevalidationCount: UpDownCounter;
+  private messageLatency: Histogram;
+
+  private aggLatencyHisto = new Map<TopicType, RecordableHistogram>();
+  private aggValidationHisto = new Map<TopicType, RecordableHistogram>();
+
+  private aggLatencyMetrics: Record<'min' | 'max' | 'p50' | 'p90' | 'avg', ObservableGauge>;
+  private aggValidationMetrics: Record<'min' | 'max' | 'p50' | 'p90' | 'avg', ObservableGauge>;
+
+  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.messagePrevalidationCount = meter.createUpDownCounter(Metrics.P2P_GOSSIP_MESSAGE_PREVALIDATION_COUNT, {
+      description: 'How many message pass/fail prevalidation',
+      valueType: ValueType.INT,
+    });
+
+    this.messageLatency = meter.createHistogram(Metrics.P2P_GOSSIP_MESSAGE_LATENCY, {
+      unit: 'ms',
+      description: 'P2P message latency',
+      valueType: ValueType.INT,
+    });
+
+    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',
+      }),
+    };
+
+    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',
+      }),
+    };
+
+    meter.addBatchObservableCallback(this.aggregate, [
+      ...Object.values(this.aggValidationMetrics),
+      ...Object.values(this.aggLatencyMetrics),
+    ]);
+  }
+
+  public recordMessageValidation(topicName: TopicType, timerOrMs: Timer | number) {
+    const ms = Math.ceil(typeof timerOrMs === 'number' ? timerOrMs : timerOrMs.ms());
+    this.messageValidationDuration.record(ms, { [Attributes.TOPIC_NAME]: topicName });
+
+    let validationHistogram = this.aggValidationHisto.get(topicName);
+    if (!validationHistogram) {
+      validationHistogram = createHistogram({ min: 1, max: 5 * 60 * 1000 }); // 5 mins
+      this.aggValidationHisto.set(topicName, validationHistogram);
+    }
+
+    validationHistogram.record(Math.max(ms, 1));
+  }
+
+  public incMessagePrevalidationStatus(passed: boolean, topicName: TopicType | undefined) {
+    this.messagePrevalidationCount.add(1, { [Attributes.TOPIC_NAME]: topicName, [Attributes.OK]: passed });
+  }
+
+  public recordMessageLatency(topicName: TopicType, timerOrMs: Timer | number) {
+    const ms = Math.ceil(typeof timerOrMs === 'number' ? timerOrMs : timerOrMs.ms());
+    this.messageLatency.record(ms, { [Attributes.TOPIC_NAME]: topicName });
+
+    let latencyHistogram = this.aggLatencyHisto.get(topicName);
+    if (!latencyHistogram) {
+      latencyHistogram = createHistogram({ min: 1, max: 24 * 60 * 60 * 1000 }); // 24hrs
+      this.aggLatencyHisto.set(topicName, latencyHistogram);
+    }
+
+    latencyHistogram.record(Math.max(ms, 1));
+  }
+
+  private aggregate = (res: BatchObservableResult) => {
+    for (const [metrics, histograms] of [
+      [this.aggLatencyMetrics, this.aggLatencyHisto],
+      [this.aggValidationMetrics, this.aggValidationHisto],
+    ] as const) {
+      for (const topicName of Object.values(TopicType)) {
+        const histogram = histograms.get(topicName);
+        if (!histogram || histogram.count === 0) {
+          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 });
+      }
+    }
+  };
+}