@aztec/p2p 0.0.1-commit.6d63667d → 0.0.1-commit.71324e566

package/dest/services/gossipsub/topic_score_params.js

@@ -0,0 +1,363 @@
+import { TopicType, createTopicString } from '@aztec/stdlib/p2p';
+import { createCheckpointTimingModel } from '@aztec/stdlib/timetable';
+import { createTopicScoreParams } from '@chainsafe/libp2p-gossipsub/score';
+/**
+ * Calculates the number of blocks per slot based on timing parameters.
+ * Uses the shared calculation from @aztec/stdlib/timetable.
+ *
+ * @param slotDurationMs - L2 slot duration in milliseconds
+ * @param blockDurationMs - Duration per block in milliseconds (undefined = single block mode)
+ * @param opts - Shared checkpoint timing inputs used by the sequencer and validators
+ * @returns Number of blocks per slot
+ */ export function calculateBlocksPerSlot(slotDurationMs, blockDurationMs, opts) {
+    if (!opts) {
+        return createCheckpointTimingModel({
+            aztecSlotDuration: slotDurationMs / 1000,
+            blockDuration: blockDurationMs ? blockDurationMs / 1000 : undefined
+        }).calculateMaxBlocksPerSlot();
+    }
+    return createCheckpointTimingModel({
+        aztecSlotDuration: slotDurationMs / 1000,
+        ethereumSlotDuration: opts.ethereumSlotDuration,
+        blockDuration: blockDurationMs ? blockDurationMs / 1000 : undefined,
+        l1PublishingTime: opts.l1PublishingTime ?? opts.ethereumSlotDuration,
+        p2pPropagationTime: opts.p2pPropagationTime
+    }).calculateMaxBlocksPerSlot();
+}
+/**
+ * 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, blockDurationMs } = params;
+        // Compute values that are the same for all topics
+        this.blocksPerSlot = calculateBlocksPerSlot(slotDurationMs, blockDurationMs, {
+            ethereumSlotDuration: params.ethereumSlotDuration,
+            l1PublishingTime: params.l1PublishingTime,
+            p2pPropagationTime: params.p2pPropagationTime
+        });
+        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/libp2p/libp2p_service.d.ts

@@ -1,42 +1,46 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { BlockNumber, type SlotNumber } from '@aztec/foundation/branded-types';
 import { type Logger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { EthAddress, L2BlockSource } from '@aztec/stdlib/block';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { ClientProtocolCircuitVerifier, PeerInfo, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { BlockProposal, CheckpointAttestation, CheckpointProposal, type Gossipable, P2PClientType, type ValidationResult as P2PValidationResult, TopicType } from '@aztec/stdlib/p2p';
-import { Tx } from '@aztec/stdlib/tx';
+import { BlockProposal, CheckpointAttestation, CheckpointProposal, type CheckpointProposalCore, type Gossipable, PeerErrorSeverity, TopicType } from '@aztec/stdlib/p2p';
+import { Tx, type TxValidator } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
 import { type TelemetryClient, WithTracer } from '@aztec/telemetry-client';
 import { type Message, type PeerId, TopicValidatorResult } from '@libp2p/interface';
 import { ENR } from '@nethermindeth/enr';
 import type { P2PConfig } from '../../config.js';
-import type { MemPools } from '../../mem_pools/index.js';
+import type { MemPools } from '../../mem_pools/interface.js';
+import { type TransactionValidator } from '../../msg_validators/tx_validator/factory.js';
 import { type PubSubLibp2p } from '../../util.js';
 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 ReqRespInterface, type ReqRespResponse, ReqRespSubProtocol, type ReqRespSubProtocolHandler, type ReqRespSubProtocolValidators, type SubProtocolMap } from '../reqresp/index.js';
-import { AuthRequest, StatusMessage } from '../reqresp/index.js';
-import type { P2PBlockReceivedCallback, P2PCheckpointReceivedCallback, P2PService, PeerDiscoveryService } from '../service.js';
-type ReceivedMessageValidationResult<T> = {
+import { AuthRequest, BlockTxsRequest, BlockTxsResponse, type ReqRespInterface, type ReqRespResponse, ReqRespSubProtocol, type ReqRespSubProtocolHandler, type ReqRespSubProtocolValidators, StatusMessage, type SubProtocolMap } from '../reqresp/index.js';
+import type { P2PBlockReceivedCallback, P2PCheckpointReceivedCallback, P2PDuplicateAttestationCallback, P2PService, PeerDiscoveryService } from '../service.js';
+type ReceivedMessageValidationResult<T, M = undefined> = {
     obj: T;
     result: Exclude<TopicValidatorResult, TopicValidatorResult.Reject>;
+    metadata?: M;
 } | {
-    obj?: undefined;
+    obj?: T;
     result: TopicValidatorResult.Reject;
+    metadata?: M;
+    severity: PeerErrorSeverity;
 };
 /**
  * Lib P2P implementation of the P2PService interface.
  */
-export declare class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends WithTracer implements P2PService {
-    private clientType;
+export declare class LibP2PService extends WithTracer implements P2PService {
     private config;
     protected node: PubSubLibp2p;
     private peerDiscoveryService;
     private reqresp;
-    private peerManager;
+    protected peerManager: PeerManagerInterface;
     protected mempools: MemPools;
-    private archiver;
+    protected archiver: L2BlockSource & ContractDataSource;
     private epochCache;
     private proofVerifier;
     private worldStateSynchronizer;
@@ -48,6 +52,10 @@ export declare class LibP2PService<T extends P2PClientType = P2PClientType.Full>
     private protocolVersion;
     private topicStrings;
     private feesCache;
+    /** Callback invoked when a duplicate proposal is detected (triggers slashing). */
+    private duplicateProposalCallback?;
+    /** Callback invoked when a duplicate attestation is detected (triggers slashing). */
+    private duplicateAttestationCallback?;
     /**
      * Callback for when a block is received from a peer.
      * @param block - The block received from the peer.
@@ -59,12 +67,18 @@ export declare class LibP2PService<T extends P2PClientType = P2PClientType.Full>
      * @param checkpoint - The checkpoint proposal received from the peer.
      * @returns The attestations for the checkpoint, if any.
      */
-    private checkpointReceivedCallback;
+    private allNodesCheckpointReceivedCallback;
+    /**
+     * Callback for when a checkpoint proposal is received - specifically for validators - from a peer.
+     * @param checkpoint - The checkpoint proposal received from the peer.
+     * @returns The attestations for the checkpoint, if any.
+     */
+    private validatorCheckpointReceivedCallback;
     private gossipSubEventHandler;
     private instrumentation;
     private telemetry;
     protected logger: Logger;
-    constructor(clientType: T, config: P2PConfig, node: PubSubLibp2p, peerDiscoveryService: PeerDiscoveryService, reqresp: ReqRespInterface, peerManager: PeerManagerInterface, mempools: MemPools, archiver: L2BlockSource & ContractDataSource, epochCache: EpochCacheInterface, proofVerifier: ClientProtocolCircuitVerifier, worldStateSynchronizer: WorldStateSynchronizer, telemetry: TelemetryClient, logger?: Logger);
+    constructor(config: P2PConfig, node: PubSubLibp2p, peerDiscoveryService: PeerDiscoveryService, reqresp: ReqRespInterface, peerManager: PeerManagerInterface, mempools: MemPools, archiver: L2BlockSource & ContractDataSource, epochCache: EpochCacheInterface, proofVerifier: ClientProtocolCircuitVerifier, worldStateSynchronizer: WorldStateSynchronizer, telemetry: TelemetryClient, logger?: Logger);
     updateConfig(config: Partial<P2PReqRespConfig>): void;
     /**
      * Creates an instance of the LibP2P service.
@@ -72,7 +86,7 @@ export declare class LibP2PService<T extends P2PClientType = P2PClientType.Full>
      * @param txPool - The transaction pool to be accessed by the service.
      * @returns The new service.
      */
-    static new<T extends P2PClientType>(clientType: T, config: P2PConfig, peerId: PeerId, deps: {
+    static new(config: P2PConfig, peerId: PeerId, deps: {
         mempools: MemPools;
         l2BlockSource: L2BlockSource & ContractDataSource;
         epochCache: EpochCacheInterface;
@@ -82,7 +96,7 @@ export declare class LibP2PService<T extends P2PClientType = P2PClientType.Full>
         telemetry: TelemetryClient;
         logger: Logger;
         packageVersion: string;
-    }): Promise<LibP2PService<T>>;
+    }): Promise<LibP2PService>;
     /**
      * Starts the LibP2P service.
      * @returns An empty promise.
@@ -96,6 +110,7 @@ export declare class LibP2PService<T extends P2PClientType = P2PClientType.Full>
     addReqRespSubProtocol(subProtocol: ReqRespSubProtocol, handler: ReqRespSubProtocolHandler, validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol]): Promise<void>;
     registerThisValidatorAddresses(address: EthAddress[]): void;
     getPeers(includePending?: boolean): PeerInfo[];
+    getGossipMeshPeerCount(topicType: TopicType): number;
     private handleGossipSubEvent;
     /**
      * Send a batch of requests to peers, and return the responses
@@ -111,7 +126,24 @@ export declare class LibP2PService<T extends P2PClientType = P2PClientType.Full>
      */
     getEnr(): ENR | undefined;
     registerBlockReceivedCallback(callback: P2PBlockReceivedCallback): void;
-    registerCheckpointReceivedCallback(callback: P2PCheckpointReceivedCallback): void;
+    registerValidatorCheckpointReceivedCallback(callback: P2PCheckpointReceivedCallback): void;
+    registerAllNodesCheckpointReceivedCallback(callback: P2PCheckpointReceivedCallback): void;
+    notifyOwnCheckpointProposal(checkpoint: CheckpointProposalCore): Promise<void>;
+    /**
+     * Registers a callback to be invoked when a duplicate proposal is detected.
+     * This callback is triggered on the first duplicate (when count goes from 1 to 2).
+     */
+    registerDuplicateProposalCallback(callback: (info: {
+        slot: SlotNumber;
+        proposer: EthAddress;
+        type: 'checkpoint' | 'block';
+    }) => void): void;
+    /**
+     * Registers a callback to be invoked when a duplicate attestation is detected.
+     * A validator signing attestations for different proposals at the same slot.
+     * This callback is triggered on the first duplicate (when count goes from 1 to 2).
+     */
+    registerDuplicateAttestationCallback(callback: P2PDuplicateAttestationCallback): void;
     /**
      * Subscribes to a topic.
      * @param topic - The topic to subscribe to.
@@ -141,58 +173,68 @@ export declare class LibP2PService<T extends P2PClientType = P2PClientType.Full>
      * @param data - The message data
      */
     protected handleNewGossipMessage(msg: Message, msgId: string, source: PeerId): Promise<void>;
-    protected validateReceivedMessage<T>(validationFunc: () => Promise<ReceivedMessageValidationResult<T>>, msgId: string, source: PeerId, topicType: TopicType): Promise<ReceivedMessageValidationResult<T>>;
+    protected validateReceivedMessage<T, M = undefined>(validationFunc: () => Promise<ReceivedMessageValidationResult<T, M>>, msgId: string, source: PeerId, topicType: TopicType): Promise<ReceivedMessageValidationResult<T, M>>;
+    private tryDeserialize;
     protected handleGossipedTx(payloadData: Buffer, msgId: string, source: PeerId): Promise<void>;
     private processCheckpointAttestationFromPeer;
-    private processBlockFromPeer;
-    private processValidBlockProposal;
-    private handleGossipedCheckpointProposal;
-    private processValidCheckpointProposal;
+    /** Validates a checkpoint attestation and adds it to the pool. Penalizes the peer if validation fails. */
+    protected validateAndStoreCheckpointAttestation(peerId: PeerId, attestation: CheckpointAttestation): Promise<ReceivedMessageValidationResult<CheckpointAttestation>>;
+    protected processBlockFromPeer(payloadData: Buffer, msgId: string, source: PeerId): Promise<void>;
+    /** Validates a block proposal. Triggers a penalization to the peer that sent it if invalid. Adds to the mempool if valid. */
+    protected validateAndStoreBlockProposal(peerId: PeerId, block: BlockProposal): Promise<ReceivedMessageValidationResult<BlockProposal, {
+        isEquivocated: boolean;
+    }>>;
+    protected processValidBlockProposal(block: BlockProposal, sender: PeerId): Promise<void>;
+    /**
+     * Handle a gossiped checkpoint proposal.
+     * Validates and processes the checkpoint proposal, then triggers the callback for attestation.
+     */
+    protected handleGossipedCheckpointProposal(payloadData: Buffer, msgId: string, source: PeerId): Promise<void>;
+    /**
+     * Validates a checkpoint proposal. Penalizes peer if validation fails. Adds the checkpoint and
+     * its last block (if present) to the mempool if valid. Triggers equivocation detection on both.
+     */
+    protected validateAndStoreCheckpointProposal(peerId: PeerId, checkpoint: CheckpointProposal): Promise<ReceivedMessageValidationResult<CheckpointProposal, {
+        isEquivocated: boolean;
+        processBlock: boolean;
+    }>>;
+    /**
+     * Process a validated checkpoint proposal.
+     * Note: The proposal was already added to the pool by tryAddCheckpointProposal in handleGossipedCheckpointProposal.
+     */
+    protected processValidCheckpointProposal(checkpoint: CheckpointProposalCore, sender: PeerId): Promise<void>;
     /**
      * Propagates provided message to peers.
      * @param message - The message to propagate.
      */
     propagate<T extends Gossipable>(message: T): Promise<void>;
-    private validateRequestedBlockTxs;
+    /**
+     * Validate the requested block transactions. Allow partial returns.
+     * @param request - The block transactions request.
+     * @param response - The block transactions response.
+     * @param peerId - The ID of the peer that made the request.
+     * @returns True if the requested block transactions are valid, false otherwise.
+     */
+    protected validateRequestedBlockTxs(request: BlockTxsRequest, response: BlockTxsResponse, peerId: PeerId): Promise<boolean>;
     private validateRequestedTxs;
-    private validateRequestedBlock;
-    private validateRequestedTx;
-    private createRequestedTxValidator;
-    private validatePropagatedTx;
+    protected validateRequestedTx(tx: Tx, peerId: PeerId, txValidator: TxValidator, requested?: Set<`0x${string}`>): Promise<void>;
+    protected createRequestedTxValidator(): TxValidator;
     private getGasFees;
     /**
      * Get the BatchTxRequesterLibP2PService dependencies for creating BatchTxRequester instances
      */
     getBatchTxRequesterService(): BatchTxRequesterLibP2PService;
-    validate(txs: Tx[]): Promise<void>;
-    private createMessageValidators;
+    validateTxsReceivedInBlockProposal(txs: Tx[]): Promise<void>;
+    /** Creates the first stage (fast) validators for gossiped transactions. */
+    protected createFirstStageMessageValidators(currentBlockNumber: BlockNumber, nextSlotTimestamp: UInt64): Promise<Record<string, TransactionValidator>>;
+    /** Creates the second stage (expensive proof verification) validators for gossiped transactions. */
+    protected createSecondStageMessageValidators(): Record<string, TransactionValidator>;
     private runValidations;
     private handleDoubleSpendFailure;
-    /**
-     * Validate a checkpoint attestation.
-     *
-     * @param attestation - The checkpoint attestation to validate.
-     * @returns True if the checkpoint attestation is valid, false otherwise.
-     */
-    validateCheckpointAttestation(peerId: PeerId, attestation: CheckpointAttestation): Promise<P2PValidationResult>;
-    /**
-     * Validate a block proposal.
-     *
-     * @param block - The block proposal to validate.
-     * @returns True if the block proposal is valid, false otherwise.
-     */
-    validateBlockProposal(peerId: PeerId, block: BlockProposal): Promise<P2PValidationResult>;
-    /**
-     * Validate a checkpoint proposal.
-     *
-     * @param checkpoint - The checkpoint proposal to validate.
-     * @returns True if the checkpoint proposal is valid, false otherwise.
-     */
-    validateCheckpointProposal(peerId: PeerId, checkpoint: CheckpointProposal): Promise<P2PValidationResult>;
     getPeerScore(peerId: PeerId): number;
     handleAuthRequestFromPeer(authRequest: AuthRequest, peerId: PeerId): Promise<StatusMessage>;
     private sendToPeers;
     private stopLibP2P;
 }
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"libp2p_service.d.ts","sourceRoot":"","sources":["../../../src/services/libp2p/libp2p_service.ts"],"names":[],"mappings":"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"}