@aztec/p2p 0.0.1-commit.b33fc05d0 → 0.0.1-commit.b3d3157a

package/src/mem_pools/attestation_pool/attestation_pool_test_suite.ts

@@ -28,9 +28,16 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     signers = Array.from({ length: NUMBER_OF_SIGNERS_PER_TEST }, () => Secp256k1Signer.random());
   });
 
+  /**
+   * Build attestations from each signer over the *same* signed payload (same header,
+   * archive, feeAssetPriceModifier). Required by the new pool, which deduplicates by
+   * payload hash and treats attestations from different signers as distinct entries
+   * only when the payload itself matches.
+   */
   const createCheckpointAttestationsForSlot = (slotNumber: number, archive?: Fr) => {
     const archiveToUse = archive ?? Fr.random();
-    return signers.map(signer => mockCheckpointAttestation(signer, slotNumber, archiveToUse));
+    const sharedHeader = CheckpointHeader.random({ slotNumber: SlotNumber(slotNumber) });
+    return signers.map(signer => mockCheckpointAttestation(signer, slotNumber, archiveToUse, sharedHeader));
   };
 
   const mockBlockProposalForPool = (
@@ -59,13 +66,17 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     it('should add attestations to pool', async () => {
       const slotNumber = 420;
       const archive = Fr.random();
-      const attestations = signers.slice(0, -1).map(signer => mockCheckpointAttestation(signer, slotNumber, archive));
+      const sharedHeader = CheckpointHeader.random({ slotNumber: SlotNumber(slotNumber) });
+      const attestations = signers
+        .slice(0, -1)
+        .map(signer => mockCheckpointAttestation(signer, slotNumber, archive, sharedHeader));
+      const payloadHash = attestations[0].getPayloadHash();
 
       await ap.addOwnCheckpointAttestations(attestations);
 
       const retrievedAttestations = await ap.getCheckpointAttestationsForSlotAndProposal(
         SlotNumber(slotNumber),
-        archive.toString(),
+        payloadHash,
       );
       expect(retrievedAttestations.length).toBe(attestations.length);
       compareCheckpointAttestations(retrievedAttestations, attestations);
@@ -75,11 +86,16 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       compareCheckpointAttestations(retrievedAttestationsForSlot, attestations);
 
       // Add another one
-      const newAttestation = mockCheckpointAttestation(signers[NUMBER_OF_SIGNERS_PER_TEST - 1], slotNumber, archive);
+      const newAttestation = mockCheckpointAttestation(
+        signers[NUMBER_OF_SIGNERS_PER_TEST - 1],
+        slotNumber,
+        archive,
+        sharedHeader,
+      );
       await ap.addOwnCheckpointAttestations([newAttestation]);
       const retrievedAttestationsAfterAdd = await ap.getCheckpointAttestationsForSlotAndProposal(
         SlotNumber(slotNumber),
-        archive.toString(),
+        payloadHash,
       );
       expect(retrievedAttestationsAfterAdd.length).toBe(attestations.length + 1);
       compareCheckpointAttestations(retrievedAttestationsAfterAdd, [...attestations, newAttestation]);
@@ -92,7 +108,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
       const retreivedAttestationsAfterDelete = await ap.getCheckpointAttestationsForSlotAndProposal(
         SlotNumber(slotNumber),
-        archive.toString(),
+        payloadHash,
       );
       expect(retreivedAttestationsAfterDelete.length).toBe(0);
     });
@@ -108,13 +124,14 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       for (let i = 0; i < NUMBER_OF_SIGNERS_PER_TEST; i++) {
         attestations.push(mockCheckpointAttestation(signer, slotNumber, archive, header));
       }
+      const payloadHash = attestations[0].getPayloadHash();
 
       // Add them to store and check we end up with only one
       await ap.addOwnCheckpointAttestations(attestations);
 
       const retreivedAttestations = await ap.getCheckpointAttestationsForSlotAndProposal(
         SlotNumber(slotNumber),
-        archive.toString(),
+        payloadHash,
       );
       expect(retreivedAttestations.length).toBe(1);
       expect(retreivedAttestations[0].toBuffer()).toEqual(attestations[0].toBuffer());
@@ -122,9 +139,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
       // Try adding them on another operation and check they are still not duplicated
       await ap.addOwnCheckpointAttestations([attestations[0]]);
-      expect(
-        await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(slotNumber), archive.toString()),
-      ).toHaveLength(1);
+      expect(await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(slotNumber), payloadHash)).toHaveLength(1);
     });
 
     it('should store attestations by differing slot', async () => {
@@ -135,9 +150,9 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
       for (const attestation of attestations) {
         const slot = attestation.payload.header.slotNumber;
-        const archive = attestation.archive.toString();
+        const payloadHash = attestation.getPayloadHash();
 
-        const retreivedAttestations = await ap.getCheckpointAttestationsForSlotAndProposal(slot, archive);
+        const retreivedAttestations = await ap.getCheckpointAttestationsForSlotAndProposal(slot, payloadHash);
         expect(retreivedAttestations.length).toBe(1);
         expect(retreivedAttestations[0].toBuffer()).toEqual(attestation.toBuffer());
         expect(retreivedAttestations[0].payload.header.slotNumber).toEqual(slot);
@@ -153,9 +168,9 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
       for (const attestation of attestations) {
         const slot = attestation.payload.header.slotNumber;
-        const proposalId = attestation.archive.toString();
+        const payloadHash = attestation.getPayloadHash();
 
-        const retreivedAttestations = await ap.getCheckpointAttestationsForSlotAndProposal(slot, proposalId);
+        const retreivedAttestations = await ap.getCheckpointAttestationsForSlotAndProposal(slot, payloadHash);
         expect(retreivedAttestations.length).toBe(1);
         expect(retreivedAttestations[0].toBuffer()).toEqual(attestation.toBuffer());
         expect(retreivedAttestations[0].payload.header.slotNumber).toEqual(slot);
@@ -164,21 +179,25 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
     it('should delete attestations older than a given slot', async () => {
       const slotNumbers = [1, 2, 3, 69, 72, 74, 88, 420];
-      const attestations = (
-        await Promise.all(slotNumbers.map(slotNumber => createCheckpointAttestationsForSlot(slotNumber)))
-      ).flat();
-      const proposalId = attestations[0].archive.toString();
+      const attestationsPerSlot = await Promise.all(
+        slotNumbers.map(slotNumber => createCheckpointAttestationsForSlot(slotNumber)),
+      );
+      const attestations = attestationsPerSlot.flat();
+      const payloadHashForSlot1 = attestationsPerSlot[0][0].getPayloadHash();
 
       await ap.addOwnCheckpointAttestations(attestations);
 
-      const attestationsForSlot1 = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(1), proposalId);
+      const attestationsForSlot1 = await ap.getCheckpointAttestationsForSlotAndProposal(
+        SlotNumber(1),
+        payloadHashForSlot1,
+      );
       expect(attestationsForSlot1.length).toBe(signers.length);
 
       await ap.deleteOlderThan(SlotNumber(73));
 
       const attestationsForSlot1AfterDelete = await ap.getCheckpointAttestationsForSlotAndProposal(
         SlotNumber(1),
-        proposalId,
+        payloadHashForSlot1,
       );
       expect(attestationsForSlot1AfterDelete.length).toBe(0);
     });
@@ -189,7 +208,6 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       const slotNumber = 420;
       const archive = Fr.random();
       const proposal = await mockBlockProposalForPool(signers[0], slotNumber, archive);
-      const proposalId = proposal.archive.toString();
 
       const result = await ap.tryAddBlockProposal(proposal);
 
@@ -197,7 +215,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       expect(result.alreadyExists).toBe(false);
       expect(result.count).toBe(1);
 
-      const retrievedProposal = await ap.getBlockProposal(proposalId);
+      const retrievedProposal = await ap.getBlockProposalByArchive(proposal.archive.toString());
 
       expect(retrievedProposal).toBeDefined();
       expect(retrievedProposal!).toEqual(proposal);
@@ -205,33 +223,68 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
     it('should return undefined for non-existent block proposal', async () => {
       const nonExistentId = Fr.random().toString();
-      const retrievedProposal = await ap.getBlockProposal(nonExistentId);
+      const retrievedProposal = await ap.getBlockProposalByArchive(nonExistentId);
       expect(retrievedProposal).toBeUndefined();
     });
 
-    it('should return alreadyExists when adding proposal with same id', async () => {
+    it('should return alreadyExists when re-adding the same signed payload', async () => {
       const slotNumber = 420;
       const archive = Fr.random();
-      const proposal1 = await mockBlockProposalForPool(signers[0], slotNumber, archive);
-      const proposalId = proposal1.archive.toString();
+      const proposal = await mockBlockProposalForPool(signers[0], slotNumber, archive);
 
-      const result1 = await ap.tryAddBlockProposal(proposal1);
+      const result1 = await ap.tryAddBlockProposal(proposal);
       expect(result1.added).toBe(true);
       expect(result1.alreadyExists).toBe(false);
 
-      // Create a new proposal with same archive but different signer
-      const proposal2 = await mockBlockProposalForPool(signers[1], slotNumber, archive);
-
-      const result2 = await ap.tryAddBlockProposal(proposal2);
+      // Re-broadcasting the exact same proposal yields alreadyExists.
+      const result2 = await ap.tryAddBlockProposal(proposal);
       expect(result2.added).toBe(false);
       expect(result2.alreadyExists).toBe(true);
 
-      // Should still have the first proposal
-      const retrievedProposal = await ap.getBlockProposal(proposalId);
+      const retrievedProposal = await ap.getBlockProposalByArchive(proposal.archive.toString());
       expect(retrievedProposal).toBeDefined();
-      expect(retrievedProposal!.toBuffer()).toEqual(proposal1.toBuffer());
+      expect(retrievedProposal!.toBuffer()).toEqual(proposal.toBuffer());
       expect(retrievedProposal!.getSender()?.toString()).toBe(signers[0].address.toString());
     });
+
+    it('should retain an exact duplicate block proposal only once', async () => {
+      const slotNumber = 420;
+      const proposal = await mockBlockProposalForPool(signers[0], slotNumber);
+
+      await ap.tryAddBlockProposal(proposal);
+      await ap.tryAddBlockProposal(proposal);
+
+      const proposals = await ap.getProposalsForSlot(SlotNumber(slotNumber));
+      expect(proposals.blockProposals.map(proposal => proposal.toBuffer())).toEqual([
+        proposal.withoutSignedTxs().toBuffer(),
+      ]);
+    });
+
+    it('should retain all accepted block proposals at a position', async () => {
+      const slotNumber = 420;
+      const blockHeader = makeBlockHeader(1, { slotNumber: SlotNumber(slotNumber) });
+      const proposal1 = await makeBlockProposal({
+        signer: signers[0],
+        blockHeader,
+        archiveRoot: Fr.random(),
+        indexWithinCheckpoint: IndexWithinCheckpoint(1),
+      });
+      const proposal2 = await makeBlockProposal({
+        signer: signers[0],
+        blockHeader,
+        archiveRoot: Fr.random(),
+        indexWithinCheckpoint: IndexWithinCheckpoint(1),
+      });
+
+      await ap.tryAddBlockProposal(proposal1);
+      await ap.tryAddBlockProposal(proposal2);
+
+      const proposals = await ap.getProposalsForSlot(SlotNumber(slotNumber));
+      expect(proposals.blockProposals.map(proposal => proposal.toBuffer())).toEqual(
+        expect.arrayContaining([proposal1.withoutSignedTxs().toBuffer(), proposal2.withoutSignedTxs().toBuffer()]),
+      );
+      expect(await ap.getBlockProposalByArchive(proposal2.archive.toString())).toBeDefined();
+    });
   });
 
   describe('CheckpointProposal in attestation pool', () => {
@@ -239,12 +292,13 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       signer: Secp256k1Signer,
       slotNumber: number,
       archive: Fr = Fr.random(),
+      checkpointHeader?: CheckpointHeader,
     ): Promise<CheckpointProposalCore> => {
-      const checkpointHeader = makeCheckpointHeader(1, { slotNumber: SlotNumber(slotNumber) });
+      const headerToUse = checkpointHeader ?? makeCheckpointHeader(1, { slotNumber: SlotNumber(slotNumber) });
       const blockHeader = makeBlockHeader(1);
       const proposal = await makeCheckpointProposal({
         signer,
-        checkpointHeader,
+        checkpointHeader: headerToUse,
         archiveRoot: archive,
         lastBlock: { blockHeader },
       });
@@ -256,7 +310,6 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       const slotNumber = 420;
       const archive = Fr.random();
       const proposal = await mockCheckpointProposalForPool(signers[0], slotNumber, archive);
-      const proposalId = proposal.archive.toString();
 
       const result = await ap.tryAddCheckpointProposal(proposal);
 
@@ -264,7 +317,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       expect(result.alreadyExists).toBe(false);
       expect(result.count).toBe(1);
 
-      const retrievedProposal = await ap.getCheckpointProposal(proposalId);
+      const retrievedProposal = await ap.getCheckpointProposal(SlotNumber(slotNumber));
 
       expect(retrievedProposal).toBeDefined();
       expect(retrievedProposal!.toBuffer()).toEqual(proposal.toBuffer());
@@ -281,54 +334,136 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         archiveRoot: archive,
         // No lastBlock
       });
-      const proposalId = proposal.archive.toString();
 
       // Add the checkpoint core - block extraction is now caller responsibility
       await ap.tryAddCheckpointProposal(proposal.toCore());
 
       // The checkpoint proposal should be stored
-      const retrievedCheckpointProposal = await ap.getCheckpointProposal(proposalId);
+      const retrievedCheckpointProposal = await ap.getCheckpointProposal(SlotNumber(slotNumber));
       expect(retrievedCheckpointProposal).toBeDefined();
 
       // No block proposal was extracted (it had none anyway)
-      const retrievedBlockProposal = await ap.getBlockProposal(proposalId);
+      const retrievedBlockProposal = await ap.getBlockProposalByArchive(proposal.archive.toString());
       expect(retrievedBlockProposal).toBeUndefined();
     });
 
     it('should return undefined for non-existent checkpoint proposal', async () => {
-      const nonExistentId = Fr.random().toString();
-      const retrievedProposal = await ap.getCheckpointProposal(nonExistentId);
+      const retrievedProposal = await ap.getCheckpointProposal(SlotNumber(99999));
       expect(retrievedProposal).toBeUndefined();
     });
 
-    it('should return alreadyExists when adding proposal with same id', async () => {
+    it('should return alreadyExists when re-adding the same signed payload', async () => {
       const slotNumber = 420;
       const archive = Fr.random();
-      const proposal1 = await mockCheckpointProposalForPool(signers[0], slotNumber, archive);
-      const proposalId = proposal1.archive.toString();
+      const proposal = await mockCheckpointProposalForPool(signers[0], slotNumber, archive);
 
-      const result1 = await ap.tryAddCheckpointProposal(proposal1);
+      const result1 = await ap.tryAddCheckpointProposal(proposal);
       expect(result1.added).toBe(true);
       expect(result1.alreadyExists).toBe(false);
 
-      // Create a new proposal with same archive but different signer
-      const proposal2 = await mockCheckpointProposalForPool(signers[1], slotNumber, archive);
-
-      const result2 = await ap.tryAddCheckpointProposal(proposal2);
+      // Re-broadcasting the exact same signed payload yields alreadyExists.
+      const result2 = await ap.tryAddCheckpointProposal(proposal);
       expect(result2.added).toBe(false);
       expect(result2.alreadyExists).toBe(true);
 
-      // Should still have the first proposal
-      const retrievedProposal = await ap.getCheckpointProposal(proposalId);
+      // Should still have the first proposal stored at the slot
+      const retrievedProposal = await ap.getCheckpointProposal(SlotNumber(slotNumber));
       expect(retrievedProposal).toBeDefined();
-      expect(retrievedProposal!.toBuffer()).toEqual(proposal1.toBuffer());
+      expect(retrievedProposal!.toBuffer()).toEqual(proposal.toBuffer());
       expect(retrievedProposal!.getSender()?.toString()).toBe(signers[0].address.toString());
     });
 
+    it('should treat distinct payloads at the same slot as equivocations (count = 2)', async () => {
+      const slotNumber = 420;
+      // Two proposals at the same slot but with different headers (distinct payloads).
+      const proposal1 = await mockCheckpointProposalForPool(signers[0], slotNumber, Fr.random());
+      const proposal2 = await mockCheckpointProposalForPool(signers[0], slotNumber, Fr.random());
+
+      const result1 = await ap.tryAddCheckpointProposal(proposal1);
+      expect(result1.added).toBe(true);
+      expect(result1.count).toBe(1);
+
+      const result2 = await ap.tryAddCheckpointProposal(proposal2);
+      // The second distinct payload is tracked as an equivocation, count goes to 2,
+      // and both accepted payloads are retained by payload hash.
+      expect(result2.added).toBe(true);
+      expect(result2.alreadyExists).toBe(false);
+      expect(result2.count).toBe(2);
+
+      const retrievedProposal = await ap.getCheckpointProposal(SlotNumber(slotNumber));
+      const expectedProposal = [proposal1, proposal2].sort((a, b) =>
+        a.getPayloadHash().localeCompare(b.getPayloadHash()),
+      )[0];
+      expect(retrievedProposal!.toBuffer()).toEqual(expectedProposal.toBuffer());
+
+      const proposals = await ap.getProposalsForSlot(SlotNumber(slotNumber));
+      expect(proposals.checkpointProposals.map(proposal => proposal.toBuffer())).toEqual(
+        expect.arrayContaining([proposal1.toBuffer(), proposal2.toBuffer()]),
+      );
+    });
+
+    it('should detect equivocation when only feeAssetPriceModifier differs', async () => {
+      const slotNumber = 420;
+      const archive = Fr.random();
+      // Same checkpoint header + archive, but two different feeAssetPriceModifier values.
+      // This is the audit-finding scenario: archive collides but the signed payload differs.
+      const sharedHeader = makeCheckpointHeader(1, { slotNumber: SlotNumber(slotNumber) });
+      const proposalA = await makeCheckpointProposal({
+        signer: signers[0],
+        checkpointHeader: sharedHeader,
+        archiveRoot: archive,
+        feeAssetPriceModifier: 50n,
+      });
+      const proposalB = await makeCheckpointProposal({
+        signer: signers[0],
+        checkpointHeader: sharedHeader,
+        archiveRoot: archive,
+        feeAssetPriceModifier: -50n,
+      });
+
+      const result1 = await ap.tryAddCheckpointProposal(proposalA.toCore());
+      expect(result1.count).toBe(1);
+
+      const result2 = await ap.tryAddCheckpointProposal(proposalB.toCore());
+      // The fix: archive collision no longer hides the equivocation; payload-hash dedup
+      // sees the distinct feeMod and bumps `count` to 2 so libp2p can fire the slash callback.
+      expect(result2.added).toBe(true);
+      expect(result2.alreadyExists).toBe(false);
+      expect(result2.count).toBe(2);
+    });
+
+    it('should delete retained proposals older than a given slot', async () => {
+      const oldSlot = 100;
+      const newSlot = 200;
+      const oldBlock = await mockBlockProposalForPool(signers[0], oldSlot);
+      const newBlock = await mockBlockProposalForPool(signers[1], newSlot);
+      const oldCheckpoint = await mockCheckpointProposalForPool(signers[0], oldSlot);
+      const newCheckpoint = await mockCheckpointProposalForPool(signers[1], newSlot);
+
+      await ap.tryAddBlockProposal(oldBlock);
+      await ap.tryAddBlockProposal(newBlock);
+      await ap.tryAddCheckpointProposal(oldCheckpoint);
+      await ap.tryAddCheckpointProposal(newCheckpoint);
+
+      await ap.deleteOlderThan(SlotNumber(newSlot));
+
+      expect(await ap.getProposalsForSlot(SlotNumber(oldSlot))).toEqual({
+        blockProposals: [],
+        checkpointProposals: [],
+      });
+      const newProposals = await ap.getProposalsForSlot(SlotNumber(newSlot));
+      expect(newProposals.blockProposals.map(proposal => proposal.toBuffer())).toContainEqual(
+        newBlock.withoutSignedTxs().toBuffer(),
+      );
+      expect(newProposals.checkpointProposals.map(proposal => proposal.toBuffer())).toContainEqual(
+        newCheckpoint.toBuffer(),
+      );
+    });
+
     it('should return added=false when exceeding capacity', async () => {
       const slotNumber = 420;
 
-      // Add MAX_CHECKPOINT_PROPOSALS_PER_SLOT proposals
+      // Add MAX_CHECKPOINT_PROPOSALS_PER_SLOT distinct proposals.
       for (let i = 0; i < MAX_CHECKPOINT_PROPOSALS_PER_SLOT; i++) {
         const proposal = await mockCheckpointProposalForPool(signers[i % NUMBER_OF_SIGNERS_PER_TEST], slotNumber);
         const result = await ap.tryAddCheckpointProposal(proposal);
@@ -336,7 +471,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         expect(result.count).toBe(i + 1);
       }
 
-      // The next proposal should not be added
+      // The next proposal should not be added.
       const extraProposal = await mockCheckpointProposalForPool(signers[0], slotNumber);
       const result = await ap.tryAddCheckpointProposal(extraProposal);
       expect(result.added).toBe(false);
@@ -446,12 +581,12 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         const result2 = await ap.tryAddBlockProposal(proposal2);
         expect(result2.count).toBe(2);
 
-        // Add a third proposal for same position
+        // Third proposal for same position should be rejected (cap is 2)
         const proposal3 = await mockBlockProposalWithIndex(signers[2], slotNumber, indexWithinCheckpoint);
         const result3 = await ap.tryAddBlockProposal(proposal3);
 
-        expect(result3.added).toBe(true);
-        expect(result3.count).toBe(3);
+        expect(result3.added).toBe(false);
+        expect(result3.count).toBe(2);
       });
 
       it('should return added=false when exceeding capacity', async () => {
@@ -571,17 +706,17 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         await ap.tryAddBlockProposal(newProposal);
 
         // Verify both proposals exist
-        expect(await ap.getBlockProposal(oldProposal.archive.toString())).toBeDefined();
-        expect(await ap.getBlockProposal(newProposal.archive.toString())).toBeDefined();
+        expect(await ap.getBlockProposalByArchive(oldProposal.archive.toString())).toBeDefined();
+        expect(await ap.getBlockProposalByArchive(newProposal.archive.toString())).toBeDefined();
 
         // Delete slots older than newSlot (should delete oldSlot)
         await ap.deleteOlderThan(SlotNumber(newSlot));
 
         // Old proposal should be deleted from storage
-        expect(await ap.getBlockProposal(oldProposal.archive.toString())).toBeUndefined();
+        expect(await ap.getBlockProposalByArchive(oldProposal.archive.toString())).toBeUndefined();
 
         // New proposal should still exist
-        expect(await ap.getBlockProposal(newProposal.archive.toString())).toBeDefined();
+        expect(await ap.getBlockProposalByArchive(newProposal.archive.toString())).toBeDefined();
       });
     });
 
@@ -590,12 +725,13 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         signer: Secp256k1Signer,
         slotNumber: number,
         archive: Fr = Fr.random(),
+        checkpointHeader?: CheckpointHeader,
       ): Promise<CheckpointProposalCore> => {
-        const checkpointHeader = makeCheckpointHeader(1, { slotNumber: SlotNumber(slotNumber) });
+        const headerToUse = checkpointHeader ?? makeCheckpointHeader(1, { slotNumber: SlotNumber(slotNumber) });
         const blockHeader = makeBlockHeader(1);
         const proposal = await makeCheckpointProposal({
           signer,
-          checkpointHeader,
+          checkpointHeader: headerToUse,
           archiveRoot: archive,
           lastBlock: { blockHeader },
         });
@@ -666,12 +802,12 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         const result2 = await ap.tryAddCheckpointProposal(proposal2);
         expect(result2.count).toBe(2);
 
-        // Add a third proposal for same slot
+        // Third proposal for same slot should be rejected (cap is 2)
         const proposal3 = await mockCheckpointProposalCoreForPool(signers[2], slotNumber);
         const result3 = await ap.tryAddCheckpointProposal(proposal3);
 
-        expect(result3.added).toBe(true);
-        expect(result3.count).toBe(3);
+        expect(result3.added).toBe(false);
+        expect(result3.count).toBe(2);
       });
 
       it('should not count attestations as proposals for duplicate detection', async () => {

package/src/mem_pools/attestation_pool/mocks.ts

@@ -3,11 +3,12 @@ import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer'
 import { Fr } from '@aztec/foundation/curves/bn254';
 import {
   CheckpointAttestation,
+  CheckpointProposal,
   ConsensusPayload,
-  SignatureDomainSeparator,
-  getHashedSignaturePayloadEthSignedMessage,
+  getHashedSignaturePayloadTypedData,
 } from '@aztec/stdlib/p2p';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { TEST_COORDINATION_SIGNATURE_CONTEXT } from '@aztec/stdlib/testing';
 
 import { type LocalAccount, generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 
@@ -37,15 +38,19 @@ export const mockCheckpointAttestation = (
   feeAssetPriceModifier: bigint = 0n,
 ): CheckpointAttestation => {
   header = header ?? CheckpointHeader.random({ slotNumber: SlotNumber(slot) });
-  const payload = new ConsensusPayload(header, archive, feeAssetPriceModifier);
+  const payload = new ConsensusPayload(header, archive, feeAssetPriceModifier, TEST_COORDINATION_SIGNATURE_CONTEXT);
 
-  const attestationHash = getHashedSignaturePayloadEthSignedMessage(
-    payload,
-    SignatureDomainSeparator.checkpointAttestation,
-  );
+  const attestationHash = getHashedSignaturePayloadTypedData(payload);
   const attestationSignature = signer.sign(attestationHash);
 
-  const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.checkpointProposal);
+  const proposal = new CheckpointProposal(
+    header,
+    archive,
+    feeAssetPriceModifier,
+    attestationSignature,
+    TEST_COORDINATION_SIGNATURE_CONTEXT,
+  );
+  const proposalHash = getHashedSignaturePayloadTypedData(proposal);
   const proposerSignature = signer.sign(proposalHash);
 
   return new CheckpointAttestation(payload, attestationSignature, proposerSignature);

package/src/mem_pools/index.ts

@@ -1,6 +1,3 @@
 export { AttestationPool, type AttestationPoolApi } from './attestation_pool/attestation_pool.js';
 export { type MemPools } from './interface.js';
-// Old TxPool exports - kept temporarily for external consumers
-export { type TxPool } from './tx_pool/tx_pool.js';
-// New TxPoolV2 exports
 export { type TxPoolV2, type TxPoolV2Config, type TxPoolV2Events, type AddTxsResult } from './tx_pool_v2/index.js';

package/src/mem_pools/instrumentation.ts

@@ -100,7 +100,11 @@ export class PoolInstrumentation<PoolObject extends Gossipable> {
 
     this.addObjectCounter = createUpDownCounterWithDefault(this.meter, metricsLabels.itemsAdded);
 
-    this.minedDelay = this.meter.createHistogram(metricsLabels.itemMinedDelay);
+    this.minedDelay = this.meter.createHistogram(metricsLabels.itemMinedDelay, {
+      advice: {
+        explicitBucketBoundaries: [100, 500, 1000, 5000, 10000, 30000, 60000, 300000, 600000, 1800000, 3600000],
+      },
+    });
 
     this.meter.addBatchObservableCallback(this.observeStats, [this.objectsInMempool]);
   }

package/src/mem_pools/tx_pool_v2/archive/tx_archive.ts

@@ -1,6 +1,5 @@
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import { ChonkProof } from '@aztec/stdlib/proofs';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
 
 /**
@@ -70,7 +69,7 @@ export class TxArchive {
           }
 
           // Archive the transaction with stripped proof
-          const archivedTx = this.stripProof(tx);
+          const archivedTx = tx.withoutProof();
           const txHash = tx.getTxHash().toString();
           await this.#txs.set(txHash, archivedTx.toBuffer());
           await this.#indices.set(headIdx, txHash);
@@ -101,13 +100,6 @@ export class TxArchive {
     return head - tail;
   }
 
-  /**
-   * Strips the proof from a transaction for archival.
-   */
-  private stripProof(tx: Tx): Tx {
-    return new Tx(tx.txHash, tx.data, ChonkProof.empty(), tx.contractClassLogFields, tx.publicFunctionCalldata);
-  }
-
   private async getHeadIndex(): Promise<number> {
     const entry = await this.#indices.entriesAsync({ limit: 1, reverse: true }).next();
     return (entry.value?.[0] ?? -1) + 1;

package/src/mem_pools/tx_pool_v2/eviction/fee_payer_balance_eviction_rule.ts

@@ -29,7 +29,8 @@ export class FeePayerBalanceEvictionRule implements EvictionRule {
 
       if (context.event === EvictionEvent.BLOCK_MINED) {
         const blockNumber = context.block.getBlockNumber();
-        await this.worldState.syncImmediate(blockNumber);
+        const blockHash = await context.block.hash();
+        await this.worldState.syncImmediate(blockNumber, blockHash);
         return await this.evictForFeePayers(context.feePayers, this.worldState.getSnapshot(blockNumber), pool);
       }
 

package/src/mem_pools/tx_pool_v2/eviction/index.ts

@@ -21,6 +21,7 @@ export { FeePayerBalancePreAddRule } from './fee_payer_balance_pre_add_rule.js';
 export { LowPriorityPreAddRule } from './low_priority_pre_add_rule.js';
 
 // Post-event eviction rules
+export { InsufficientFeePerGasEvictionRule } from './insufficient_fee_per_gas_eviction_rule.js';
 export { InvalidTxsAfterMiningRule } from './invalid_txs_after_mining_rule.js';
 export { InvalidTxsAfterReorgRule } from './invalid_txs_after_reorg_rule.js';
 export { FeePayerBalanceEvictionRule } from './fee_payer_balance_eviction_rule.js';