@aztec-labs/p2p 6.0.0-nightly.20260829

package/dest/services/gossipsub/topic_score_params.js

@@ -0,0 +1,336 @@
+import { TopicType, createTopicString } from '@aztec-labs/stdlib/p2p';
+import { createTopicScoreParams } from '@chainsafe/libp2p-gossipsub/score';
+/**
+ * Determines the decay window in slots based on expected message frequency.
+ * Low-frequency topics need longer decay windows to accumulate meaningful counter values.
+ *
+ * @param expectedMessagesPerSlot - Expected messages per slot for this topic
+ * @returns Number of slots over which the counter should decay to ~1%
+ */ export function getDecayWindowSlots(expectedMessagesPerSlot) {
+    if (expectedMessagesPerSlot <= 1) {
+        return 5; // Low frequency: decay over 5 slots
+    } else if (expectedMessagesPerSlot <= 10) {
+        return 3; // Medium frequency: decay over 3 slots
+    } else {
+        return 2; // High frequency: decay over 2 slots
+    }
+}
+/**
+ * Computes the decay factor for exponential decay over a given window.
+ * After `heartbeatsInWindow` heartbeats, the counter decays to ~1% of its original value.
+ *
+ * @param heartbeatIntervalMs - Gossipsub heartbeat interval in milliseconds
+ * @param slotDurationMs - L2 slot duration in milliseconds
+ * @param decayWindowSlots - Number of slots over which to decay
+ * @returns Decay factor (0 < decay < 1), applied each heartbeat
+ */ export function computeDecay(heartbeatIntervalMs, slotDurationMs, decayWindowSlots) {
+    const heartbeatsPerSlot = slotDurationMs / heartbeatIntervalMs;
+    const heartbeatsInWindow = heartbeatsPerSlot * decayWindowSlots;
+    // Decay to 1% over the window: decay^heartbeatsInWindow = 0.01
+    // decay = 0.01^(1/heartbeatsInWindow)
+    return Math.pow(0.01, 1 / heartbeatsInWindow);
+}
+/**
+ * Computes the steady-state convergence value for a decaying counter.
+ * If messages arrive at a constant rate and decay is applied each heartbeat,
+ * the counter converges to: rate / (1 - decay)
+ *
+ * @param messagesPerHeartbeat - Expected messages per heartbeat
+ * @param decay - Decay factor applied each heartbeat
+ * @returns Convergence value (steady-state counter value)
+ */ export function computeConvergence(messagesPerHeartbeat, decay) {
+    return messagesPerHeartbeat / (1 - decay);
+}
+/**
+ * Computes a conservative threshold for mesh message deliveries.
+ * The threshold should be low enough to avoid penalizing honest peers with normal variance.
+ *
+ * @param convergence - Steady-state counter value
+ * @param conservativeFactor - Fraction of convergence to use as threshold (e.g., 0.3)
+ * @returns Threshold value
+ */ export function computeThreshold(convergence, conservativeFactor) {
+    return convergence * conservativeFactor;
+}
+/**
+ * Determines the effective expected block proposals per slot for scoring.
+ * Returns undefined if scoring should be disabled, or a positive number if enabled.
+ *
+ * @param blocksPerSlot - Number of blocks per slot from timetable
+ * @param expectedBlockProposalsPerSlot - Config override. 0 disables scoring, undefined falls back to blocksPerSlot - 1.
+ * @returns Positive number of expected block proposals, or undefined if scoring is disabled
+ */ export function getEffectiveBlockProposalsPerSlot(blocksPerSlot, expectedBlockProposalsPerSlot) {
+    if (expectedBlockProposalsPerSlot !== undefined) {
+        return expectedBlockProposalsPerSlot > 0 ? expectedBlockProposalsPerSlot : undefined;
+    }
+    // Fallback: In MBPS mode, N-1 block proposals per slot (last one bundled with checkpoint)
+    // In single block mode (blocksPerSlot=1), this is 0 → disabled
+    const fallback = Math.max(0, blocksPerSlot - 1);
+    return fallback > 0 ? fallback : undefined;
+}
+/**
+ * Gets the expected messages per slot for a given topic type.
+ *
+ * @param topicType - The topic type
+ * @param targetCommitteeSize - Target committee size
+ * @param blocksPerSlot - Number of blocks per slot
+ * @param expectedBlockProposalsPerSlot - Override for block proposals. 0 disables scoring, undefined falls back to blocksPerSlot - 1.
+ * @returns Expected messages per slot, or undefined if unpredictable
+ */ export function getExpectedMessagesPerSlot(topicType, targetCommitteeSize, blocksPerSlot, expectedBlockProposalsPerSlot) {
+    switch(topicType){
+        case TopicType.tx:
+            // Transactions are unpredictable - disable mesh message delivery scoring
+            return undefined;
+        case TopicType.block_proposal:
+            return getEffectiveBlockProposalsPerSlot(blocksPerSlot, expectedBlockProposalsPerSlot);
+        case TopicType.checkpoint_proposal:
+            // Exactly 1 checkpoint proposal per slot
+            return 1;
+        case TopicType.checkpoint_attestation:
+            // Each committee member sends one attestation per slot
+            return targetCommitteeSize;
+        default:
+            return undefined;
+    }
+}
+/** Conservative factor for threshold calculation (30% of convergence) */ const CONSERVATIVE_FACTOR = 0.3;
+/** Number of slots over which invalid message penalty decays */ const INVALID_DECAY_WINDOW_SLOTS = 4;
+/** Weight for invalid message deliveries penalty */ const INVALID_MESSAGE_WEIGHT = -20;
+/** Mesh message deliveries window in milliseconds (5 seconds - balanced for TypeScript runtime) */ const MESH_DELIVERIES_WINDOW_MS = 5000;
+/**
+ * Multiplier for activation time to provide extra grace period during network bootstrap.
+ * The activation timer starts from mesh join time, not from first message received.
+ * During bootstrap, peers may join before messages start flowing, so we need extra time.
+ */ const ACTIVATION_MULTIPLIER = 5;
+// ============================================================================
+// P1 (timeInMesh) Configuration
+// ============================================================================
+// P1 rewards peers for time spent in the mesh. Following Lodestar's approach,
+// we normalize the score so that max P1 = MAX_P1_SCORE after P1_CAP_TIME_SECONDS.
+//
+// Formula: P1 = min(timeInMesh / quantum, cap) * weight
+// - quantum = slotDurationMs (one increment per slot worth of time)
+// - cap = P1_CAP_TIME_SECONDS / slotSeconds (number of slots to reach cap)
+// - weight = MAX_P1_SCORE / cap
+//
+// This ensures: max P1 = cap * weight = MAX_P1_SCORE
+/** Maximum P1 score contribution per topic */ export const MAX_P1_SCORE = 8;
+/** Time in seconds to reach P1 cap (1 hour) */ const P1_CAP_TIME_SECONDS = 3600;
+// ============================================================================
+// P2 (firstMessageDeliveries) Configuration
+// ============================================================================
+// P2 rewards peers who deliver messages first. We normalize so max P2 = MAX_P2_SCORE.
+// P2 uses a decaying counter, so we set the cap based on convergence and scale the weight.
+//
+// Formula: P2 = min(firstMessageDeliveries, cap) * weight
+// - cap = convergence value for first deliveries
+// - weight = MAX_P2_SCORE / cap
+/** Maximum P2 score contribution per topic */ export const MAX_P2_SCORE = 25;
+/** Decay window for first message deliveries in slots (fast decay) */ const P2_DECAY_WINDOW_SLOTS = 2;
+// ============================================================================
+// P3 (meshMessageDeliveries) Configuration
+// ============================================================================
+// P3 penalizes peers who under-deliver messages. For a peer to be pruned from
+// the mesh, their topic score must be negative: P1 + P2 + P3 < 0
+//
+// Therefore, P3 max penalty must exceed (P1 + P2) to cause pruning:
+//   |P3| > P1 + P2
+//   |P3| > 8 + 25 = 33
+//
+// We set P3 max = -34 per topic (slightly more than P1+P2) to ensure pruning.
+// The number of P3-enabled topics depends on config: by default 2 (checkpoint_proposal +
+// checkpoint_attestation), or 3 if block proposal scoring is enabled via
+// expectedBlockProposalsPerSlot. Total P3b after pruning = -68 (2 topics) or -102 (3 topics).
+//
+// With appSpecificWeight=10, ~20 HighTolerance errors (-40 app score) plus max P3b (-68 or -102)
+// would not cross gossipThreshold (-500). This keeps non-contributors from being disconnected
+// unless they also accrue app-level penalties.
+//
+// The weight formula ensures max penalty equals MAX_P3_PENALTY_PER_TOPIC:
+//   weight = MAX_P3_PENALTY_PER_TOPIC / threshold²
+//   When deficit = threshold: penalty = threshold² * weight = MAX_P3_PENALTY_PER_TOPIC
+/** Maximum P3 penalty per topic (must exceed P1 + P2 to cause pruning) */ export const MAX_P3_PENALTY_PER_TOPIC = -(MAX_P1_SCORE + MAX_P2_SCORE + 1); // -34
+/**
+ * Factory class for creating gossipsub topic scoring parameters.
+ * Computes shared values once and reuses them across all topics.
+ */ export class TopicScoreParamsFactory {
+    params;
+    /** Number of blocks per slot based on timetable configuration */ blocksPerSlot;
+    /** Decay factor for invalid message penalties (P4) */ invalidDecay;
+    /** Number of heartbeats per slot */ heartbeatsPerSlot;
+    /** P1: Time in mesh quantum (slot duration in ms - score increases by ~1 per slot) */ timeInMeshQuantum;
+    /** P1: Time in mesh cap (number of slots to reach max score) */ timeInMeshCap;
+    /** P1: Time in mesh weight (normalized so max P1 = MAX_P1_SCORE) */ timeInMeshWeight;
+    /** P2: First message deliveries decay factor */ firstMessageDeliveriesDecay;
+    /** P2: First message deliveries cap (convergence-based) */ firstMessageDeliveriesCap;
+    /** P2: First message deliveries weight (normalized so max P2 = MAX_P2_SCORE) */ firstMessageDeliveriesWeight;
+    /** Base parameters common to all topics */ baseParams;
+    constructor(params){
+        this.params = params;
+        const { slotDurationMs, heartbeatIntervalMs } = params;
+        // Compute values that are the same for all topics. The block count comes straight from the network-wide
+        // max-blocks-per-checkpoint config value.
+        this.blocksPerSlot = params.maxBlocksPerCheckpoint;
+        this.heartbeatsPerSlot = slotDurationMs / heartbeatIntervalMs;
+        this.invalidDecay = computeDecay(heartbeatIntervalMs, slotDurationMs, INVALID_DECAY_WINDOW_SLOTS);
+        // P1: timeInMesh - Lodestar style slot-based normalization
+        // quantum = slot duration, so score increases by ~1 per slot of mesh membership
+        // cap = number of slots in P1_CAP_TIME_SECONDS (1 hour)
+        // weight = MAX_P1_SCORE / cap, so max P1 = cap * weight = MAX_P1_SCORE
+        const slotDurationSeconds = slotDurationMs / 1000;
+        this.timeInMeshQuantum = slotDurationMs;
+        this.timeInMeshCap = P1_CAP_TIME_SECONDS / slotDurationSeconds;
+        this.timeInMeshWeight = MAX_P1_SCORE / this.timeInMeshCap;
+        // P2: firstMessageDeliveries - convergence-based cap with normalized weight
+        // Uses fast decay (2 slots) so it rewards recent first deliveries
+        // cap = convergence at 1 first delivery per heartbeat (theoretical max rate)
+        // weight = MAX_P2_SCORE / cap, so max P2 = cap * weight = MAX_P2_SCORE
+        this.firstMessageDeliveriesDecay = computeDecay(heartbeatIntervalMs, slotDurationMs, P2_DECAY_WINDOW_SLOTS);
+        // Convergence for 1 message per heartbeat (generous estimate for first deliveries)
+        this.firstMessageDeliveriesCap = computeConvergence(1, this.firstMessageDeliveriesDecay);
+        this.firstMessageDeliveriesWeight = MAX_P2_SCORE / this.firstMessageDeliveriesCap;
+        // Base params are identical for all topics
+        this.baseParams = {
+            topicWeight: 1,
+            invalidMessageDeliveriesWeight: INVALID_MESSAGE_WEIGHT,
+            invalidMessageDeliveriesDecay: this.invalidDecay,
+            // P1: timeInMesh (same for all topics)
+            timeInMeshQuantum: this.timeInMeshQuantum,
+            timeInMeshCap: this.timeInMeshCap,
+            timeInMeshWeight: this.timeInMeshWeight,
+            // P2: firstMessageDeliveries (same for all topics)
+            firstMessageDeliveriesDecay: this.firstMessageDeliveriesDecay,
+            firstMessageDeliveriesCap: this.firstMessageDeliveriesCap,
+            firstMessageDeliveriesWeight: this.firstMessageDeliveriesWeight
+        };
+    }
+    /**
+   * Creates scoring parameters for topics with unpredictable or zero message rates.
+   * Disables P1, P2, P3, and P3b to avoid unbalanced positive score accumulation.
+   *
+   * Rationale: If P1/P2 were enabled without P3, the topic would contribute free
+   * positive scores that could offset penalties from other topics, preventing
+   * proper mesh pruning of non-contributing peers.
+   */ createDisabledP3Params() {
+        return createTopicScoreParams({
+            topicWeight: 1,
+            // P1: timeInMesh - disabled (no free positive scores)
+            timeInMeshQuantum: 1,
+            timeInMeshCap: 0,
+            timeInMeshWeight: 0,
+            // P2: firstMessageDeliveries - disabled
+            firstMessageDeliveriesDecay: 0.5,
+            firstMessageDeliveriesCap: 0,
+            firstMessageDeliveriesWeight: 0,
+            // P3: meshMessageDeliveries - disabled
+            meshMessageDeliveriesWeight: 0,
+            meshMessageDeliveriesDecay: 0.5,
+            meshMessageDeliveriesThreshold: 0,
+            meshMessageDeliveriesWindow: 0,
+            meshMessageDeliveriesActivation: 0,
+            meshMessageDeliveriesCap: 0,
+            // P3b: meshFailurePenalty - disabled
+            meshFailurePenaltyWeight: 0,
+            meshFailurePenaltyDecay: 0.5,
+            // P4: invalidMessageDeliveries - still enabled for attack detection
+            invalidMessageDeliveriesWeight: INVALID_MESSAGE_WEIGHT,
+            invalidMessageDeliveriesDecay: this.invalidDecay
+        });
+    }
+    /**
+   * Creates scoring parameters for topics with predictable message rates.
+   * Enables P1, P2, P3, and P3b for balanced scoring.
+   *
+   * The scoring is designed so that:
+   * - P1 + P2 max = 8 + 25 = 33 (positive rewards for good behavior)
+   * - P3 max = -34 (penalty exceeds P1+P2 to ensure pruning of non-contributors)
+   * - After pruning: P1 resets, P2 decays, P3b persists with slow decay
+   *
+   * @param expectedPerSlot - Expected messages per slot
+   */ createEnabledP3Params(expectedPerSlot) {
+        const { slotDurationMs, heartbeatIntervalMs } = this.params;
+        // Calculate decay based on message frequency
+        const decayWindowSlots = getDecayWindowSlots(expectedPerSlot);
+        const decay = computeDecay(heartbeatIntervalMs, slotDurationMs, decayWindowSlots);
+        // Calculate convergence and threshold
+        const messagesPerHeartbeat = expectedPerSlot / this.heartbeatsPerSlot;
+        const convergence = computeConvergence(messagesPerHeartbeat, decay);
+        const threshold = computeThreshold(convergence, CONSERVATIVE_FACTOR);
+        // Cap factor: higher for high-volume topics
+        const capFactor = expectedPerSlot > 10 ? 8 : 4;
+        // P3 Weight: scaled so max penalty = MAX_P3_PENALTY_PER_TOPIC (-34)
+        // When deficit = threshold (peer delivers nothing):
+        //   penalty = deficit² × weight = threshold² × (MAX_P3_PENALTY_PER_TOPIC / threshold²) = MAX_P3_PENALTY_PER_TOPIC
+        const meshDeliveriesWeight = threshold > 0 ? MAX_P3_PENALTY_PER_TOPIC / (threshold * threshold) : 0;
+        // Activation time: use the decay window multiplied by ACTIVATION_MULTIPLIER for extra grace
+        // during network bootstrap. The timer starts from mesh join time, not from first message,
+        // so peers joining before messages flow need extra time to accumulate counter values.
+        const activationMs = slotDurationMs * decayWindowSlots * ACTIVATION_MULTIPLIER;
+        return createTopicScoreParams({
+            ...this.baseParams,
+            // P3: meshMessageDeliveries
+            meshMessageDeliveriesWeight: meshDeliveriesWeight,
+            meshMessageDeliveriesDecay: decay,
+            meshMessageDeliveriesThreshold: threshold,
+            meshMessageDeliveriesWindow: MESH_DELIVERIES_WINDOW_MS,
+            meshMessageDeliveriesActivation: activationMs,
+            meshMessageDeliveriesCap: Math.max(threshold * capFactor, 2),
+            // P3b: meshFailurePenalty (same weight and decay as P3)
+            meshFailurePenaltyWeight: meshDeliveriesWeight,
+            meshFailurePenaltyDecay: decay
+        });
+    }
+    /** Number of topics with P3 enabled, computed from config. Always 2 (checkpoint_proposal + checkpoint_attestation) plus optionally block_proposal. */ get numP3EnabledTopics() {
+        const blockProposalP3Enabled = getEffectiveBlockProposalsPerSlot(this.blocksPerSlot, this.params.expectedBlockProposalsPerSlot) !== undefined;
+        return blockProposalP3Enabled ? 3 : 2;
+    }
+    /** Total maximum P3b penalty across all topics after pruning, computed from config */ get totalMaxP3bPenalty() {
+        return MAX_P3_PENALTY_PER_TOPIC * this.numP3EnabledTopics;
+    }
+    /**
+   * Creates topic score parameters for a specific topic type.
+   *
+   * @param topicType - The topic type
+   * @returns TopicScoreParams for the topic
+   */ createForTopic(topicType) {
+        const expectedPerSlot = getExpectedMessagesPerSlot(topicType, this.params.targetCommitteeSize, this.blocksPerSlot, this.params.expectedBlockProposalsPerSlot);
+        // For unpredictable topics (tx) or topics with 0 expected messages, disable P3/P3b
+        if (expectedPerSlot === undefined || expectedPerSlot === 0) {
+            return this.createDisabledP3Params();
+        }
+        return this.createEnabledP3Params(expectedPerSlot);
+    }
+    /**
+   * Creates all topic score parameters for gossipsub configuration.
+   *
+   * @param protocolVersion - Protocol version string for topic naming
+   * @returns Record mapping topic strings to their score parameters
+   */ createAll(protocolVersion) {
+        const topics = {};
+        for (const topicType of Object.values(TopicType)){
+            const topicString = createTopicString(topicType, protocolVersion);
+            topics[topicString] = this.createForTopic(topicType);
+        }
+        return topics;
+    }
+}
+/**
+ * Creates topic score parameters for a specific topic type.
+ * Convenience function that creates a factory internally.
+ *
+ * @param topicType - The topic type
+ * @param params - Network parameters for scoring calculation
+ * @returns TopicScoreParams for the topic
+ */ export function createTopicScoreParamsForTopic(topicType, params) {
+    const factory = new TopicScoreParamsFactory(params);
+    return factory.createForTopic(topicType);
+}
+/**
+ * Creates all topic score parameters for gossipsub configuration.
+ *
+ * @param protocolVersion - Protocol version string for topic naming
+ * @param params - Network parameters for scoring calculation
+ * @returns Record mapping topic strings to their score parameters
+ */ export function createAllTopicScoreParams(protocolVersion, params) {
+    const factory = new TopicScoreParamsFactory(params);
+    return factory.createAll(protocolVersion);
+}

package/dest/services/index.d.ts

@@ -0,0 +1,8 @@
+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_file_store/index.js';
+export * from './tx_collection/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYywwQkFBMEIsQ0FBQyJ9

package/dest/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC"}

package/dest/services/index.js

@@ -0,0 +1,7 @@
+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_file_store/index.js';
+export * from './tx_collection/index.js';

package/dest/services/libp2p/instrumentation.d.ts

@@ -0,0 +1,25 @@
+import type { Timer } from '@aztec-labs/foundation/timer';
+import { TopicType } from '@aztec-labs/stdlib/p2p';
+import { type TelemetryClient } from '@aztec-labs/telemetry-client';
+export declare class P2PInstrumentation {
+    private messageValidationDuration;
+    private messagePrevalidationCount;
+    private messageLatency;
+    private txReceivedCount;
+    private slowValidationCount;
+    private txValidationStageDuration;
+    private aggLatencyHisto;
+    private aggValidationHisto;
+    private aggLatencyMetrics;
+    private aggValidationMetrics;
+    constructor(client: TelemetryClient, name: string);
+    recordMessageValidation(topicName: TopicType, timerOrMs: Timer | number): void;
+    incrementTxReceived(count: number): void;
+    incSlowValidation(topicName: TopicType): void;
+    /** Records the duration of a single stage of gossiped tx validation. */
+    recordTxValidationStage(stage: string, ms: number): void;
+    incMessagePrevalidationStatus(passed: boolean, topicName: TopicType | undefined): void;
+    recordMessageLatency(topicName: TopicType, timerOrMs: Timer | number): void;
+    private aggregate;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zdHJ1bWVudGF0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VydmljZXMvbGlicDJwL2luc3RydW1lbnRhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUMxRCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDbkQsT0FBTyxFQU1MLEtBQUssZUFBZSxFQUdyQixNQUFNLDhCQUE4QixDQUFDO0FBR3RDLHFCQUFhLGtCQUFrQjtJQUM3QixPQUFPLENBQUMseUJBQXlCLENBQVk7SUFDN0MsT0FBTyxDQUFDLHlCQUF5QixDQUFnQjtJQUNqRCxPQUFPLENBQUMsY0FBYyxDQUFZO0lBQ2xDLE9BQU8sQ0FBQyxlQUFlLENBQWdCO0lBQ3ZDLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBZ0I7SUFDM0MsT0FBTyxDQUFDLHlCQUF5QixDQUFZO0lBRTdDLE9BQU8sQ0FBQyxlQUFlLENBQTZDO0lBQ3BFLE9BQU8sQ0FBQyxrQkFBa0IsQ0FBNkM7SUFFdkUsT0FBTyxDQUFDLGlCQUFpQixDQUFpRTtJQUMxRixPQUFPLENBQUMsb0JBQW9CLENBQWlFO0lBRTdGLFlBQVksTUFBTSxFQUFFLGVBQWUsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQXNEaEQ7SUFFTSx1QkFBdUIsQ0FBQyxTQUFTLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxLQUFLLEdBQUcsTUFBTSxRQVc3RTtJQUVNLG1CQUFtQixDQUFDLEtBQUssRUFBRSxNQUFNLFFBRXZDO0lBRU0saUJBQWlCLENBQUMsU0FBUyxFQUFFLFNBQVMsUUFFNUM7SUFFRCx3RUFBd0U7SUFDakUsdUJBQXVCLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsTUFBTSxRQUV2RDtJQUVNLDZCQUE2QixDQUFDLE1BQU0sRUFBRSxPQUFPLEVBQUUsU0FBUyxFQUFFLFNBQVMsR0FBRyxTQUFTLFFBRXJGO0lBRU0sb0JBQW9CLENBQUMsU0FBUyxFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQUUsS0FBSyxHQUFHLE1BQU0sUUFXMUU7SUFFRCxPQUFPLENBQUMsU0FBUyxDQWtCZjtDQUNIIn0=

package/dest/services/libp2p/instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../src/services/libp2p/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAML,KAAK,eAAe,EAGrB,MAAM,8BAA8B,CAAC;AAGtC,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,yBAAyB,CAAY;IAC7C,OAAO,CAAC,yBAAyB,CAAgB;IACjD,OAAO,CAAC,cAAc,CAAY;IAClC,OAAO,CAAC,eAAe,CAAgB;IACvC,OAAO,CAAC,mBAAmB,CAAgB;IAC3C,OAAO,CAAC,yBAAyB,CAAY;IAE7C,OAAO,CAAC,eAAe,CAA6C;IACpE,OAAO,CAAC,kBAAkB,CAA6C;IAEvE,OAAO,CAAC,iBAAiB,CAAiE;IAC1F,OAAO,CAAC,oBAAoB,CAAiE;IAE7F,YAAY,MAAM,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,EAsDhD;IAEM,uBAAuB,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,GAAG,MAAM,QAW7E;IAEM,mBAAmB,CAAC,KAAK,EAAE,MAAM,QAEvC;IAEM,iBAAiB,CAAC,SAAS,EAAE,SAAS,QAE5C;IAED,wEAAwE;IACjE,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAEvD;IAEM,6BAA6B,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,GAAG,SAAS,QAErF;IAEM,oBAAoB,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,GAAG,MAAM,QAW1E;IAED,OAAO,CAAC,SAAS,CAkBf;CACH"}

package/dest/services/libp2p/instrumentation.js

@@ -0,0 +1,143 @@
+import { TopicType } from '@aztec-labs/stdlib/p2p';
+import { Attributes, Metrics, createUpDownCounterWithDefault } from '@aztec-labs/telemetry-client';
+import { createHistogram } from 'node:perf_hooks';
+export class P2PInstrumentation {
+    messageValidationDuration;
+    messagePrevalidationCount;
+    messageLatency;
+    txReceivedCount;
+    slowValidationCount;
+    txValidationStageDuration;
+    aggLatencyHisto = new Map();
+    aggValidationHisto = new Map();
+    aggLatencyMetrics;
+    aggValidationMetrics;
+    constructor(client, name){
+        const meter = client.getMeter(name);
+        this.messageValidationDuration = meter.createHistogram(Metrics.P2P_GOSSIP_MESSAGE_VALIDATION_DURATION);
+        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);
+        this.txValidationStageDuration = meter.createHistogram(Metrics.P2P_GOSSIP_TX_VALIDATION_STAGE_DURATION);
+        this.txReceivedCount = createUpDownCounterWithDefault(meter, Metrics.P2P_GOSSIP_TX_RECEIVED_COUNT);
+        this.slowValidationCount = createUpDownCounterWithDefault(meter, Metrics.P2P_GOSSIP_SLOW_VALIDATION_COUNT, {
+            [Attributes.TOPIC_NAME]: [
+                TopicType.tx,
+                TopicType.block_proposal,
+                TopicType.checkpoint_proposal,
+                TopicType.checkpoint_attestation
+            ]
+        });
+        this.aggLatencyMetrics = {
+            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),
+            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, [
+            ...Object.values(this.aggValidationMetrics),
+            ...Object.values(this.aggLatencyMetrics)
+        ]);
+    }
+    recordMessageValidation(topicName, timerOrMs) {
+        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));
+    }
+    incrementTxReceived(count) {
+        this.txReceivedCount.add(count);
+    }
+    incSlowValidation(topicName) {
+        this.slowValidationCount.add(1, {
+            [Attributes.TOPIC_NAME]: topicName
+        });
+    }
+    /** Records the duration of a single stage of gossiped tx validation. */ recordTxValidationStage(stage, ms) {
+        this.txValidationStageDuration.record(Math.ceil(ms), {
+            [Attributes.TX_VALIDATION_STAGE]: stage
+        });
+    }
+    incMessagePrevalidationStatus(passed, topicName) {
+        this.messagePrevalidationCount.add(1, {
+            [Attributes.TOPIC_NAME]: topicName,
+            [Attributes.OK]: passed
+        });
+    }
+    recordMessageLatency(topicName, timerOrMs) {
+        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: 60 * 1000
+            }); // Max: 1 minute
+            this.aggLatencyHisto.set(topicName, latencyHistogram);
+        }
+        latencyHistogram.record(Math.max(ms, 1));
+    }
+    aggregate = (res)=>{
+        for (const [metrics, histograms] of [
+            [
+                this.aggLatencyMetrics,
+                this.aggLatencyHisto
+            ],
+            [
+                this.aggValidationMetrics,
+                this.aggValidationHisto
+            ]
+        ]){
+            for (const topicName of Object.values(TopicType)){
+                const histogram = histograms.get(topicName);
+                if (!histogram || histogram.count === 0) {
+                    continue;
+                }
+                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
+                });
+            }
+        }
+    };
+}