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

package/dest/mem_pools/attestation_pool/attestation_pool.js

@@ -1,174 +1,242 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
 import { BlockProposal, CheckpointAttestation, CheckpointProposal } from '@aztec/stdlib/p2p';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 import { PoolInstrumentation, PoolName } from '../instrumentation.js';
-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 = 2;
+export const MAX_BLOCK_PROPOSALS_PER_POSITION = 2;
+/** Maximum attestations a single signer can make per slot before being rejected. */ export const MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER = 2;
 /**
  * Pool for storing attestations and proposals collected by a validator.
  *
  * Attestations and proposals observed via the p2p network are stored for requests
  * from the validator to produce a block, or to serve to other peers.
+ *
+ * Equivocation detection: distinct *signed payload hashes* arriving at the same
+ * position are tracked in the matching index multimap so the equivocation count
+ * reaches 2 even when archive collides on `feeAssetPriceModifier` variants.
+ * Proposal bytes are retained per accepted payload hash, up to the same equivocation
+ * caps, for slashing watchers that need signed P2P proposals.
  */ export class AttestationPool {
     store;
     log;
     metrics;
-    // Checkpoint attestations from attestation key (slot-proposalId-signer) to serialized CheckpointAttestation
-    // Keys are lexicographically sortable allowing range queries by slot or by (slot, proposalId)
-    checkpointAttestations;
-    // Checkpoint proposals from proposal archive to serialized CheckpointProposal
-    checkpointProposals;
-    // Checkpoint proposals indexed by slot for querying all proposals in a slot
-    // Key: slot number, Value: proposal archive strings
-    checkpointProposalsForSlot;
-    // Block proposals from proposal archive to serialized BlockProposal
-    blockProposals;
-    // Block proposals indexed by slot and index-within-checkpoint for duplicate detection
-    // Key: (slot << 10) | indexWithinCheckpoint, Value: archive string
-    blockProposalsForSlotAndIndex;
+    // Checkpoint attestations from `${paddedSlot}-${signer}` to serialized CheckpointAttestation.
+    // Stores the first attestation seen per (slot, signer); subsequent distinct payload
+    // hashes from the same signer are tracked only in `attestationHashesPerSlotAndSigner`
+    // for equivocation detection.
+    attestationPerSlotAndSigner;
+    // Distinct payload hashes seen per (slot, signer) for tracking attestation equivocations.
+    // Key: `${paddedSlot}-${signerAddress}`, Value: CheckpointProposalHash (`0x`-prefixed hex)
+    attestationHashesPerSlotAndSigner;
+    // Checkpoint proposals from `${paddedSlot}-${payloadHash}` to serialized CheckpointProposalCore.
+    // Stores every accepted distinct payload up to MAX_CHECKPOINT_PROPOSALS_PER_SLOT.
+    checkpointProposalsPerSlotAndHash;
+    // Distinct payload hashes seen per slot. Hash collision = duplicate.
+    // Hash count reaching 2 = equivocation.
+    // Key: slot number, Value: CheckpointProposalHash (`0x`-prefixed hex)
+    checkpointProposalHashesPerSlot;
+    // Block proposals from `${paddedSlot}-${paddedIndex}-${payloadHash}` to serialized BlockProposal.
+    // Stores every accepted distinct payload up to MAX_BLOCK_PROPOSALS_PER_POSITION.
+    blockProposalsPerSlotIndexAndHash;
+    // Distinct payload hashes seen per (slot, indexWithinCheckpoint).
+    // Key: slot * (1 << INDEX_BITS) + indexWithinCheckpoint, Value: BlockProposalHash (`0x`-prefixed hex)
+    blockProposalHashesPerSlotAndIndex;
+    // Secondary index from archive root to all retained block proposal keys.
+    blockProposalKeysPerArchive;
     constructor(store, telemetry = getTelemetryClient(), log = createLogger('aztec:attestation_pool')){
         this.store = store;
         this.log = log;
         this.poolStats = async ()=>{
             return {
-                itemCount: await this.checkpointAttestations.sizeAsync()
+                itemCount: await this.attestationPerSlotAndSigner.sizeAsync()
             };
         };
         // Initialize block proposal storage
-        this.blockProposals = store.openMap('proposals');
-        this.blockProposalsForSlotAndIndex = store.openMultiMap('block_proposals_for_slot_and_index');
+        this.blockProposalsPerSlotIndexAndHash = store.openMap('block_proposals_by_slot_index_and_hash');
+        this.blockProposalHashesPerSlotAndIndex = store.openMultiMap('block_proposals_for_slot_and_index');
+        this.blockProposalKeysPerArchive = store.openMultiMap('block_proposals_by_archive');
         // Initialize checkpoint attestations storage
-        this.checkpointAttestations = store.openMap('checkpoint_attestations');
+        this.attestationPerSlotAndSigner = store.openMap('checkpoint_attestations');
+        this.attestationHashesPerSlotAndSigner = store.openMultiMap('checkpoint_attestations_per_slot_and_signer');
         // Initialize checkpoint proposal storage
-        this.checkpointProposals = store.openMap('checkpoint_proposals');
-        this.checkpointProposalsForSlot = store.openMultiMap('checkpoint_proposals_for_slot');
+        this.checkpointProposalsPerSlotAndHash = store.openMap('checkpoint_proposals_by_slot_and_hash');
+        this.checkpointProposalHashesPerSlot = store.openMultiMap('checkpoint_proposals_for_slot');
         this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL, this.poolStats);
     }
     poolStats;
     /** Returns whether the pool is empty. */ async isEmpty() {
-        for await (const _ of this.checkpointAttestations.entriesAsync()){
-            return false;
-        }
-        for await (const _ of this.blockProposals.entriesAsync()){
-            return false;
-        }
-        return true;
+        const [attestationCount, blockProposalCount, checkpointProposalCount] = await Promise.all([
+            this.attestationPerSlotAndSigner.sizeAsync(),
+            this.blockProposalsPerSlotIndexAndHash.sizeAsync(),
+            this.checkpointProposalsPerSlotAndHash.sizeAsync()
+        ]);
+        return attestationCount === 0 && blockProposalCount === 0 && checkpointProposalCount === 0;
     }
-    getProposalKey(slot, proposalId) {
-        const slotStr = typeof slot === 'string' ? slot : new Fr(slot).toString();
-        const proposalIdStr = typeof proposalId === 'string' ? proposalId : Buffer.isBuffer(proposalId) ? Fr.fromBuffer(proposalId).toString() : proposalId.toString();
-        return `${slotStr}-${proposalIdStr}`;
+    /** Number of bits reserved for indexWithinCheckpoint in position keys. */ static INDEX_BITS = 10;
+    /** Maximum indexWithinCheckpoint value (2^10 - 1 = 1023). */ static MAX_INDEX = (1 << AttestationPool.INDEX_BITS) - 1;
+    /** Decimal digits used to left-pad slot numbers in string keys.
+   * 10 digits ≈ 3500 years at 36 s/slot, leaving ample headroom. */ static SLOT_PAD_DIGITS = 10;
+    /** Fixed-width decimal slot string for use in composite string keys. */ slotPaddedKey(slot) {
+        return slot.toString().padStart(AttestationPool.SLOT_PAD_DIGITS, '0');
+    }
+    /** Fixed-width decimal index string for use in composite string keys. */ indexPaddedKey(indexWithinCheckpoint) {
+        return indexWithinCheckpoint.toString().padStart(4, '0');
     }
-    getAttestationKey(slot, proposalId, address) {
-        return `${this.getProposalKey(slot, proposalId)}-${address}`;
+    /** Key for retained block proposals. */ getBlockProposalKey(slot, indexWithinCheckpoint, payloadHash) {
+        return `${this.slotPaddedKey(slot)}-${this.indexPaddedKey(indexWithinCheckpoint)}-${payloadHash}`;
     }
-    /** Returns range bounds for querying all attestations for a given slot. */ getAttestationKeyRangeForSlot(slot) {
-        const slotStr = new Fr(slot).toString();
+    /** Range bounds for all retained block proposals in a slot. */ getBlockProposalKeyRangeForSlot(slot) {
         return {
-            start: `${slotStr}-`,
-            end: `${slotStr}-Z`
-        }; // 'Z' sorts after any hex character
+            start: `${this.slotPaddedKey(slot)}-`,
+            end: `${this.slotPaddedKey(slot + 1)}-`
+        };
     }
-    /** Returns range bounds for querying all attestations for a given (slot, proposalId). */ getAttestationKeyRangeForProposal(slot, proposalId) {
-        const proposalKey = this.getProposalKey(slot, proposalId);
+    /** Key for retained checkpoint proposals. */ getCheckpointProposalKey(slot, payloadHash) {
+        return `${this.slotPaddedKey(slot)}-${payloadHash}`;
+    }
+    /** Range bounds for all retained checkpoint proposals in a slot. */ getCheckpointProposalKeyRangeForSlot(slot) {
         return {
-            start: `${proposalKey}-`,
-            end: `${proposalKey}-Z`
+            start: `${this.slotPaddedKey(slot)}-`,
+            end: `${this.slotPaddedKey(slot + 1)}-`
         };
     }
-    /** Number of bits reserved for indexWithinCheckpoint in position keys. */ static INDEX_BITS = 10;
-    /** Maximum indexWithinCheckpoint value (2^10 - 1 = 1023). */ static MAX_INDEX = (1 << AttestationPool.INDEX_BITS) - 1;
-    /** Creates a position key for block proposals: (slot << 10) | indexWithinCheckpoint. */ getBlockPositionKey(slot, indexWithinCheckpoint) {
+    /** Key for the per-(slot, signer) attestation main store and equivocation index. */ getSlotSignerKey(slot, signerAddress) {
+        return `${this.slotPaddedKey(slot)}-${signerAddress}`;
+    }
+    /**
+   * Returns range bounds for querying all attestations for a given slot.
+   * Fixed-width padding ensures the slot prefix sorts cleanly, so using the next
+   * slot's prefix as the upper bound captures exactly the current slot's entries.
+   */ getAttestationKeyRangeForSlot(slot) {
+        return {
+            start: `${this.slotPaddedKey(slot)}-`,
+            end: `${this.slotPaddedKey(slot + 1)}-`
+        };
+    }
+    /** Creates a position key for block proposals: slot * 1024 + indexWithinCheckpoint.
+   * Uses multiplication instead of bit-shift to avoid 32-bit signed integer overflow
+   * (bit-shift overflows after slot ~2^21, roughly 278 days of uptime). */ getBlockPositionKey(slot, indexWithinCheckpoint) {
         if (indexWithinCheckpoint > AttestationPool.MAX_INDEX) {
             throw new Error(`Value for indexWithinCheckpoint ${indexWithinCheckpoint} exceeds maximum ${AttestationPool.MAX_INDEX}`);
         }
-        return slot << AttestationPool.INDEX_BITS | indexWithinCheckpoint;
+        return slot * (1 << AttestationPool.INDEX_BITS) + indexWithinCheckpoint;
+    }
+    /** Returns true if the multimap already contains the given value for the given key. */ async multimapHasValue(map, key, value) {
+        const values = await toArray(map.getValuesAsync(key));
+        return values.includes(value);
     }
     /**
    * Attempts to add a block proposal to the pool.
    *
-   * This method performs validation and addition in a single call:
-   * - Checks if the proposal already exists (returns alreadyExists: true if so)
-   * - Checks if the position has reached the proposal cap (returns added: false if so)
-   * - Adds the proposal if validation passes
+   * - Detects duplicates by signed-payload hash (not archive); a re-broadcast of the
+   *   exact same signed payload returns `alreadyExists: true`.
+   * - Distinct payload hashes at the same `(slot, indexWithinCheckpoint)` are tracked
+   *   in the equivocation index and retained up to the cap.
    *
    * @param blockProposal - The block proposal to add
    * @returns Result indicating whether the proposal was added and duplicate detection info
    */ async tryAddBlockProposal(blockProposal) {
         return await this.store.transactionAsync(async ()=>{
-            const proposalId = blockProposal.archive.toString();
-            // Check if already exists
-            const alreadyExists = await this.blockProposals.hasAsync(proposalId);
-            if (alreadyExists) {
-                const totalForPosition = await this.getBlockProposalCountForPosition(blockProposal.slotNumber, blockProposal.indexWithinCheckpoint);
+            const positionKey = this.getBlockPositionKey(blockProposal.slotNumber, blockProposal.indexWithinCheckpoint);
+            const payloadHash = blockProposal.getPayloadHash();
+            // Hash already tracked => exact same signed payload was already received.
+            if (await this.multimapHasValue(this.blockProposalHashesPerSlotAndIndex, positionKey, payloadHash)) {
+                const count = await this.blockProposalHashesPerSlotAndIndex.getValueCountAsync(positionKey);
                 return {
                     added: false,
                     alreadyExists: true,
-                    totalForPosition
+                    count
                 };
             }
-            // Get current count for position and check cap, do not add if exceeded
-            const totalForPosition = await this.getBlockProposalCountForPosition(blockProposal.slotNumber, blockProposal.indexWithinCheckpoint);
-            if (totalForPosition >= MAX_PROPOSALS_PER_POSITION) {
+            // Cap reached for this position (no more new payload hashes accepted).
+            const count = await this.blockProposalHashesPerSlotAndIndex.getValueCountAsync(positionKey);
+            if (count >= MAX_BLOCK_PROPOSALS_PER_POSITION) {
                 return {
                     added: false,
                     alreadyExists: false,
-                    totalForPosition
+                    count
                 };
             }
-            // Add the proposal
-            await this.addBlockProposal(blockProposal);
+            // Track the new payload hash for equivocation detection.
+            await this.blockProposalHashesPerSlotAndIndex.set(positionKey, payloadHash);
+            const proposalKey = this.getBlockProposalKey(blockProposal.slotNumber, blockProposal.indexWithinCheckpoint, payloadHash);
+            await this.blockProposalsPerSlotIndexAndHash.set(proposalKey, blockProposal.withoutSignedTxs().toBuffer());
+            await this.blockProposalKeysPerArchive.set(blockProposal.archive.toString(), proposalKey);
             this.log.debug(`Added block proposal for slot ${blockProposal.slotNumber} and index ${blockProposal.indexWithinCheckpoint}`, {
-                proposalId,
+                archive: blockProposal.archive.toString(),
+                payloadHash,
                 slotNumber: blockProposal.slotNumber,
                 indexWithinCheckpoint: blockProposal.indexWithinCheckpoint
             });
             return {
                 added: true,
                 alreadyExists: false,
-                totalForPosition: totalForPosition + 1
+                count: count + 1
             };
         });
     }
-    /** Gets the count of block proposals for a given position (slot, indexWithinCheckpoint). */ getBlockProposalCountForPosition(slot, indexWithinCheckpoint) {
-        const positionKey = this.getBlockPositionKey(slot, indexWithinCheckpoint);
-        return this.blockProposalsForSlotAndIndex.getValueCountAsync(positionKey);
-    }
-    /** Internal method - must be called within a transaction. */ async addBlockProposal(blockProposal) {
-        const proposalId = blockProposal.archive.toString();
-        // Strip signedTxs before storing to avoid persisting full tx data
-        await this.blockProposals.set(proposalId, blockProposal.withoutSignedTxs().toBuffer());
-        // Index by slot and position for duplicate detection
-        const positionKey = this.getBlockPositionKey(blockProposal.slotNumber, blockProposal.indexWithinCheckpoint);
-        await this.blockProposalsForSlotAndIndex.set(positionKey, proposalId);
-    }
     /**
-   * Get block proposal by its ID.
+   * Get block proposal by archive root.
    *
-   * @param id - The ID of the block proposal to retrieve. The ID is proposal.payload.archive
+   * Resolves the archive root through the archive index and returns the first
+   * retained proposal for that archive. This lookup is used by block-txs req/resp,
+   * where any retained proposal for the requested archive gives the tx hash list.
    *
-   * @return The block proposal if it exists, otherwise undefined.
-   */ async getBlockProposal(id) {
-        const buffer = await this.blockProposals.getAsync(id);
-        try {
-            if (buffer && buffer.length > 0) {
-                return BlockProposal.fromBuffer(buffer);
+   * @param archiveRoot - The archive root to look up
+   * @return The block proposal if it exists and its archive matches, otherwise undefined.
+   */ async getBlockProposalByArchive(archiveRoot) {
+        for await (const proposalKey of this.blockProposalKeysPerArchive.getValuesAsync(archiveRoot)){
+            const buffer = await this.blockProposalsPerSlotIndexAndHash.getAsync(proposalKey);
+            if (!buffer || buffer.length === 0) {
+                continue;
+            }
+            try {
+                const proposal = BlockProposal.fromBuffer(buffer);
+                if (proposal.archive.toString() === archiveRoot) {
+                    return proposal;
+                }
+            } catch  {
+                continue;
             }
-        } catch  {
-            return undefined;
         }
         return undefined;
     }
+    /** Returns retained signed proposals for a slot. */ async getProposalsForSlot(slot) {
+        const blockProposals = [];
+        const checkpointProposals = [];
+        for await (const [_, buffer] of this.blockProposalsPerSlotIndexAndHash.entriesAsync(this.getBlockProposalKeyRangeForSlot(slot))){
+            try {
+                blockProposals.push(BlockProposal.fromBuffer(buffer));
+            } catch  {
+                continue;
+            }
+        }
+        for await (const [_, buffer] of this.checkpointProposalsPerSlotAndHash.entriesAsync(this.getCheckpointProposalKeyRangeForSlot(slot))){
+            try {
+                checkpointProposals.push(CheckpointProposal.fromBuffer(buffer));
+            } catch  {
+                continue;
+            }
+        }
+        return {
+            blockProposals,
+            checkpointProposals
+        };
+    }
+    /** Checks if any block proposals exist for a given slot (at index 0). */ async hasBlockProposalsForSlot(slot) {
+        const positionKey = this.getBlockPositionKey(slot, 0);
+        const count = await this.blockProposalHashesPerSlotAndIndex.getValueCountAsync(positionKey);
+        return count > 0;
+    }
     /**
    * Attempts to add a checkpoint proposal to the pool.
    *
-   * This method performs validation and addition in a single call:
-   * - Checks if the proposal already exists (returns alreadyExists: true if so)
-   * - Checks if the slot has reached the proposal cap (returns added: false if so)
-   * - Adds the proposal if validation passes
+   * - Detects duplicates by signed-payload hash (not archive); a re-broadcast of the
+   *   exact same signed payload returns `alreadyExists: true`.
+   * - Distinct payload hashes at the same slot are tracked in the equivocation index.
+   *   Distinct payload bytes are retained up to the same cap so slashing watchers
+   *   can recover signed proposals.
    *
    * Note: This method only handles the CheckpointProposalCore. If the original
    * CheckpointProposal contains a lastBlock, the caller should extract it via
@@ -178,89 +246,99 @@ export const ATTESTATION_CAP_BUFFER = 10;
    * @returns Result indicating whether the proposal was added and duplicate detection info
    */ async tryAddCheckpointProposal(proposal) {
         return await this.store.transactionAsync(async ()=>{
-            const proposalId = proposal.archive.toString();
-            // Check if already exists
-            const alreadyExists = await this.checkpointProposals.hasAsync(proposalId);
-            if (alreadyExists) {
-                const totalForPosition = await this.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
+            const slot = proposal.slotNumber;
+            const payloadHash = proposal.getPayloadHash();
+            if (await this.multimapHasValue(this.checkpointProposalHashesPerSlot, slot, payloadHash)) {
+                const count = await this.checkpointProposalHashesPerSlot.getValueCountAsync(slot);
                 return {
                     added: false,
                     alreadyExists: true,
-                    totalForPosition
+                    count
                 };
             }
-            // Get current count for slot and check cap
-            const totalForPosition = await this.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
-            if (totalForPosition >= MAX_PROPOSALS_PER_SLOT) {
+            const count = await this.checkpointProposalHashesPerSlot.getValueCountAsync(slot);
+            if (count >= MAX_CHECKPOINT_PROPOSALS_PER_SLOT) {
                 return {
                     added: false,
                     alreadyExists: false,
-                    totalForPosition
+                    count
                 };
             }
-            // Add the proposal if cap not exceeded
-            await this.addCheckpointProposal(proposal);
-            this.log.debug(`Added checkpoint proposal for slot ${proposal.slotNumber}`, {
-                proposalId,
-                slotNumber: proposal.slotNumber
+            // Track the new payload hash for equivocation detection.
+            await this.checkpointProposalHashesPerSlot.set(slot, payloadHash);
+            await this.checkpointProposalsPerSlotAndHash.set(this.getCheckpointProposalKey(slot, payloadHash), proposal.toBuffer());
+            this.log.debug(`Added checkpoint proposal for slot ${slot}`, {
+                archive: proposal.archive.toString(),
+                payloadHash,
+                slotNumber: slot
             });
             return {
                 added: true,
                 alreadyExists: false,
-                totalForPosition: totalForPosition + 1
+                count: count + 1
             };
         });
     }
-    /** Internal method - must be called within a transaction. */ async addCheckpointProposal(proposal) {
-        const slotKey = proposal.slotNumber;
-        const proposalId = proposal.archive.toString();
-        await this.checkpointProposalsForSlot.set(slotKey, proposalId);
-        await this.checkpointProposals.set(proposalId, proposal.toBuffer());
-    }
     /**
-   * Get checkpoint proposal by its ID.
+   * Get a retained checkpoint proposal stored for the given slot.
+   * If multiple proposals were retained for an equivocation, returns the lowest
+   * payload hash deterministically.
    *
    * Returns a CheckpointProposalCore (without lastBlock info) since the lastBlock
    * is extracted and stored separately as a BlockProposal when added.
    *
-   * @param id - The ID of the checkpoint proposal to retrieve (proposal.archive)
-   * @return The checkpoint proposal core if it exists, otherwise undefined.
-   */ async getCheckpointProposal(id) {
-        const buffer = await this.checkpointProposals.getAsync(id);
-        try {
-            if (buffer && buffer.length > 0) {
-                return CheckpointProposal.fromBuffer(buffer);
+   * @param slot - The slot to look up
+   * @return The checkpoint proposal core if one is stored, otherwise undefined.
+   */ async getCheckpointProposal(slot) {
+        for await (const [_, buffer] of this.checkpointProposalsPerSlotAndHash.entriesAsync(this.getCheckpointProposalKeyRangeForSlot(slot))){
+            try {
+                if (buffer && buffer.length > 0) {
+                    return CheckpointProposal.fromBuffer(buffer);
+                }
+            } catch  {
+                continue;
             }
-        } catch  {
-            return undefined;
         }
         return undefined;
     }
+    /** Returns whether any checkpoint proposal is retained for the given slot. */ async hasCheckpointProposalForSlot(slot) {
+        return await this.getCheckpointProposal(slot) !== undefined;
+    }
     /**
    * Adds own checkpoint attestations to the pool.
-   * Skips validations on number of checkpoint attestations stored for the given slot.
+   * Skips per-signer cap and equivocation tracking; the caller is trusted.
+   * Each (slot, signer) gets a single stored attestation; later additions overwrite.
    */ async addOwnCheckpointAttestations(attestations) {
         await this.store.transactionAsync(async ()=>{
             for (const attestation of attestations){
                 const slotNumber = attestation.payload.header.slotNumber;
-                const proposalId = attestation.archive;
                 const sender = attestation.getSender();
                 // Skip attestations with invalid signatures
                 if (!sender) {
                     this.log.warn(`Skipping own checkpoint attestation with invalid signature for slot ${slotNumber}`, {
                         signature: attestation.signature.toString(),
                         slotNumber,
-                        proposalId
+                        archive: attestation.archive.toString()
                     });
                     continue;
                 }
                 const address = sender.toString();
-                await this.checkpointAttestations.set(this.getAttestationKey(slotNumber, proposalId, address), attestation.toBuffer());
+                const ownKey = this.getSlotSignerKey(slotNumber, address);
+                const payloadHash = attestation.getPayloadHash();
+                // Store the signature in canonical (v ∈ {27, 28}) form; see tryAddCheckpointAttestation.
+                await this.attestationPerSlotAndSigner.set(ownKey, attestation.withNormalizedSignature().toBuffer());
+                this.metrics.trackMempoolItemAdded(ownKey);
+                // Track our own payload hash so that an equivocating attestation from another
+                // peer at the same (slot, signer) is detected as a duplicate.
+                if (!await this.multimapHasValue(this.attestationHashesPerSlotAndSigner, ownKey, payloadHash)) {
+                    await this.attestationHashesPerSlotAndSigner.set(ownKey, payloadHash);
+                }
                 this.log.debug(`Added own checkpoint attestation for slot ${slotNumber} from ${address}`, {
                     signature: attestation.signature.toString(),
                     slotNumber,
                     address,
-                    proposalId
+                    archive: attestation.archive.toString(),
+                    payloadHash
                 });
             }
         });
@@ -268,29 +346,30 @@ export const ATTESTATION_CAP_BUFFER = 10;
     /**
    * Get all checkpoint attestations for a given slot.
    *
+   * Returns one attestation per (slot, signer) — the first seen for each signer.
+   * Later equivocating attestations from the same signer are tracked in the index
+   * but their bytes are not retained.
+   *
    * @param slot - The slot to query
    * @return CheckpointAttestations
    */ async getCheckpointAttestationsForSlot(slot) {
         const range = this.getAttestationKeyRangeForSlot(slot);
         const attestations = [];
-        for await (const [_, buf] of this.checkpointAttestations.entriesAsync(range)){
+        for await (const [_, buf] of this.attestationPerSlotAndSigner.entriesAsync(range)){
             attestations.push(CheckpointAttestation.fromBuffer(buf));
         }
         return attestations;
     }
     /**
-   * Get checkpoint attestations for slot and given proposal.
+   * Get checkpoint attestations for a slot whose signed payload matches the given
+   * proposal payload hash.
    *
    * @param slot - The slot to query
-   * @param proposalId - The proposal to query
-   * @return CheckpointAttestations
-   */ async getCheckpointAttestationsForSlotAndProposal(slot, proposalId) {
-        const range = this.getAttestationKeyRangeForProposal(slot, proposalId);
-        const attestations = [];
-        for await (const [_, buf] of this.checkpointAttestations.entriesAsync(range)){
-            attestations.push(CheckpointAttestation.fromBuffer(buf));
-        }
-        return attestations;
+   * @param proposalPayloadHash - Hex-encoded keccak256 of the target proposal's signed payload
+   * @return CheckpointAttestations whose `getPayloadHash()` matches `proposalPayloadHash`
+   */ async getCheckpointAttestationsForSlotAndProposal(slot, proposalPayloadHash) {
+        const all = await this.getCheckpointAttestationsForSlot(slot);
+        return all.filter((att)=>att.getPayloadHash() === proposalPayloadHash);
     }
     /**
    * Delete all pool data (attestations, proposals) older than the given slot.
@@ -301,38 +380,53 @@ export const ATTESTATION_CAP_BUFFER = 10;
         let numberOfCheckpointProposals = 0;
         let numberOfBlockProposals = 0;
         await this.store.transactionAsync(async ()=>{
-            // Delete checkpoint attestations with slot < oldestSlot
-            // Attestation keys start with Fr(slot).toString(), so we use end bound of Fr(oldestSlot).toString()
-            const attestationEndKey = new Fr(oldestSlot).toString();
-            for await (const key of this.checkpointAttestations.keysAsync({
-                end: attestationEndKey
+            const oldestSlotPadded = this.slotPaddedKey(oldestSlot);
+            // Delete checkpoint attestations whose key < `${oldestSlotPadded}-`. Fixed-width
+            // decimal padding means the slot prefix sorts strictly before any key at that slot.
+            for await (const key of this.attestationPerSlotAndSigner.keysAsync({
+                end: `${oldestSlotPadded}-`
             })){
-                await this.checkpointAttestations.delete(key);
+                await this.attestationPerSlotAndSigner.delete(key);
+                this.metrics.trackMempoolItemRemoved(key);
                 numberOfAttestations++;
             }
-            // Delete checkpoint proposals for slots < oldestSlot, using checkpointProposalsForSlot as index
-            for await (const slot of this.checkpointProposalsForSlot.keysAsync({
+            // Clean up per-signer-per-slot index using the same end bound.
+            for await (const key of this.attestationHashesPerSlotAndSigner.keysAsync({
+                end: `${oldestSlotPadded}-`
+            })){
+                await this.attestationHashesPerSlotAndSigner.delete(key);
+            }
+            // Delete checkpoint proposals for slots < oldestSlot.
+            for await (const slot of this.checkpointProposalHashesPerSlot.keysAsync({
                 end: oldestSlot
             })){
-                const proposalIds = await toArray(this.checkpointProposalsForSlot.getValuesAsync(slot));
-                for (const proposalId of proposalIds){
-                    await this.checkpointProposals.delete(proposalId);
-                    numberOfCheckpointProposals++;
-                }
-                await this.checkpointProposalsForSlot.delete(slot);
+                await this.checkpointProposalHashesPerSlot.delete(slot);
             }
-            // Delete block proposals for slots < oldestSlot, using blockProposalsForSlotAndIndex as index
-            // Key format: (slot << INDEX_BITS) | indexWithinCheckpoint
-            const blockPositionEndKey = oldestSlot << AttestationPool.INDEX_BITS;
-            for await (const positionKey of this.blockProposalsForSlotAndIndex.keysAsync({
+            for await (const key of this.checkpointProposalsPerSlotAndHash.keysAsync({
+                end: `${oldestSlotPadded}-`
+            })){
+                await this.checkpointProposalsPerSlotAndHash.delete(key);
+                numberOfCheckpointProposals++;
+            }
+            // Delete block proposals for slots < oldestSlot, using blockProposalHashesPerSlotAndIndex as index.
+            // Key format: slot * (1 << INDEX_BITS) + indexWithinCheckpoint
+            const blockPositionEndKey = oldestSlot * (1 << AttestationPool.INDEX_BITS);
+            for await (const positionKey of this.blockProposalHashesPerSlotAndIndex.keysAsync({
                 end: blockPositionEndKey
             })){
-                const proposalIds = await toArray(this.blockProposalsForSlotAndIndex.getValuesAsync(positionKey));
-                for (const proposalId of proposalIds){
-                    await this.blockProposals.delete(proposalId);
-                    numberOfBlockProposals++;
+                await this.blockProposalHashesPerSlotAndIndex.delete(positionKey);
+            }
+            for await (const [key, buffer] of this.blockProposalsPerSlotIndexAndHash.entriesAsync({
+                end: `${oldestSlotPadded}-`
+            })){
+                try {
+                    const proposal = BlockProposal.fromBuffer(buffer);
+                    await this.blockProposalKeysPerArchive.deleteValue(proposal.archive.toString(), key);
+                } catch  {
+                // ignore decode errors when cleaning up
                 }
-                await this.blockProposalsForSlotAndIndex.delete(positionKey);
+                await this.blockProposalsPerSlotIndexAndHash.delete(key);
+                numberOfBlockProposals++;
             }
         });
         this.log.verbose(`Deleted old pool data`, {
@@ -345,67 +439,80 @@ export const ATTESTATION_CAP_BUFFER = 10;
     /**
    * Attempts to add a checkpoint attestation to the pool.
    *
-   * 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)
-   * - Adds the attestation if validation passes
+   * - Detects duplicates by signed-payload hash (not archive); a re-broadcast of the
+   *   exact same signed payload from the same signer returns `alreadyExists: true`.
+   * - Distinct payload hashes from the same (slot, signer) are tracked in the
+   *   equivocation index. The first one's bytes are stored; later distinct hashes
+   *   bump `count` so libp2p can fire its duplicate callback.
    *
    * @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
-   */ async tryAddCheckpointAttestation(attestation, committeeSize) {
+   * @returns Result indicating whether the attestation was added, existence info,
+   *          and number of distinct payload hashes by this signer for this slot
+   *          (for equivocation detection).
+   */ async tryAddCheckpointAttestation(attestation) {
         const slotNumber = attestation.payload.header.slotNumber;
-        const proposalId = attestation.archive.toString();
         const sender = attestation.getSender();
         if (!sender) {
             return {
                 added: false,
                 alreadyExists: false,
-                totalForPosition: 0
+                count: 0
             };
         }
+        const signerAddress = sender.toString();
+        const slotSignerKey = this.getSlotSignerKey(slotNumber, signerAddress);
+        const payloadHash = attestation.getPayloadHash();
         return await this.store.transactionAsync(async ()=>{
-            const key = this.getAttestationKey(slotNumber, proposalId, sender.toString());
-            const alreadyExists = await this.checkpointAttestations.hasAsync(key);
-            if (alreadyExists) {
-                const total = await this.getAttestationCount(slotNumber, proposalId);
+            if (await this.multimapHasValue(this.attestationHashesPerSlotAndSigner, slotSignerKey, payloadHash)) {
+                const count = await this.attestationHashesPerSlotAndSigner.getValueCountAsync(slotSignerKey);
                 return {
                     added: false,
                     alreadyExists: true,
-                    totalForPosition: total
+                    count
                 };
             }
-            const limit = committeeSize + ATTESTATION_CAP_BUFFER;
-            const currentCount = await this.getAttestationCount(slotNumber, proposalId);
-            if (currentCount >= limit) {
+            const signerAttestationCount = await this.attestationHashesPerSlotAndSigner.getValueCountAsync(slotSignerKey);
+            if (signerAttestationCount >= MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER) {
+                this.log.debug(`Rejecting attestation: signer ${signerAddress} exceeded per-slot cap for slot ${slotNumber}`, {
+                    slotNumber,
+                    signerAddress,
+                    archive: attestation.archive.toString(),
+                    payloadHash,
+                    signerAttestationCount
+                });
                 return {
                     added: false,
                     alreadyExists: false,
-                    totalForPosition: currentCount
+                    count: signerAttestationCount
                 };
             }
-            await this.checkpointAttestations.set(key, attestation.toBuffer());
-            this.log.debug(`Added checkpoint attestation for slot ${slotNumber} from ${sender.toString()}`, {
+            // Track the new payload hash for equivocation detection.
+            await this.attestationHashesPerSlotAndSigner.set(slotSignerKey, payloadHash);
+            // Only the first distinct payload at (slot, signer) is stored; later
+            // equivocations are detected via the multimap but their bytes are not retained.
+            const alreadyHasStored = await this.attestationPerSlotAndSigner.hasAsync(slotSignerKey);
+            if (!alreadyHasStored) {
+                // Store the signature in canonical (v ∈ {27, 28}) form. `sender` recovered above, so the
+                // signature is non-empty and safe to normalize; this keeps a yParity-encoded (v = 0/1) variant
+                // from a malicious peer or an in-flight byte mutation out of the L1 bundle downstream.
+                await this.attestationPerSlotAndSigner.set(slotSignerKey, attestation.withNormalizedSignature().toBuffer());
+                this.metrics.trackMempoolItemAdded(slotSignerKey);
+            }
+            this.log.debug(`Added checkpoint attestation for slot ${slotNumber} from ${signerAddress}`, {
                 signature: attestation.signature.toString(),
                 slotNumber,
-                address: sender.toString(),
-                proposalId
+                address: signerAddress,
+                archive: attestation.archive.toString(),
+                payloadHash,
+                stored: !alreadyHasStored
             });
             return {
                 added: true,
                 alreadyExists: false,
-                totalForPosition: currentCount + 1
+                count: signerAttestationCount + 1
             };
         });
     }
-    /** Gets the count of attestations for a given (slot, proposalId). */ async getAttestationCount(slot, proposalId) {
-        const range = this.getAttestationKeyRangeForProposal(slot, proposalId);
-        let count = 0;
-        for await (const _ of this.checkpointAttestations.keysAsync(range)){
-            count++;
-        }
-        return count;
-    }
 }
 /** Creates an AttestationPool backed by a temporary store for testing. */ export async function createTestAttestationPool(telemetry) {
     const { openTmpStore } = await import('@aztec/kv-store/lmdb-v2');