@aztec/p2p 0.0.1-commit.96dac018d → 0.0.1-commit.993d240

package/dest/mem_pools/attestation_pool/attestation_pool_test_suite.d.ts

@@ -1,3 +1,3 @@
 import { type AttestationPool } from './attestation_pool.js';
 export declare function describeAttestationPool(getAttestationPool: () => AttestationPool): void;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0ZXN0YXRpb25fcG9vbF90ZXN0X3N1aXRlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVtX3Bvb2xzL2F0dGVzdGF0aW9uX3Bvb2wvYXR0ZXN0YXRpb25fcG9vbF90ZXN0X3N1aXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVlBLE9BQU8sRUFDTCxLQUFLLGVBQWUsRUFHckIsTUFBTSx1QkFBdUIsQ0FBQztBQUsvQix3QkFBZ0IsdUJBQXVCLENBQUMsa0JBQWtCLEVBQUUsTUFBTSxlQUFlLFFBMnJCaEYifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0ZXN0YXRpb25fcG9vbF90ZXN0X3N1aXRlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVtX3Bvb2xzL2F0dGVzdGF0aW9uX3Bvb2wvYXR0ZXN0YXRpb25fcG9vbF90ZXN0X3N1aXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVlBLE9BQU8sRUFDTCxLQUFLLGVBQWUsRUFHckIsTUFBTSx1QkFBdUIsQ0FBQztBQUsvQix3QkFBZ0IsdUJBQXVCLENBQUMsa0JBQWtCLEVBQUUsTUFBTSxlQUFlLFFBbTBCaEYifQ==

package/dest/mem_pools/attestation_pool/attestation_pool_test_suite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attestation_pool_test_suite.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/attestation_pool_test_suite.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,KAAK,eAAe,EAGrB,MAAM,uBAAuB,CAAC;AAK/B,wBAAgB,uBAAuB,CAAC,kBAAkB,EAAE,MAAM,eAAe,QA2rBhF"}
+{"version":3,"file":"attestation_pool_test_suite.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/attestation_pool_test_suite.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,KAAK,eAAe,EAGrB,MAAM,uBAAuB,CAAC;AAK/B,wBAAgB,uBAAuB,CAAC,kBAAkB,EAAE,MAAM,eAAe,QAm0BhF"}

package/dest/mem_pools/attestation_pool/attestation_pool_test_suite.js

@@ -15,9 +15,17 @@ export function describeAttestationPool(getAttestationPool) {
             length: NUMBER_OF_SIGNERS_PER_TEST
         }, ()=>Secp256k1Signer.random());
     });
-    const createCheckpointAttestationsForSlot = (slotNumber, archive)=>{
+    /**
+   * 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, archive)=>{
         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 = (signer, slotNumber, archive = Fr.random())=>{
         const header = makeBlockHeader(1, {
@@ -41,20 +49,24 @@ export function describeAttestationPool(getAttestationPool) {
         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());
+            const retrievedAttestations = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(slotNumber), payloadHash);
             expect(retrievedAttestations.length).toBe(attestations.length);
             compareCheckpointAttestations(retrievedAttestations, attestations);
             const retrievedAttestationsForSlot = await ap.getCheckpointAttestationsForSlot(SlotNumber(slotNumber));
             expect(retrievedAttestationsForSlot.length).toBe(attestations.length);
             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());
+            const retrievedAttestationsAfterAdd = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(slotNumber), payloadHash);
             expect(retrievedAttestationsAfterAdd.length).toBe(attestations.length + 1);
             compareCheckpointAttestations(retrievedAttestationsAfterAdd, [
                 ...attestations,
@@ -68,7 +80,7 @@ export function describeAttestationPool(getAttestationPool) {
             ]);
             // Delete by slot
             await ap.deleteOlderThan(SlotNumber(slotNumber + 1));
-            const retreivedAttestationsAfterDelete = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(slotNumber), archive.toString());
+            const retreivedAttestationsAfterDelete = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(slotNumber), payloadHash);
             expect(retreivedAttestationsAfterDelete.length).toBe(0);
         });
         it('should handle duplicate proposals in a slot', async ()=>{
@@ -83,9 +95,10 @@ export function describeAttestationPool(getAttestationPool) {
             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());
+            const retreivedAttestations = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(slotNumber), payloadHash);
             expect(retreivedAttestations.length).toBe(1);
             expect(retreivedAttestations[0].toBuffer()).toEqual(attestations[0].toBuffer());
             expect(retreivedAttestations[0].getSender()?.toString()).toEqual(signer.address.toString());
@@ -93,7 +106,7 @@ export function describeAttestationPool(getAttestationPool) {
             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 ()=>{
             const slotNumbers = [
@@ -106,8 +119,8 @@ export function describeAttestationPool(getAttestationPool) {
             await ap.addOwnCheckpointAttestations(attestations);
             for (const attestation of attestations){
                 const slot = attestation.payload.header.slotNumber;
-                const archive = attestation.archive.toString();
-                const retreivedAttestations = await ap.getCheckpointAttestationsForSlotAndProposal(slot, archive);
+                const payloadHash = attestation.getPayloadHash();
+                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);
@@ -130,8 +143,8 @@ export function describeAttestationPool(getAttestationPool) {
             await ap.addOwnCheckpointAttestations(attestations);
             for (const attestation of attestations){
                 const slot = attestation.payload.header.slotNumber;
-                const proposalId = attestation.archive.toString();
-                const retreivedAttestations = await ap.getCheckpointAttestationsForSlotAndProposal(slot, proposalId);
+                const payloadHash = attestation.getPayloadHash();
+                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);
@@ -148,13 +161,14 @@ export function describeAttestationPool(getAttestationPool) {
                 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);
+            const attestationsForSlot1AfterDelete = await ap.getCheckpointAttestationsForSlotAndProposal(SlotNumber(1), payloadHashForSlot1);
             expect(attestationsForSlot1AfterDelete.length).toBe(0);
         });
     });
@@ -163,49 +177,81 @@ export function describeAttestationPool(getAttestationPool) {
             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);
             expect(result.added).toBe(true);
             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);
         });
         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 result1 = await ap.tryAddBlockProposal(proposal1);
+            const proposal = await mockBlockProposalForPool(signers[0], slotNumber, archive);
+            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', ()=>{
-        const mockCheckpointProposalForPool = async (signer, slotNumber, archive = Fr.random())=>{
-            const checkpointHeader = makeCheckpointHeader(1, {
+        const mockCheckpointProposalForPool = async (signer, slotNumber, archive = Fr.random(), checkpointHeader)=>{
+            const headerToUse = checkpointHeader ?? makeCheckpointHeader(1, {
                 slotNumber: SlotNumber(slotNumber)
             });
             const blockHeader = makeBlockHeader(1);
             const proposal = await makeCheckpointProposal({
                 signer,
-                checkpointHeader,
+                checkpointHeader: headerToUse,
                 archiveRoot: archive,
                 lastBlock: {
                     blockHeader
@@ -218,12 +264,11 @@ export function describeAttestationPool(getAttestationPool) {
             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);
             expect(result.added).toBe(true);
             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());
         });
@@ -239,50 +284,121 @@ export function describeAttestationPool(getAttestationPool) {
                 checkpointHeader,
                 archiveRoot: archive
             });
-            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 result1 = await ap.tryAddCheckpointProposal(proposal1);
+            const proposal = await mockCheckpointProposalForPool(signers[0], slotNumber, archive);
+            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);
                 expect(result.added).toBe(true);
                 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);
@@ -367,11 +483,11 @@ export function describeAttestationPool(getAttestationPool) {
                 const proposal2 = await mockBlockProposalWithIndex(signers[1], slotNumber, indexWithinCheckpoint);
                 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 ()=>{
                 const slotNumber = 100;
@@ -462,25 +578,25 @@ export function describeAttestationPool(getAttestationPool) {
                 await ap.tryAddBlockProposal(oldProposal);
                 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();
             });
         });
         describe('tryAddCheckpointProposal duplicate detection', ()=>{
-            const mockCheckpointProposalCoreForPool = async (signer, slotNumber, archive = Fr.random())=>{
-                const checkpointHeader = makeCheckpointHeader(1, {
+            const mockCheckpointProposalCoreForPool = async (signer, slotNumber, archive = Fr.random(), checkpointHeader)=>{
+                const headerToUse = checkpointHeader ?? makeCheckpointHeader(1, {
                     slotNumber: SlotNumber(slotNumber)
                 });
                 const blockHeader = makeBlockHeader(1);
                 const proposal = await makeCheckpointProposal({
                     signer,
-                    checkpointHeader,
+                    checkpointHeader: headerToUse,
                     archiveRoot: archive,
                     lastBlock: {
                         blockHeader
@@ -537,11 +653,11 @@ export function describeAttestationPool(getAttestationPool) {
                 const proposal2 = await mockCheckpointProposalCoreForPool(signers[1], slotNumber);
                 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 ()=>{
                 const slotNumber = 100;

package/dest/mem_pools/attestation_pool/mocks.d.ts

@@ -239,4 +239,4 @@ export declare const generateAccount: () => {
  * @returns A Checkpoint Attestation
  */
 export declare const mockCheckpointAttestation: (signer: Secp256k1Signer, slot?: number, archive?: Fr, header?: CheckpointHeader | undefined, feeAssetPriceModifier?: bigint) => CheckpointAttestation;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9ja3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvYXR0ZXN0YXRpb25fcG9vbC9tb2Nrcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUNqRixPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxFQUNMLHFCQUFxQixFQUl0QixNQUFNLG1CQUFtQixDQUFDO0FBQzNCLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBSXhEOzs7O0dBSUc7QUFDSCxlQUFPLE1BQU0sZUFBZTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBRzNCLENBQUM7QUFFRjs7Ozs7OztHQU9HO0FBQ0gsZUFBTyxNQUFNLHlCQUF5Qix3SkFvQnJDLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9ja3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvYXR0ZXN0YXRpb25fcG9vbC9tb2Nrcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUNqRixPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxFQUNMLHFCQUFxQixFQUl0QixNQUFNLG1CQUFtQixDQUFDO0FBQzNCLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBS3hEOzs7O0dBSUc7QUFDSCxlQUFPLE1BQU0sZUFBZTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBRzNCLENBQUM7QUFFRjs7Ozs7OztHQU9HO0FBQ0gsZUFBTyxNQUFNLHlCQUF5Qix3SkF3QnJDLENBQUMifQ==

package/dest/mem_pools/attestation_pool/mocks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mocks.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/mocks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EACL,qBAAqB,EAItB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAIxD;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG3B,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,wJAoBrC,CAAC"}
+{"version":3,"file":"mocks.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/mocks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EACL,qBAAqB,EAItB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAKxD;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG3B,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,wJAwBrC,CAAC"}

package/dest/mem_pools/attestation_pool/mocks.js

@@ -1,7 +1,8 @@
 import { SlotNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { CheckpointAttestation, ConsensusPayload, SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from '@aztec/stdlib/p2p';
+import { CheckpointAttestation, CheckpointProposal, ConsensusPayload, getHashedSignaturePayloadTypedData } from '@aztec/stdlib/p2p';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { TEST_COORDINATION_SIGNATURE_CONTEXT } from '@aztec/stdlib/testing';
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 /** Generate Account
  *
@@ -22,10 +23,11 @@ import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
     header = header ?? CheckpointHeader.random({
         slotNumber: SlotNumber(slot)
     });
-    const payload = new ConsensusPayload(header, archive, feeAssetPriceModifier);
-    const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.checkpointAttestation);
+    const payload = new ConsensusPayload(header, archive, feeAssetPriceModifier, TEST_COORDINATION_SIGNATURE_CONTEXT);
+    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/dest/mem_pools/index.d.ts

@@ -1,5 +1,4 @@
 export { AttestationPool, type AttestationPoolApi } from './attestation_pool/attestation_pool.js';
 export { type MemPools } from './interface.js';
-export { type TxPool } from './tx_pool/tx_pool.js';
 export { type TxPoolV2, type TxPoolV2Config, type TxPoolV2Events, type AddTxsResult } from './tx_pool_v2/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tZW1fcG9vbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxLQUFLLGtCQUFrQixFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFDbEcsT0FBTyxFQUFFLEtBQUssUUFBUSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFL0MsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFbkQsT0FBTyxFQUFFLEtBQUssUUFBUSxFQUFFLEtBQUssY0FBYyxFQUFFLEtBQUssY0FBYyxFQUFFLEtBQUssWUFBWSxFQUFFLE1BQU0sdUJBQXVCLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tZW1fcG9vbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxLQUFLLGtCQUFrQixFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFDbEcsT0FBTyxFQUFFLEtBQUssUUFBUSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDL0MsT0FBTyxFQUFFLEtBQUssUUFBUSxFQUFFLEtBQUssY0FBYyxFQUFFLEtBQUssY0FBYyxFQUFFLEtBQUssWUFBWSxFQUFFLE1BQU0sdUJBQXVCLENBQUMifQ==

package/dest/mem_pools/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mem_pools/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAClG,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mem_pools/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAClG,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC"}

package/dest/mem_pools/instrumentation.d.ts

@@ -23,12 +23,14 @@ export declare class PoolInstrumentation<PoolObject extends Gossipable> {
     private dbMetrics;
     private defaultAttributes;
     private meter;
-    private txAddedTimestamp;
+    private mempoolItemAddedTimestamp;
     constructor(telemetry: TelemetryClient, name: PoolName, poolStats: PoolStatsCallback, dbStats?: LmdbStatsCallback);
     recordSize(poolObject: PoolObject): void;
     incrementAddedObjects(count: number): void;
     transactionsAdded(transactions: Tx[]): void;
     transactionsRemoved(hashes: Iterable<bigint> | Iterable<string>): void;
+    trackMempoolItemAdded(key: bigint | string): void;
+    trackMempoolItemRemoved(key: bigint | string): void;
     private observeStats;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zdHJ1bWVudGF0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWVtX3Bvb2xzL2luc3RydW1lbnRhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNwRCxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUMzQyxPQUFPLEVBS0wsS0FBSyxpQkFBaUIsRUFLdEIsS0FBSyxlQUFlLEVBR3JCLE1BQU0seUJBQXlCLENBQUM7QUFFakMsb0JBQVksUUFBUTtJQUNsQixPQUFPLFdBQVc7SUFDbEIsZ0JBQWdCLG9CQUFvQjtDQUNyQztBQWtDRCxNQUFNLE1BQU0saUJBQWlCLEdBQUcsTUFBTSxPQUFPLENBQUM7SUFDNUMsU0FBUyxFQUFFLE1BQU0sR0FBRyxNQUFNLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0NBQzVDLENBQUMsQ0FBQztBQUVIOztHQUVHO0FBQ0gscUJBQWEsbUJBQW1CLENBQUMsVUFBVSxTQUFTLFVBQVU7SUFtQjFELE9BQU8sQ0FBQyxTQUFTO0lBbEJuQix1Q0FBdUM7SUFDdkMsT0FBTyxDQUFDLGdCQUFnQixDQUFrQjtJQUMxQyxPQUFPLENBQUMsZ0JBQWdCLENBQWdCO0lBQ3hDLHFCQUFxQjtJQUNyQixPQUFPLENBQUMsVUFBVSxDQUFZO0lBQzlCLHdEQUF3RDtJQUN4RCxPQUFPLENBQUMsVUFBVSxDQUFZO0lBRTlCLE9BQU8sQ0FBQyxTQUFTLENBQWM7SUFFL0IsT0FBTyxDQUFDLGlCQUFpQixDQUFDO0lBQzFCLE9BQU8sQ0FBQyxLQUFLLENBQVE7SUFFckIsT0FBTyxDQUFDLGdCQUFnQixDQUFrRDtJQUUxRSxZQUNFLFNBQVMsRUFBRSxlQUFlLEVBQzFCLElBQUksRUFBRSxRQUFRLEVBQ04sU0FBUyxFQUFFLGlCQUFpQixFQUNwQyxPQUFPLENBQUMsRUFBRSxpQkFBaUIsRUF3QjVCO0lBRU0sVUFBVSxDQUFDLFVBQVUsRUFBRSxVQUFVLFFBRXZDO0lBRU0scUJBQXFCLENBQUMsS0FBSyxFQUFFLE1BQU0sUUFFekM7SUFFTSxpQkFBaUIsQ0FBQyxZQUFZLEVBQUUsRUFBRSxFQUFFLFFBSzFDO0lBRU0sbUJBQW1CLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQyxNQUFNLENBQUMsR0FBRyxRQUFRLENBQUMsTUFBTSxDQUFDLFFBWXJFO0lBRUQsT0FBTyxDQUFDLFlBQVksQ0FZbEI7Q0FDSCJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zdHJ1bWVudGF0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWVtX3Bvb2xzL2luc3RydW1lbnRhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNwRCxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUMzQyxPQUFPLEVBS0wsS0FBSyxpQkFBaUIsRUFLdEIsS0FBSyxlQUFlLEVBR3JCLE1BQU0seUJBQXlCLENBQUM7QUFFakMsb0JBQVksUUFBUTtJQUNsQixPQUFPLFdBQVc7SUFDbEIsZ0JBQWdCLG9CQUFvQjtDQUNyQztBQWtDRCxNQUFNLE1BQU0saUJBQWlCLEdBQUcsTUFBTSxPQUFPLENBQUM7SUFDNUMsU0FBUyxFQUFFLE1BQU0sR0FBRyxNQUFNLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0NBQzVDLENBQUMsQ0FBQztBQUVIOztHQUVHO0FBQ0gscUJBQWEsbUJBQW1CLENBQUMsVUFBVSxTQUFTLFVBQVU7SUFtQjFELE9BQU8sQ0FBQyxTQUFTO0lBbEJuQix1Q0FBdUM7SUFDdkMsT0FBTyxDQUFDLGdCQUFnQixDQUFrQjtJQUMxQyxPQUFPLENBQUMsZ0JBQWdCLENBQWdCO0lBQ3hDLHFCQUFxQjtJQUNyQixPQUFPLENBQUMsVUFBVSxDQUFZO0lBQzlCLHdEQUF3RDtJQUN4RCxPQUFPLENBQUMsVUFBVSxDQUFZO0lBRTlCLE9BQU8sQ0FBQyxTQUFTLENBQWM7SUFFL0IsT0FBTyxDQUFDLGlCQUFpQixDQUFDO0lBQzFCLE9BQU8sQ0FBQyxLQUFLLENBQVE7SUFFckIsT0FBTyxDQUFDLHlCQUF5QixDQUFvRTtJQUVyRyxZQUNFLFNBQVMsRUFBRSxlQUFlLEVBQzFCLElBQUksRUFBRSxRQUFRLEVBQ04sU0FBUyxFQUFFLGlCQUFpQixFQUNwQyxPQUFPLENBQUMsRUFBRSxpQkFBaUIsRUE0QjVCO0lBRU0sVUFBVSxDQUFDLFVBQVUsRUFBRSxVQUFVLFFBRXZDO0lBRU0scUJBQXFCLENBQUMsS0FBSyxFQUFFLE1BQU0sUUFFekM7SUFFTSxpQkFBaUIsQ0FBQyxZQUFZLEVBQUUsRUFBRSxFQUFFLFFBRTFDO0lBRU0sbUJBQW1CLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQyxNQUFNLENBQUMsR0FBRyxRQUFRLENBQUMsTUFBTSxDQUFDLFFBSXJFO0lBRU0scUJBQXFCLENBQUMsR0FBRyxFQUFFLE1BQU0sR0FBRyxNQUFNLEdBQUcsSUFBSSxDQUV2RDtJQUVNLHVCQUF1QixDQUFDLEdBQUcsRUFBRSxNQUFNLEdBQUcsTUFBTSxHQUFHLElBQUksQ0FTekQ7SUFFRCxPQUFPLENBQUMsWUFBWSxDQVlsQjtDQUNIIn0=

package/dest/mem_pools/instrumentation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/mem_pools/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAKL,KAAK,iBAAiB,EAKtB,KAAK,eAAe,EAGrB,MAAM,yBAAyB,CAAC;AAEjC,oBAAY,QAAQ;IAClB,OAAO,WAAW;IAClB,gBAAgB,oBAAoB;CACrC;AAkCD,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,CAAC;IAC5C,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5C,CAAC,CAAC;AAEH;;GAEG;AACH,qBAAa,mBAAmB,CAAC,UAAU,SAAS,UAAU;IAmB1D,OAAO,CAAC,SAAS;IAlBnB,uCAAuC;IACvC,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,OAAO,CAAC,gBAAgB,CAAgB;IACxC,qBAAqB;IACrB,OAAO,CAAC,UAAU,CAAY;IAC9B,wDAAwD;IACxD,OAAO,CAAC,UAAU,CAAY;IAE9B,OAAO,CAAC,SAAS,CAAc;IAE/B,OAAO,CAAC,iBAAiB,CAAC;IAC1B,OAAO,CAAC,KAAK,CAAQ;IAErB,OAAO,CAAC,gBAAgB,CAAkD;IAE1E,YACE,SAAS,EAAE,eAAe,EAC1B,IAAI,EAAE,QAAQ,EACN,SAAS,EAAE,iBAAiB,EACpC,OAAO,CAAC,EAAE,iBAAiB,EAwB5B;IAEM,UAAU,CAAC,UAAU,EAAE,UAAU,QAEvC;IAEM,qBAAqB,CAAC,KAAK,EAAE,MAAM,QAEzC;IAEM,iBAAiB,CAAC,YAAY,EAAE,EAAE,EAAE,QAK1C;IAEM,mBAAmB,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,QAYrE;IAED,OAAO,CAAC,YAAY,CAYlB;CACH"}
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/mem_pools/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAKL,KAAK,iBAAiB,EAKtB,KAAK,eAAe,EAGrB,MAAM,yBAAyB,CAAC;AAEjC,oBAAY,QAAQ;IAClB,OAAO,WAAW;IAClB,gBAAgB,oBAAoB;CACrC;AAkCD,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,CAAC;IAC5C,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5C,CAAC,CAAC;AAEH;;GAEG;AACH,qBAAa,mBAAmB,CAAC,UAAU,SAAS,UAAU;IAmB1D,OAAO,CAAC,SAAS;IAlBnB,uCAAuC;IACvC,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,OAAO,CAAC,gBAAgB,CAAgB;IACxC,qBAAqB;IACrB,OAAO,CAAC,UAAU,CAAY;IAC9B,wDAAwD;IACxD,OAAO,CAAC,UAAU,CAAY;IAE9B,OAAO,CAAC,SAAS,CAAc;IAE/B,OAAO,CAAC,iBAAiB,CAAC;IAC1B,OAAO,CAAC,KAAK,CAAQ;IAErB,OAAO,CAAC,yBAAyB,CAAoE;IAErG,YACE,SAAS,EAAE,eAAe,EAC1B,IAAI,EAAE,QAAQ,EACN,SAAS,EAAE,iBAAiB,EACpC,OAAO,CAAC,EAAE,iBAAiB,EA4B5B;IAEM,UAAU,CAAC,UAAU,EAAE,UAAU,QAEvC;IAEM,qBAAqB,CAAC,KAAK,EAAE,MAAM,QAEzC;IAEM,iBAAiB,CAAC,YAAY,EAAE,EAAE,EAAE,QAE1C;IAEM,mBAAmB,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,QAIrE;IAEM,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEvD;IAEM,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CASzD;IAED,OAAO,CAAC,YAAY,CAYlB;CACH"}

package/dest/mem_pools/instrumentation.js

@@ -37,10 +37,10 @@ export var PoolName = /*#__PURE__*/ function(PoolName) {
     dbMetrics;
     defaultAttributes;
     meter;
-    txAddedTimestamp;
+    mempoolItemAddedTimestamp;
     constructor(telemetry, name, poolStats, dbStats){
         this.poolStats = poolStats;
-        this.txAddedTimestamp = new Map();
+        this.mempoolItemAddedTimestamp = new Map();
         this.observeStats = async (observer)=>{
             const { itemCount } = await this.poolStats();
             if (typeof itemCount === 'number') {
@@ -65,7 +65,23 @@ export var PoolName = /*#__PURE__*/ function(PoolName) {
             [Attributes.DB_DATA_TYPE]: 'tx-pool'
         }, dbStats);
         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
         ]);
@@ -77,21 +93,23 @@ export var PoolName = /*#__PURE__*/ function(PoolName) {
         this.addObjectCounter.add(count);
     }
     transactionsAdded(transactions) {
-        const timestamp = Date.now();
-        for (const transaction of transactions){
-            this.txAddedTimestamp.set(transaction.txHash.toBigInt(), timestamp);
-        }
+        transactions.forEach((tx)=>this.trackMempoolItemAdded(tx.txHash.toBigInt()));
     }
     transactionsRemoved(hashes) {
-        const timestamp = Date.now();
         for (const hash of hashes){
-            const key = BigInt(hash);
-            const addedAt = this.txAddedTimestamp.get(key);
-            if (addedAt !== undefined) {
-                this.txAddedTimestamp.delete(key);
-                if (addedAt < timestamp) {
-                    this.minedDelay.record(timestamp - addedAt);
-                }
+            this.trackMempoolItemRemoved(BigInt(hash));
+        }
+    }
+    trackMempoolItemAdded(key) {
+        this.mempoolItemAddedTimestamp.set(key, Date.now());
+    }
+    trackMempoolItemRemoved(key) {
+        const timestamp = Date.now();
+        const addedAt = this.mempoolItemAddedTimestamp.get(key);
+        if (addedAt !== undefined) {
+            this.mempoolItemAddedTimestamp.delete(key);
+            if (addedAt < timestamp) {
+                this.minedDelay.record(timestamp - addedAt);
             }
         }
     }

package/dest/mem_pools/tx_pool_v2/eviction/fee_payer_balance_eviction_rule.d.ts

@@ -14,4 +14,4 @@ export declare class FeePayerBalanceEvictionRule implements EvictionRule {
     private evictForFeePayers;
     private getEvictionsForFeePayer;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmVlX3BheWVyX2JhbGFuY2VfZXZpY3Rpb25fcnVsZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21lbV9wb29scy90eF9wb29sX3YyL2V2aWN0aW9uL2ZlZV9wYXllcl9iYWxhbmNlX2V2aWN0aW9uX3J1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsT0FBTyxLQUFLLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUk5RSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsY0FBYyxFQUFFLFlBQVksRUFBRSxjQUFjLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUdyRzs7O0dBR0c7QUFDSCxxQkFBYSwyQkFBNEIsWUFBVyxZQUFZO0lBTWxELE9BQU8sQ0FBQyxVQUFVO0lBTDlCLFNBQWdCLElBQUksNkJBQTZCO0lBQ2pELFNBQWdCLE1BQU0sdUJBQXVCO0lBRTdDLE9BQU8sQ0FBQyxHQUFHLENBQWtFO0lBRTdFLFlBQW9CLFVBQVUsRUFBRSxzQkFBc0IsRUFBSTtJQUVwRCxLQUFLLENBQUMsT0FBTyxFQUFFLGVBQWUsRUFBRSxJQUFJLEVBQUUsY0FBYyxHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FnQ25GO1lBRWEsaUJBQWlCO1lBeUJqQix1QkFBdUI7Q0FzQ3RDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmVlX3BheWVyX2JhbGFuY2VfZXZpY3Rpb25fcnVsZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21lbV9wb29scy90eF9wb29sX3YyL2V2aWN0aW9uL2ZlZV9wYXllcl9iYWxhbmNlX2V2aWN0aW9uX3J1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsT0FBTyxLQUFLLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUk5RSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsY0FBYyxFQUFFLFlBQVksRUFBRSxjQUFjLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUdyRzs7O0dBR0c7QUFDSCxxQkFBYSwyQkFBNEIsWUFBVyxZQUFZO0lBTWxELE9BQU8sQ0FBQyxVQUFVO0lBTDlCLFNBQWdCLElBQUksNkJBQTZCO0lBQ2pELFNBQWdCLE1BQU0sdUJBQXVCO0lBRTdDLE9BQU8sQ0FBQyxHQUFHLENBQWtFO0lBRTdFLFlBQW9CLFVBQVUsRUFBRSxzQkFBc0IsRUFBSTtJQUVwRCxLQUFLLENBQUMsT0FBTyxFQUFFLGVBQWUsRUFBRSxJQUFJLEVBQUUsY0FBYyxHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FpQ25GO1lBRWEsaUJBQWlCO1lBeUJqQix1QkFBdUI7Q0FzQ3RDIn0=

package/dest/mem_pools/tx_pool_v2/eviction/fee_payer_balance_eviction_rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fee_payer_balance_eviction_rule.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/eviction/fee_payer_balance_eviction_rule.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAI9E,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGrG;;;GAGG;AACH,qBAAa,2BAA4B,YAAW,YAAY;IAMlD,OAAO,CAAC,UAAU;IAL9B,SAAgB,IAAI,6BAA6B;IACjD,SAAgB,MAAM,uBAAuB;IAE7C,OAAO,CAAC,GAAG,CAAkE;IAE7E,YAAoB,UAAU,EAAE,sBAAsB,EAAI;IAEpD,KAAK,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAgCnF;YAEa,iBAAiB;YAyBjB,uBAAuB;CAsCtC"}
+{"version":3,"file":"fee_payer_balance_eviction_rule.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/eviction/fee_payer_balance_eviction_rule.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAI9E,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGrG;;;GAGG;AACH,qBAAa,2BAA4B,YAAW,YAAY;IAMlD,OAAO,CAAC,UAAU;IAL9B,SAAgB,IAAI,6BAA6B;IACjD,SAAgB,MAAM,uBAAuB;IAE7C,OAAO,CAAC,GAAG,CAAkE;IAE7E,YAAoB,UAAU,EAAE,sBAAsB,EAAI;IAEpD,KAAK,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAiCnF;YAEa,iBAAiB;YAyBjB,uBAAuB;CAsCtC"}