@aztec/p2p 0.0.1-commit.858058eac → 0.0.1-commit.85d7d01

package/src/msg_validators/tx_validator/gas_validator.ts

@@ -1,4 +1,9 @@
-import { AVM_MAX_PROCESSABLE_L2_GAS, FIXED_DA_GAS, FIXED_L2_GAS } from '@aztec/constants';
+import {
+  MAX_PROCESSABLE_L2_GAS,
+  PRIVATE_TX_L2_GAS_OVERHEAD,
+  PUBLIC_TX_L2_GAS_OVERHEAD,
+  TX_DA_GAS_OVERHEAD,
+} from '@aztec/constants';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -16,6 +21,86 @@ import {
 
 import { getFeePayerClaimAmount, getTxFeeLimit } from './fee_payer_balance.js';
 
+/** Structural interface for types that carry gas limit data, used by {@link GasLimitsValidator}. */
+export interface HasGasLimitData {
+  txHash: { toString(): string };
+  data: {
+    // We just need to know whether there is something here or not
+    forPublic?: unknown;
+    constants: {
+      txContext: {
+        gasSettings: { gasLimits: Gas };
+      };
+    };
+  };
+}
+
+/**
+ * Validates that a transaction's gas limits are within acceptable bounds.
+ *
+ * Rejects transactions whose gas limits fall below the fixed minimums (FIXED_DA_GAS,
+ * FIXED_L2_GAS) or exceed the AVM's maximum processable L2 gas. This is a cheap,
+ * stateless check that operates on gas settings alone.
+ *
+ * Generic over T so it can validate both full {@link Tx} objects and {@link TxMetaData}
+ * (used during pending pool migration).
+ *
+ * Used by: pending pool migration (via factory), and indirectly by {@link GasTxValidator}.
+ */
+export class GasLimitsValidator<T extends HasGasLimitData> implements TxValidator<T> {
+  #log: Logger;
+
+  constructor(bindings?: LoggerBindings) {
+    this.#log = createLogger('sequencer:tx_validator:tx_gas', bindings);
+  }
+
+  validateTx(tx: T): Promise<TxValidationResult> {
+    return Promise.resolve(this.validateGasLimit(tx));
+  }
+
+  /** Checks gas limits are >= fixed minimums and <= AVM max processable L2 gas. */
+  validateGasLimit(tx: T): TxValidationResult {
+    const gasLimits = tx.data.constants.txContext.gasSettings.gasLimits;
+    const minGasLimits = new Gas(
+      TX_DA_GAS_OVERHEAD,
+      tx.data.forPublic ? PUBLIC_TX_L2_GAS_OVERHEAD : PRIVATE_TX_L2_GAS_OVERHEAD,
+    );
+
+    if (minGasLimits.gtAny(gasLimits)) {
+      this.#log.verbose(`Rejecting transaction due to the gas limit(s) not being above the minimum gas limit`, {
+        gasLimits,
+        minGasLimits,
+      });
+      return { result: 'invalid', reason: [TX_ERROR_INSUFFICIENT_GAS_LIMIT] };
+    }
+
+    if (gasLimits.l2Gas > MAX_PROCESSABLE_L2_GAS) {
+      this.#log.verbose(`Rejecting transaction due to the gas limit(s) being higher than the maximum processable gas`, {
+        gasLimits,
+        minGasLimits,
+      });
+      return { result: 'invalid', reason: [TX_ERROR_GAS_LIMIT_TOO_HIGH] };
+    }
+
+    return { result: 'valid' };
+  }
+}
+
+/**
+ * Validates that a transaction can pay its gas fees.
+ *
+ * Runs three checks in order:
+ * 1. **Gas limits** (delegates to {@link GasLimitsValidator}) — rejects if limits are
+ *    out of bounds.
+ * 2. **Max fee per gas** — skips (not rejects) the tx if its maxFeesPerGas is below
+ *    the current block's gas fees. We skip rather than reject because the tx may
+ *    become eligible in a later block with lower fees.
+ * 3. **Fee payer balance** — reads the fee payer's FeeJuice balance from public state,
+ *    adds any pending claim from a setup-phase `_increase_public_balance` call, and
+ *    rejects if the total is less than the tx's fee limit (gasLimits * maxFeePerGas).
+ *
+ * Used by: gossip (stage 1), RPC, and block building validators.
+ */
 export class GasTxValidator implements TxValidator<Tx> {
   #log: Logger;
   #publicDataSource: PublicStateSource;
@@ -26,7 +111,7 @@ export class GasTxValidator implements TxValidator<Tx> {
     publicDataSource: PublicStateSource,
     feeJuiceAddress: AztecAddress,
     gasFees: GasFees,
-    bindings?: LoggerBindings,
+    private bindings?: LoggerBindings,
   ) {
     this.#log = createLogger('sequencer:tx_validator:tx_gas', bindings);
     this.#publicDataSource = publicDataSource;
@@ -35,7 +120,7 @@ export class GasTxValidator implements TxValidator<Tx> {
   }
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {
-    const gasLimitValidation = this.#validateGasLimit(tx);
+    const gasLimitValidation = new GasLimitsValidator(this.bindings).validateGasLimit(tx);
     if (gasLimitValidation.result === 'invalid') {
       return Promise.resolve(gasLimitValidation);
     }
@@ -69,31 +154,9 @@ export class GasTxValidator implements TxValidator<Tx> {
   }
 
   /**
-   * Check whether the tx's gas limit is above the minimum amount.
+   * Checks the fee payer has enough FeeJuice balance to cover the tx's fee limit.
+   * Accounts for any pending claim from a setup-phase `_increase_public_balance` call.
    */
-  #validateGasLimit(tx: Tx): TxValidationResult {
-    const gasLimits = tx.data.constants.txContext.gasSettings.gasLimits;
-    const minGasLimits = new Gas(FIXED_DA_GAS, FIXED_L2_GAS);
-
-    if (minGasLimits.gtAny(gasLimits)) {
-      this.#log.verbose(`Rejecting transaction due to the gas limit(s) not being above the minimum gas limit`, {
-        gasLimits,
-        minGasLimits,
-      });
-      return { result: 'invalid', reason: [TX_ERROR_INSUFFICIENT_GAS_LIMIT] };
-    }
-
-    if (gasLimits.l2Gas > AVM_MAX_PROCESSABLE_L2_GAS) {
-      this.#log.verbose(`Rejecting transaction due to the gas limit(s) being higher than the maximum processable gas`, {
-        gasLimits,
-        minGasLimits,
-      });
-      return { result: 'invalid', reason: [TX_ERROR_GAS_LIMIT_TOO_HIGH] };
-    }
-
-    return { result: 'valid' };
-  }
-
   public async validateTxFee(tx: Tx): Promise<TxValidationResult> {
     const feePayer = tx.data.feePayer;
 

package/src/msg_validators/tx_validator/index.ts

@@ -12,3 +12,4 @@ export * from './archive_cache.js';
 export * from './tx_permitted_validator.js';
 export * from './timestamp_validator.js';
 export * from './size_validator.js';
+export * from './factory.js';

package/src/msg_validators/tx_validator/nullifier_cache.ts

@@ -0,0 +1,30 @@
+import type { NullifierSource } from '@aztec/p2p';
+import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+
+/**
+ * Implements a nullifier source by checking a DB and an in-memory collection.
+ * Intended for validating transactions as they are added to a block.
+ */
+export class NullifierCache implements NullifierSource {
+  nullifiers: Set<string>;
+
+  constructor(private db: MerkleTreeReadOperations) {
+    this.nullifiers = new Set();
+  }
+
+  public async nullifiersExist(nullifiers: Buffer[]): Promise<boolean[]> {
+    const cacheResults = nullifiers.map(n => this.nullifiers.has(n.toString()));
+    const toCheckDb = nullifiers.filter((_n, index) => !cacheResults[index]);
+    const dbHits = await this.db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, toCheckDb);
+
+    let dbIndex = 0;
+    return nullifiers.map((_n, index) => cacheResults[index] || dbHits[dbIndex++] !== undefined);
+  }
+
+  public addNullifiers(nullifiers: Buffer[]) {
+    for (const nullifier of nullifiers) {
+      this.nullifiers.add(nullifier.toString());
+    }
+  }
+}

package/src/msg_validators/tx_validator/timestamp_validator.ts

@@ -1,13 +1,13 @@
 import type { BlockNumber } from '@aztec/foundation/branded-types';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
-import { TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import { TX_ERROR_INVALID_EXPIRATION_TIMESTAMP, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
 /** Structural interface for timestamp validation. */
 export interface HasTimestampData {
   txHash: { toString(): string };
   data: {
-    includeByTimestamp: bigint;
+    expirationTimestamp: bigint;
     constants: {
       anchorBlockHeader: {
         globalVariables: {
@@ -35,21 +35,21 @@ export class TimestampTxValidator<T extends HasTimestampData> implements TxValid
   }
 
   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`
+    const expirationTimestamp = tx.data.expirationTimestamp;
+    // If building block 1, we skip the expiration check. For details on why see the `validate_expiration_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 (!buildingBlock1 && expirationTimestamp < 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 ${tx.txHash} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp}, timestamp: ${this.values.timestamp}.`,
+        `Rejecting tx ${tx.txHash} for low expiration timestamp. Tx expiration timestamp: ${expirationTimestamp}, timestamp: ${this.values.timestamp}.`,
       );
-      return Promise.resolve({ result: 'invalid', reason: [TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP] });
+      return Promise.resolve({ result: 'invalid', reason: [TX_ERROR_INVALID_EXPIRATION_TIMESTAMP] });
     } else {
       return Promise.resolve({ result: 'valid' });
     }

package/src/services/dummy_service.ts

@@ -1,6 +1,6 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
-import type { Gossipable, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import type { Gossipable, PeerErrorSeverity, TopicType } from '@aztec/stdlib/p2p';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
@@ -44,6 +44,10 @@ export class DummyP2PService implements P2PService {
     return [];
   }
 
+  getGossipMeshPeerCount(_topicType: TopicType): number {
+    return 0;
+  }
+
   /**
    * Starts the dummy implementation.
    * @returns A resolved promise.
@@ -137,14 +141,10 @@ export class DummyP2PService implements P2PService {
     return undefined;
   }
 
-  validate(_txs: Tx[]): Promise<void> {
+  validateTxsReceivedInBlockProposal(_txs: Tx[]): Promise<void> {
     return Promise.resolve();
   }
 
-  validatePropagatedTx(_tx: Tx, _peerId: PeerId): Promise<boolean> {
-    return Promise.resolve(true);
-  }
-
   addReqRespSubProtocol(
     _subProtocol: ReqRespSubProtocol,
     _handler: ReqRespSubProtocolHandler,

package/src/services/encoding.ts

@@ -1,11 +1,11 @@
 // Taken from lodestar: https://github.com/ChainSafe/lodestar
-import { sha256 } from '@aztec/foundation/crypto/sha256';
 import { createLogger } from '@aztec/foundation/log';
 import { MAX_TX_SIZE_KB, TopicType, getTopicFromString } from '@aztec/stdlib/p2p';
 
 import type { RPC } from '@chainsafe/libp2p-gossipsub/message';
 import type { DataTransform } from '@chainsafe/libp2p-gossipsub/types';
 import type { Message } from '@libp2p/interface';
+import { webcrypto } from 'node:crypto';
 import { compressSync, uncompressSync } from 'snappy';
 import xxhashFactory from 'xxhash-wasm';
 
@@ -44,11 +44,10 @@ export function msgIdToStrFn(msgId: Uint8Array): string {
  * @param message - The libp2p message
  * @returns The message identifier
  */
-export function getMsgIdFn(message: Message) {
-  const { topic } = message;
-
-  const vec = [Buffer.from(topic), message.data];
-  return sha256(Buffer.concat(vec)).subarray(0, 20);
+export async function getMsgIdFn({ topic, data }: Message): Promise<Uint8Array> {
+  const buffer = Buffer.concat([Buffer.from(topic), data]);
+  const hash = await webcrypto.subtle.digest('SHA-256', buffer);
+  return Buffer.from(hash.slice(0, 20));
 }
 
 const DefaultMaxSizesKb: Record<TopicType, number> = {
@@ -58,7 +57,8 @@ const DefaultMaxSizesKb: Record<TopicType, number> = {
   // Proposals may carry some tx objects, so we allow a larger size capped at 10mb
   // Note this may not be enough for carrying all tx objects in a block
   [TopicType.block_proposal]: 1024 * 10,
-  // TODO(palla/mbps): Check size for checkpoint proposal
+  // Checkpoint proposals carry almost the same data as a block proposal (see the lastBlockProposal)
+  // Only diff is an additional header, which is pretty small compared to the 10mb limit
   [TopicType.checkpoint_proposal]: 1024 * 10,
 };
 

package/src/services/gossipsub/README.md

@@ -40,7 +40,7 @@ We configure all parameters (P1-P4) with values calculated dynamically from netw
 | P3b: meshFailurePenalty | -34 per topic | Sticky penalty after pruning |
 | P4: invalidMessageDeliveries | -20 per message | Attack detection |
 
-**Important:** P1 and P2 are only enabled on topics with P3 enabled (block_proposal, checkpoint_proposal, checkpoint_attestation). The tx topic has all scoring disabled except P4, to prevent free positive score accumulation that would offset penalties from other topics.
+**Important:** P1 and P2 are only enabled on topics with P3 enabled. By default, P3 is enabled for checkpoint_proposal and checkpoint_attestation (2 topics). Block proposal scoring is controlled by `expectedBlockProposalsPerSlot` (current default: `0`, including when env var is unset, so disabled) - see [Block Proposals](#block-proposals-block_proposal) for details. The tx topic has all scoring disabled except P4, to prevent free positive score accumulation that would offset penalties from other topics.
 
 ## Exponential Decay
 
@@ -217,7 +217,21 @@ Transactions are submitted unpredictably by users, so we cannot set meaningful d
 
 ### Block Proposals (block_proposal)
 
-In Multi-Block-Per-Slot (MBPS) mode, N-1 block proposals are gossiped per slot (the last block is bundled with the checkpoint). In single-block mode, this is 0.
+Block proposal scoring is controlled by the `expectedBlockProposalsPerSlot` config (`SEQ_EXPECTED_BLOCK_PROPOSALS_PER_SLOT` env var):
+
+| Config Value | Behavior |
+|-------------|----------|
+| `0` (current default) | Block proposal P3 scoring is **disabled** |
+| Positive number | Uses the provided value as expected proposals per slot |
+| `undefined` | Falls back to `blocksPerSlot - 1` (MBPS mode: N-1, single block: 0) |
+
+**Current behavior note:** In the current implementation, if `SEQ_EXPECTED_BLOCK_PROPOSALS_PER_SLOT` is not set, config mapping applies `0` by default (scoring disabled). The `undefined` fallback above is currently reachable only if the value is explicitly provided as `undefined` in code.
+
+**Future intent:** Once throughput is stable, we may change env parsing/defaults so an unset env var resolves to `undefined` again (re-enabling automatic fallback to `blocksPerSlot - 1`).
+
+**Why disabled by default?** In MBPS mode, gossipsub expects N-1 block proposals per slot. When transaction throughput is low (as expected at launch), fewer blocks are actually built, causing peers to be incorrectly penalized for under-delivering block proposals. The default of 0 disables this scoring. Set to a positive value when throughput increases and block production is consistent.
+
+In MBPS mode (when enabled), N-1 block proposals are gossiped per slot (the last block is bundled with the checkpoint). In single-block mode, this is 0.
 
 ### Checkpoint Proposals (checkpoint_proposal)
 
@@ -241,6 +255,7 @@ The scoring parameters depend on:
 | `targetCommitteeSize` | L1RollupConstants | 48 |
 | `heartbeatInterval` | P2PConfig.gossipsubInterval | 700ms |
 | `blockDurationMs` | P2PConfig.blockDurationMs | undefined (single block) |
+| `expectedBlockProposalsPerSlot` | P2PConfig.expectedBlockProposalsPerSlot | 0 (disabled; current unset-env behavior) |
 
 ## Invalid Message Handling (P4)
 
@@ -320,9 +335,9 @@ Conversely, if topic scores are low, a peer slightly above the disconnect thresh
 
 Topic scores provide **burst response** to attacks, while app score provides **stable baseline**:
 
-- P1 (time in mesh): Max +8 per topic (+24 across 3 topics)
-- P2 (first deliveries): Max +25 per topic (+75 across 3 topics, but decays fast)
-- P3 (under-delivery): Max -34 per topic (-102 across 3 topics in MBPS; -68 in single-block mode)
+- P1 (time in mesh): Max +8 per topic (+16 default, +24 with block proposal scoring enabled)
+- P2 (first deliveries): Max +25 per topic (+50 default, +75 with block proposal scoring, but decays fast)
+- P3 (under-delivery): Max -34 per topic (-68 default with 2 topics, -102 with block proposal scoring enabled)
 - P4 (invalid messages): -20 per invalid message, can spike to -2000+ during attacks
 
 Example attack scenario:
@@ -373,21 +388,21 @@ When a peer is pruned from the mesh:
 3. **P3b captures the penalty**: The P3 deficit at prune time becomes P3b, which decays slowly
 
 After pruning, the peer's score consists mainly of P3b:
-- **Total P3b across 3 topics: -102** (max)
+- **Total P3b: -68** (default, 2 topics) or **-102** (with block proposal scoring enabled, 3 topics)
 - **Recovery time**: P3b decays to ~1% over one decay window (2-5 slots = 2-6 minutes)
 - **Grafting eligibility**: Peer can be grafted when score ≥ 0, but asymptotic decay means recovery is slow
 
 ### Why Non-Contributors Aren't Disconnected
 
-With P3b capped at -102 total after pruning (MBPS mode). In single-block mode, the cap is -68:
+With P3b capped at -68 (default, 2 topics) or -102 (with block proposal scoring, 3 topics) after pruning:
 
 | Threshold | Value | P3b Score | Triggered? |
 |-----------|-------|-----------|------------|
-| gossipThreshold | -500 | -102 (MBPS) / -68 (single) | No |
-| publishThreshold | -1000 | -102 (MBPS) / -68 (single) | No |
-| graylistThreshold | -2000 | -102 (MBPS) / -68 (single) | No |
+| gossipThreshold | -500 | -68 (default) / -102 (block scoring on) | No |
+| publishThreshold | -1000 | -68 (default) / -102 (block scoring on) | No |
+| graylistThreshold | -2000 | -68 (default) / -102 (block scoring on) | No |
 
-**A score of -102 (MBPS) or -68 (single-block) is well above -500**, so non-contributing peers:
+**A score of -68 or -102 is well above -500**, so non-contributing peers:
 - Are pruned from mesh (good - stops them slowing propagation)
 - Still receive gossip (can recover by reconnecting/restarting)
 - Are NOT disconnected unless they also have application-level penalties
@@ -547,7 +562,7 @@ What happens when a peer experiences a network outage and stops delivering messa
 While the peer is disconnected:
 
 1. **P3 penalty accumulates**: The message delivery counter decays toward 0, causing increasing P3 penalty
-2. **Max P3 penalty reached**: Once counter drops below threshold, penalty hits -34 per topic (-102 total in MBPS; -68 single-block)
+2. **Max P3 penalty reached**: Once counter drops below threshold, penalty hits -34 per topic (-68 default, -102 with block proposal scoring)
 3. **Mesh pruning**: Topic score goes negative → peer is pruned from mesh
 4. **P3b captures penalty**: The P3 deficit at prune time becomes P3b (sticky penalty)
 
@@ -569,13 +584,13 @@ Note: If the peer just joined the mesh, P3 penalties only start after
 During a network outage, the peer:
 - **Does NOT send invalid messages** → No P4 penalty
 - **Does NOT violate protocols** → No application-level penalty
-- **Only accumulates topic-level penalties** → Max -102 (P3b, MBPS) or -68 (single-block)
+- **Only accumulates topic-level penalties** → Max -68 (default) or -102 (with block proposal scoring)
 
 This is the crucial difference from malicious behavior:
 
 | Scenario | App Score | Topic Score | Total | Threshold Hit |
 |----------|-----------|-------------|-------|---------------|
-| Network outage | 0 | -102 (MBPS) / -68 (single) | -102 / -68 | None |
+| Network outage | 0 | -68 (default) / -102 (block scoring on) | -68 / -102 | None |
 | Validation failure | -50 | -20 | -520 | gossipThreshold |
 | Malicious peer | -100 | -2000+ | -2100+ | graylistThreshold |
 

package/src/services/gossipsub/topic_score_params.ts

@@ -15,6 +15,8 @@ export type TopicScoringNetworkParams = {
   targetCommitteeSize: number;
   /** Duration per block in milliseconds when building multiple blocks per slot. If undefined, single block mode. */
   blockDurationMs?: number;
+  /** Expected number of block proposals per slot for scoring override. 0 disables scoring, undefined falls back to blocksPerSlot - 1. */
+  expectedBlockProposalsPerSlot?: number;
 };
 
 /**
@@ -89,18 +91,41 @@ export function computeThreshold(convergence: number, conservativeFactor: number
   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: number,
+  expectedBlockProposalsPerSlot?: number,
+): number | undefined {
+  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: TopicType,
   targetCommitteeSize: number,
   blocksPerSlot: number,
+  expectedBlockProposalsPerSlot?: number,
 ): number | undefined {
   switch (topicType) {
     case TopicType.tx:
@@ -108,9 +133,7 @@ export function getExpectedMessagesPerSlot(
       return undefined;
 
     case TopicType.block_proposal:
-      // In MBPS mode, N-1 block proposals per slot (last one bundled with checkpoint)
-      // In single block mode (blocksPerSlot=1), this is 0
-      return Math.max(0, blocksPerSlot - 1);
+      return getEffectiveBlockProposalsPerSlot(blocksPerSlot, expectedBlockProposalsPerSlot);
 
     case TopicType.checkpoint_proposal:
       // Exactly 1 checkpoint proposal per slot
@@ -190,10 +213,12 @@ const P2_DECAY_WINDOW_SLOTS = 2;
 //   |P3| > 8 + 25 = 33
 //
 // We set P3 max = -34 per topic (slightly more than P1+P2) to ensure pruning.
-// With 3 topics having P3 enabled, total P3b after pruning = -102.
+// 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 (-102)
-// would cross gossipThreshold (-500). This keeps non-contributors from being disconnected
+// 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:
@@ -203,12 +228,6 @@ const P2_DECAY_WINDOW_SLOTS = 2;
 /** 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
 
-/** Number of topics with P3 enabled in MBPS mode (block_proposal + checkpoint_proposal + checkpoint_attestation) */
-export const NUM_P3_ENABLED_TOPICS = 3;
-
-/** Total maximum P3b penalty across all topics after pruning in MBPS mode */
-export const TOTAL_MAX_P3B_PENALTY = MAX_P3_PENALTY_PER_TOPIC * NUM_P3_ENABLED_TOPICS; // -102
-
 /**
  * Factory class for creating gossipsub topic scoring parameters.
  * Computes shared values once and reuses them across all topics.
@@ -384,6 +403,18 @@ export class TopicScoreParamsFactory {
     });
   }
 
+  /** Number of topics with P3 enabled, computed from config. Always 2 (checkpoint_proposal + checkpoint_attestation) plus optionally block_proposal. */
+  get numP3EnabledTopics(): number {
+    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(): number {
+    return MAX_P3_PENALTY_PER_TOPIC * this.numP3EnabledTopics;
+  }
+
   /**
    * Creates topic score parameters for a specific topic type.
    *
@@ -391,7 +422,12 @@ export class TopicScoreParamsFactory {
    * @returns TopicScoreParams for the topic
    */
   createForTopic(topicType: TopicType): ReturnType<typeof createTopicScoreParams> {
-    const expectedPerSlot = getExpectedMessagesPerSlot(topicType, this.params.targetCommitteeSize, this.blocksPerSlot);
+    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) {