@aztec/p2p 0.0.1-commit.f2ce05ee → 0.0.1-commit.f81dbcf

package/src/client/test/tx_proposal_collector/proposal_tx_collector_worker.ts

@@ -8,7 +8,7 @@ import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 import type { L2BlockSource } from '@aztec/stdlib/block';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
-import { P2PClientType, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import type { Tx, TxValidationResult } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
@@ -16,14 +16,12 @@ import type { PeerId } from '@libp2p/interface';
 import { peerIdFromString } from '@libp2p/peer-id';
 
 import type { P2PConfig } from '../../../config.js';
+import { BatchTxRequesterCollector, SendBatchRequestCollector } from '../../../services/index.js';
 import type { IBatchRequestTxValidator } from '../../../services/reqresp/batch-tx-requester/tx_validator.js';
 import { RateLimitStatus } from '../../../services/reqresp/rate-limiter/rate_limiter.js';
+import { MissingTxsTracker } from '../../../services/tx_collection/missing_txs_tracker.js';
 import {
-  BatchTxRequesterCollector,
-  SendBatchRequestCollector,
-} from '../../../services/tx_collection/proposal_tx_collector.js';
-import { AlwaysTrueCircuitVerifier } from '../../../test-helpers/reqresp-nodes.js';
-import {
+  AlwaysTrueCircuitVerifier,
   BENCHMARK_CONSTANTS,
   InMemoryAttestationPool,
   InMemoryTxPool,
@@ -31,7 +29,7 @@ import {
   calculateInternalTimeout,
   createMockEpochCache,
   createMockWorldStateSynchronizer,
-} from '../../../test-helpers/testbench-utils.js';
+} from '../../../test-helpers/index.js';
 import { createP2PClient } from '../../index.js';
 import type { P2PClient } from '../../p2p_client.js';
 import {
@@ -116,7 +114,6 @@ async function startClient(config: P2PConfig, clientIndex: number) {
   };
 
   client = await createP2PClient(
-    P2PClientType.Full,
     config as P2PConfig & DataStoreConfig,
     l2BlockSource as L2BlockSource & ContractDataSource,
     proofVerifier as ClientProtocolCircuitVerifier,
@@ -214,7 +211,13 @@ async function runCollector(cmd: Extract<WorkerCommand, { type: 'RUN_COLLECTOR'
     if (collectorType === 'batch-requester') {
       const collector = new BatchTxRequesterCollector(p2pService, logger, new DateProvider(), noopTxValidator);
       const fetched = await executeTimeout(
-        (_signal: AbortSignal) => collector.collectTxs(parsedTxHashes, parsedProposal, pinnedPeer, internalTimeoutMs),
+        (_signal: AbortSignal) =>
+          collector.collectTxs(
+            MissingTxsTracker.fromArray(parsedTxHashes),
+            parsedProposal,
+            pinnedPeer,
+            internalTimeoutMs,
+          ),
         timeoutMs,
         () => new Error(`Collector timed out after ${timeoutMs}ms`),
       );
@@ -226,7 +229,13 @@ async function runCollector(cmd: Extract<WorkerCommand, { type: 'RUN_COLLECTOR'
         BENCHMARK_CONSTANTS.FIXED_MAX_RETRY_ATTEMPTS,
       );
       const fetched = await executeTimeout(
-        (_signal: AbortSignal) => collector.collectTxs(parsedTxHashes, parsedProposal, pinnedPeer, internalTimeoutMs),
+        (_signal: AbortSignal) =>
+          collector.collectTxs(
+            MissingTxsTracker.fromArray(parsedTxHashes),
+            parsedProposal,
+            pinnedPeer,
+            internalTimeoutMs,
+          ),
         timeoutMs,
         () => new Error(`Collector timed out after ${timeoutMs}ms`),
       );

package/src/config.ts

@@ -1,6 +1,7 @@
 import {
   type ConfigMappingsType,
   SecretValue,
+  bigintConfigHelper,
   booleanConfigHelper,
   getConfigFromMappings,
   getDefaultConfig,
@@ -38,13 +39,28 @@ export interface P2PConfig
     ChainConfig,
     TxCollectionConfig,
     TxFileStoreConfig,
-    Pick<SequencerConfig, 'blockDurationMs'> {
+    Pick<SequencerConfig, 'blockDurationMs' | 'expectedBlockProposalsPerSlot' | 'maxTxsPerBlock'> {
+  /** Maximum transactions per block for validation. Overrides maxTxsPerBlock for gossip validation when set. */
+  validateMaxTxsPerBlock?: number;
+
+  /** Maximum transactions per checkpoint for validation. Used as fallback for maxTxsPerBlock when that is not set. */
+  validateMaxTxsPerCheckpoint?: number;
+
+  /** Maximum L2 gas per block for validation. When set, txs exceeding this limit are rejected. */
+  validateMaxL2BlockGas?: number;
+
+  /** Maximum DA gas per block for validation. When set, txs exceeding this limit are rejected. */
+  validateMaxDABlockGas?: number;
+
   /** A flag dictating whether the P2P subsystem should be enabled. */
   p2pEnabled: boolean;
 
   /** The frequency in which to check for new L2 blocks. */
   blockCheckIntervalMS: number;
 
+  /** The frequency in which to check for new L2 slots. */
+  slotCheckIntervalMS: number;
+
   /** The number of blocks to fetch in a single batch. */
   blockRequestBatchSize: number;
 
@@ -147,8 +163,8 @@ export interface P2PConfig
   /** The maximum possible size of the P2P DB in KB. Overwrites the general dataStoreMapSizeKb. */
   p2pStoreMapSizeKb?: number;
 
-  /** Which calls are allowed in the public setup phase of a tx. */
-  txPublicSetupAllowList: AllowedElement[];
+  /** Additional entries to extend the default setup allow list. */
+  txPublicSetupAllowListExtend: AllowedElement[];
 
   /** The maximum number of pending txs before evicting lower priority txs. */
   maxPendingTxCount: number;
@@ -184,11 +200,42 @@ export interface P2PConfig
 
   /** Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus */
   fishermanMode: boolean;
+
+  /** Broadcast block proposals even when a conflicting proposal for the same slot already exists in the pool (for testing purposes only). */
+  broadcastEquivocatedProposals?: boolean;
+
+  /** Minimum age (ms) a transaction must have been in the pool before it's eligible for block building. */
+  minTxPoolAgeMs: number;
+
+  /** Minimum percentage fee increase required to replace an existing tx via RPC (0 = no bump). */
+  priceBumpPercentage: bigint;
 }
 
 export const DEFAULT_P2P_PORT = 40400;
 
 export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
+  validateMaxTxsPerBlock: {
+    env: 'VALIDATOR_MAX_TX_PER_BLOCK',
+    description:
+      'Maximum transactions per block for validation. Overrides maxTxsPerBlock for gossip validation when set.',
+    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+  },
+  validateMaxTxsPerCheckpoint: {
+    env: 'VALIDATOR_MAX_TX_PER_CHECKPOINT',
+    description:
+      'Maximum transactions per checkpoint for validation. Used as fallback for maxTxsPerBlock when that is not set.',
+    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+  },
+  validateMaxL2BlockGas: {
+    env: 'VALIDATOR_MAX_L2_BLOCK_GAS',
+    description: 'Maximum L2 gas per block for validation. When set, txs exceeding this limit are rejected.',
+    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+  },
+  validateMaxDABlockGas: {
+    env: 'VALIDATOR_MAX_DA_BLOCK_GAS',
+    description: 'Maximum DA gas per block for validation. When set, txs exceeding this limit are rejected.',
+    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+  },
   p2pEnabled: {
     env: 'P2P_ENABLED',
     description: 'A flag dictating whether the P2P subsystem should be enabled.',
@@ -204,6 +251,11 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     description: 'The frequency in which to check for new L2 blocks.',
     ...numberConfigHelper(100),
   },
+  slotCheckIntervalMS: {
+    env: 'P2P_SLOT_CHECK_INTERVAL_MS',
+    description: 'The frequency in which to check for new L2 slots.',
+    ...numberConfigHelper(1000),
+  },
   debugDisableColocationPenalty: {
     env: 'DEBUG_P2P_DISABLE_COLOCATION_PENALTY',
     description: 'DEBUG: Disable colocation penalty - NEVER set to true in production',
@@ -382,12 +434,13 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     parseEnv: (val: string | undefined) => (val ? +val : undefined),
     description: 'The maximum possible size of the P2P DB in KB. Overwrites the general dataStoreMapSizeKb.',
   },
-  txPublicSetupAllowList: {
+  txPublicSetupAllowListExtend: {
     env: 'TX_PUBLIC_SETUP_ALLOWLIST',
     parseEnv: (val: string) => parseAllowList(val),
-    description: 'The list of functions calls allowed to run in setup',
+    description:
+      'Additional entries to extend the default setup allow list. Format: I:address:selector[:flags],C:classId:selector[:flags]. Flags: os (onlySelf), rn (rejectNullMsgSender), cl=N (calldataLength), joined with +.',
     printDefault: () =>
-      'AuthRegistry, FeeJuice.increase_public_balance, Token.increase_public_balance, FPC.prepare_fee',
+      'Default: AuthRegistry._set_authorized, AuthRegistry.set_authorized, FeeJuice._increase_public_balance',
   },
   maxPendingTxCount: {
     env: 'P2P_MAX_PENDING_TX_COUNT',
@@ -448,6 +501,22 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
       'Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus.',
     ...booleanConfigHelper(false),
   },
+  broadcastEquivocatedProposals: {
+    description:
+      'Broadcast block proposals even when a conflicting proposal for the same slot already exists in the pool (for testing purposes only).',
+    ...booleanConfigHelper(false),
+  },
+  minTxPoolAgeMs: {
+    env: 'P2P_MIN_TX_POOL_AGE_MS',
+    description: 'Minimum age (ms) a transaction must have been in the pool before it is eligible for block building.',
+    ...numberConfigHelper(2_000),
+  },
+  priceBumpPercentage: {
+    env: 'P2P_RPC_PRICE_BUMP_PERCENTAGE',
+    description:
+      'Minimum percentage fee increase required to replace an existing tx via RPC. Even at 0%, replacement still requires paying at least 1 unit more.',
+    ...bigintConfigHelper(10n),
+  },
   ...sharedSequencerConfigMappings,
   ...p2pReqRespConfigMappings,
   ...batchTxRequesterConfigMappings,
@@ -505,13 +574,44 @@ export const bootnodeConfigMappings = pickConfigMappings(
   bootnodeConfigKeys,
 );
 
+/**
+ * Parses a `+`-separated flags string into validation properties for an allow list entry.
+ * Supported flags: `os` (onlySelf), `rn` (rejectNullMsgSender), `cl=N` (calldataLength).
+ */
+function parseFlags(
+  flags: string,
+  entry: string,
+): { onlySelf?: boolean; rejectNullMsgSender?: boolean; calldataLength?: number } {
+  const result: { onlySelf?: boolean; rejectNullMsgSender?: boolean; calldataLength?: number } = {};
+  for (const flag of flags.split('+')) {
+    if (flag === 'os') {
+      result.onlySelf = true;
+    } else if (flag === 'rn') {
+      result.rejectNullMsgSender = true;
+    } else if (flag.startsWith('cl=')) {
+      const n = parseInt(flag.slice(3), 10);
+      if (isNaN(n) || n < 0) {
+        throw new Error(
+          `Invalid allow list entry "${entry}": invalid calldataLength in flag "${flag}". Expected a non-negative integer.`,
+        );
+      }
+      result.calldataLength = n;
+    } else {
+      throw new Error(`Invalid allow list entry "${entry}": unknown flag "${flag}". Supported flags: os, rn, cl=N.`);
+    }
+  }
+  return result;
+}
+
 /**
  * Parses a string to a list of allowed elements.
- * Each encoded is expected to be of one of the following formats
- * `I:${address}`
- * `I:${address}:${selector}`
- * `C:${classId}`
- * `C:${classId}:${selector}`
+ * Each entry is expected to be of one of the following formats:
+ * `I:${address}:${selector}` — instance (contract address) with function selector
+ * `C:${classId}:${selector}` — class with function selector
+ *
+ * An optional flags segment can be appended after the selector:
+ * `I:${address}:${selector}:${flags}` or `C:${classId}:${selector}:${flags}`
+ * where flags is a `+`-separated list of: `os` (onlySelf), `rn` (rejectNullMsgSender), `cl=N` (calldataLength).
  *
  * @param value The string to parse
  * @returns A list of allowed elements
@@ -524,31 +624,37 @@ export function parseAllowList(value: string): AllowedElement[] {
   }
 
   for (const val of value.split(',')) {
-    const [typeString, identifierString, selectorString] = val.split(':');
-    const selector = selectorString !== undefined ? FunctionSelector.fromString(selectorString) : undefined;
+    const trimmed = val.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const [typeString, identifierString, selectorString, flagsString] = trimmed.split(':');
+
+    if (!selectorString) {
+      throw new Error(
+        `Invalid allow list entry "${trimmed}": selector is required. Expected format: I:address:selector or C:classId:selector`,
+      );
+    }
+
+    const selector = FunctionSelector.fromString(selectorString);
+    const flags = flagsString ? parseFlags(flagsString, trimmed) : {};
 
     if (typeString === 'I') {
-      if (selector) {
-        entries.push({
-          address: AztecAddress.fromString(identifierString),
-          selector,
-        });
-      } else {
-        entries.push({
-          address: AztecAddress.fromString(identifierString),
-        });
-      }
+      entries.push({
+        address: AztecAddress.fromString(identifierString),
+        selector,
+        ...flags,
+      });
     } else if (typeString === 'C') {
-      if (selector) {
-        entries.push({
-          classId: Fr.fromHexString(identifierString),
-          selector,
-        });
-      } else {
-        entries.push({
-          classId: Fr.fromHexString(identifierString),
-        });
-      }
+      entries.push({
+        classId: Fr.fromHexString(identifierString),
+        selector,
+        ...flags,
+      });
+    } else {
+      throw new Error(
+        `Invalid allow list entry "${trimmed}": unknown type "${typeString}". Expected "I" (instance) or "C" (class).`,
+      );
     }
   }
 

package/src/errors/tx-pool.error.ts

@@ -0,0 +1,12 @@
+import type { TxPoolRejectionError } from '../mem_pools/tx_pool_v2/eviction/interfaces.js';
+
+/** Error thrown when a transaction is not added to the mempool. */
+export class TxPoolError extends Error {
+  public readonly data: TxPoolRejectionError;
+
+  constructor(public readonly reason: TxPoolRejectionError) {
+    super(reason.message);
+    this.name = 'TxPoolError';
+    this.data = reason;
+  }
+}

package/src/index.ts

@@ -7,5 +7,6 @@ export * from './enr/index.js';
 export * from './config.js';
 export * from './mem_pools/attestation_pool/index.js';
 export * from './mem_pools/tx_pool/index.js';
+export * from './mem_pools/tx_pool_v2/index.js';
 export * from './msg_validators/index.js';
 export * from './services/index.js';

package/src/mem_pools/attestation_pool/attestation_pool.ts

@@ -19,13 +19,17 @@ export type TryAddResult = {
   added: boolean;
   /** Whether the exact item already existed */
   alreadyExists: boolean;
-  /** Total items for this position - used for duplicate detection */
-  totalForPosition: number;
+  /** Count of items for the position. Meaning varies by method:
+   *  - tryAddBlockProposal: proposals at (slot, indexWithinCheckpoint)
+   *  - tryAddCheckpointProposal: proposals at slot
+   *  - tryAddCheckpointAttestation: attestations by this signer for this slot */
+  count: number;
 };
 
-export const MAX_PROPOSALS_PER_SLOT = 5;
-export const MAX_PROPOSALS_PER_POSITION = 3;
-export const ATTESTATION_CAP_BUFFER = 10;
+export const MAX_CHECKPOINT_PROPOSALS_PER_SLOT = 5;
+export const MAX_BLOCK_PROPOSALS_PER_POSITION = 3;
+/** Maximum attestations a single signer can make per slot before being rejected. */
+export const MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER = 3;
 
 /** Public API interface for attestation pools. Used for typing mocks and test implementations. */
 export type AttestationPoolApi = Pick<
@@ -39,6 +43,7 @@ export type AttestationPoolApi = Pick<
   | 'deleteOlderThan'
   | 'getCheckpointAttestationsForSlot'
   | 'getCheckpointAttestationsForSlotAndProposal'
+  | 'hasBlockProposalsForSlot'
   | 'isEmpty'
 >;
 
@@ -69,6 +74,10 @@ export class AttestationPool {
   // Key: (slot << 10) | indexWithinCheckpoint, Value: archive string
   private blockProposalsForSlotAndIndex: AztecAsyncMultiMap<number, string>;
 
+  // Checkpoint attestations indexed by (slot, signer) for tracking attestations per (slot, signer) for duplicate detection
+  // Key: `${Fr(slot).toString()}-${signerAddress}` string (padded for lexicographic ordering), Value: `proposalId` strings
+  private checkpointAttestationsPerSlotAndSigner: AztecAsyncMultiMap<string, string>;
+
   constructor(
     private store: AztecAsyncKVStore,
     telemetry: TelemetryClient = getTelemetryClient(),
@@ -80,6 +89,7 @@ export class AttestationPool {
 
     // Initialize checkpoint attestations storage
     this.checkpointAttestations = store.openMap('checkpoint_attestations');
+    this.checkpointAttestationsPerSlotAndSigner = store.openMultiMap('checkpoint_attestations_per_slot_and_signer');
 
     // Initialize checkpoint proposal storage
     this.checkpointProposals = store.openMap('checkpoint_proposals');
@@ -133,6 +143,12 @@ export class AttestationPool {
     return { start: `${proposalKey}-`, end: `${proposalKey}-Z` };
   }
 
+  /** Creates a key for the per-signer-per-slot attestation index. Uses padded slot for lexicographic ordering. */
+  private getSlotSignerKey(slot: SlotNumber, signerAddress: string): string {
+    const slotStr = new Fr(slot).toString();
+    return `${slotStr}-${signerAddress}`;
+  }
+
   /** Number of bits reserved for indexWithinCheckpoint in position keys. */
   private static readonly INDEX_BITS = 10;
   /** Maximum indexWithinCheckpoint value (2^10 - 1 = 1023). */
@@ -166,21 +182,21 @@ export class AttestationPool {
       // Check if already exists
       const alreadyExists = await this.blockProposals.hasAsync(proposalId);
       if (alreadyExists) {
-        const totalForPosition = await this.getBlockProposalCountForPosition(
+        const count = await this.getBlockProposalCountForPosition(
           blockProposal.slotNumber,
           blockProposal.indexWithinCheckpoint,
         );
-        return { added: false, alreadyExists: true, totalForPosition };
+        return { added: false, alreadyExists: true, count };
       }
 
       // Get current count for position and check cap, do not add if exceeded
-      const totalForPosition = await this.getBlockProposalCountForPosition(
+      const count = await this.getBlockProposalCountForPosition(
         blockProposal.slotNumber,
         blockProposal.indexWithinCheckpoint,
       );
 
-      if (totalForPosition >= MAX_PROPOSALS_PER_POSITION) {
-        return { added: false, alreadyExists: false, totalForPosition };
+      if (count >= MAX_BLOCK_PROPOSALS_PER_POSITION) {
+        return { added: false, alreadyExists: false, count };
       }
 
       // Add the proposal
@@ -195,7 +211,7 @@ export class AttestationPool {
         },
       );
 
-      return { added: true, alreadyExists: false, totalForPosition: totalForPosition + 1 };
+      return { added: true, alreadyExists: false, count: count + 1 };
     });
   }
 
@@ -239,6 +255,13 @@ export class AttestationPool {
     return undefined;
   }
 
+  /** Checks if any block proposals exist for a given slot (at index 0). */
+  public async hasBlockProposalsForSlot(slot: SlotNumber): Promise<boolean> {
+    const positionKey = this.getBlockPositionKey(slot, 0);
+    const count = await this.blockProposalsForSlotAndIndex.getValueCountAsync(positionKey);
+    return count > 0;
+  }
+
   /**
    * Attempts to add a checkpoint proposal to the pool.
    *
@@ -261,14 +284,14 @@ export class AttestationPool {
       // Check if already exists
       const alreadyExists = await this.checkpointProposals.hasAsync(proposalId);
       if (alreadyExists) {
-        const totalForPosition = await this.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
-        return { added: false, alreadyExists: true, totalForPosition };
+        const count = await this.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
+        return { added: false, alreadyExists: true, count };
       }
 
       // Get current count for slot and check cap
-      const totalForPosition = await this.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
-      if (totalForPosition >= MAX_PROPOSALS_PER_SLOT) {
-        return { added: false, alreadyExists: false, totalForPosition };
+      const count = await this.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
+      if (count >= MAX_CHECKPOINT_PROPOSALS_PER_SLOT) {
+        return { added: false, alreadyExists: false, count };
       }
 
       // Add the proposal if cap not exceeded
@@ -279,7 +302,7 @@ export class AttestationPool {
         slotNumber: proposal.slotNumber,
       });
 
-      return { added: true, alreadyExists: false, totalForPosition: totalForPosition + 1 };
+      return { added: true, alreadyExists: false, count: count + 1 };
     });
   }
 
@@ -409,6 +432,14 @@ export class AttestationPool {
         numberOfAttestations++;
       }
 
+      // Clean up per-signer-per-slot index. Keys are formatted as `${Fr(slot).toString()}-${signerAddress}`.
+      // Since Fr pads to fixed-width hex, Fr(oldestSlot) is lexicographically greater than any key with
+      // a smaller slot (even with the signer suffix), so using it as the exclusive end bound is correct.
+      const slotSignerEndKey = new Fr(oldestSlot).toString();
+      for await (const key of this.checkpointAttestationsPerSlotAndSigner.keysAsync({ end: slotSignerEndKey })) {
+        await this.checkpointAttestationsPerSlotAndSigner.delete(key);
+      }
+
       // Delete checkpoint proposals for slots < oldestSlot, using checkpointProposalsForSlot as index
       for await (const slot of this.checkpointProposalsForSlot.keysAsync({ end: oldestSlot })) {
         const proposalIds = await toArray(this.checkpointProposalsForSlot.getValuesAsync(slot));
@@ -445,61 +476,81 @@ export class AttestationPool {
    *
    * This method performs validation and addition in a single call:
    * - Checks if the attestation already exists (returns alreadyExists: true if so)
-   * - Checks if the (slot, proposalId) has reached the attestation cap (returns added: false if so)
+   * - Checks if this signer has reached the per-signer attestation cap for this slot
    * - Adds the attestation if validation passes
    *
    * @param attestation - The checkpoint attestation to add
-   * @param committeeSize - Committee size for the attestation's slot
-   * @returns Result indicating whether the attestation was added and existence info
+   * @returns Result indicating whether the attestation was added, existence info, and count of
+   *          attestations by this signer for this slot (for equivocation detection)
    */
-  public async tryAddCheckpointAttestation(
-    attestation: CheckpointAttestation,
-    committeeSize: number,
-  ): Promise<TryAddResult> {
+  public async tryAddCheckpointAttestation(attestation: CheckpointAttestation): Promise<TryAddResult> {
     const slotNumber = attestation.payload.header.slotNumber;
     const proposalId = attestation.archive.toString();
     const sender = attestation.getSender();
 
     if (!sender) {
-      return { added: false, alreadyExists: false, totalForPosition: 0 };
+      return { added: false, alreadyExists: false, count: 0 };
     }
 
+    const signerAddress = sender.toString();
+
     return await this.store.transactionAsync(async () => {
-      const key = this.getAttestationKey(slotNumber, proposalId, sender.toString());
+      const key = this.getAttestationKey(slotNumber, proposalId, signerAddress);
       const alreadyExists = await this.checkpointAttestations.hasAsync(key);
 
+      // Get count of attestations by this signer for this slot (for duplicate detection)
+      const signerAttestationCount = await this.getSignerAttestationCountForSlot(slotNumber, signerAddress);
+
       if (alreadyExists) {
-        const total = await this.getAttestationCount(slotNumber, proposalId);
-        return { added: false, alreadyExists: true, totalForPosition: total };
+        return {
+          added: false,
+          alreadyExists: true,
+          count: signerAttestationCount,
+        };
       }
 
-      const limit = committeeSize + ATTESTATION_CAP_BUFFER;
-      const currentCount = await this.getAttestationCount(slotNumber, proposalId);
-
-      if (currentCount >= limit) {
-        return { added: false, alreadyExists: false, totalForPosition: currentCount };
+      // Check if this signer has exceeded the per-signer cap for this slot
+      if (signerAttestationCount >= MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER) {
+        this.log.debug(`Rejecting attestation: signer ${signerAddress} exceeded per-slot cap for slot ${slotNumber}`, {
+          slotNumber,
+          signerAddress,
+          proposalId,
+          signerAttestationCount,
+        });
+        return {
+          added: false,
+          alreadyExists: false,
+          count: signerAttestationCount,
+        };
       }
 
+      // Add the attestation
       await this.checkpointAttestations.set(key, attestation.toBuffer());
 
-      this.log.debug(`Added checkpoint attestation for slot ${slotNumber} from ${sender.toString()}`, {
+      // Track this attestation in the per-signer-per-slot index for duplicate detection
+      const slotSignerKey = this.getSlotSignerKey(slotNumber, signerAddress);
+      await this.checkpointAttestationsPerSlotAndSigner.set(slotSignerKey, proposalId);
+
+      this.log.debug(`Added checkpoint attestation for slot ${slotNumber} from ${signerAddress}`, {
         signature: attestation.signature.toString(),
         slotNumber,
-        address: sender.toString(),
+        address: signerAddress,
         proposalId,
       });
-      return { added: true, alreadyExists: false, totalForPosition: currentCount + 1 };
+
+      // Return the new count
+      return {
+        added: true,
+        alreadyExists: false,
+        count: signerAttestationCount + 1,
+      };
     });
   }
 
-  /** Gets the count of attestations for a given (slot, proposalId). */
-  private async getAttestationCount(slot: SlotNumber, proposalId: string): Promise<number> {
-    const range = this.getAttestationKeyRangeForProposal(slot, proposalId);
-    let count = 0;
-    for await (const _ of this.checkpointAttestations.keysAsync(range)) {
-      count++;
-    }
-    return count;
+  /** Gets the count of attestations by a specific signer for a given slot. */
+  private async getSignerAttestationCountForSlot(slot: SlotNumber, signerAddress: string): Promise<number> {
+    const slotSignerKey = this.getSlotSignerKey(slot, signerAddress);
+    return await this.checkpointAttestationsPerSlotAndSigner.getValueCountAsync(slotSignerKey);
   }
 }