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

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

@@ -1 +1 @@
-{"version":3,"file":"attestation_pool.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/attestation_pool.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"attestation_pool.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/attestation_pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAIpF,OAAO,KAAK,EAAE,iBAAiB,EAAqC,MAAM,iBAAiB,CAAC;AAC5F,OAAO,EACL,aAAa,EACb,qBAAqB,EAErB,KAAK,sBAAsB,EAC5B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAInF,4EAA4E;AAC5E,MAAM,MAAM,YAAY,GAAG;IACzB,iCAAiC;IACjC,KAAK,EAAE,OAAO,CAAC;IACf,6CAA6C;IAC7C,aAAa,EAAE,OAAO,CAAC;IACvB;;;mFAG+E;IAC/E,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,iCAAiC,IAAI,CAAC;AACnD,eAAO,MAAM,gCAAgC,IAAI,CAAC;AAClD,oFAAoF;AACpF,eAAO,MAAM,oCAAoC,IAAI,CAAC;AAEtD,kGAAkG;AAClG,MAAM,MAAM,kBAAkB,GAAG,IAAI,CACnC,eAAe,EACb,qBAAqB,GACrB,kBAAkB,GAClB,0BAA0B,GAC1B,uBAAuB,GACvB,8BAA8B,GAC9B,6BAA6B,GAC7B,iBAAiB,GACjB,kCAAkC,GAClC,6CAA6C,GAC7C,SAAS,CACZ,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,eAAe;IA0BxB,OAAO,CAAC,KAAK;IAEb,OAAO,CAAC,GAAG;IA3Bb,OAAO,CAAC,OAAO,CAA6C;IAI5D,OAAO,CAAC,sBAAsB,CAAgC;IAG9D,OAAO,CAAC,mBAAmB,CAAgC;IAI3D,OAAO,CAAC,0BAA0B,CAAqC;IAGvE,OAAO,CAAC,cAAc,CAAgC;IAItD,OAAO,CAAC,6BAA6B,CAAqC;IAI1E,OAAO,CAAC,sCAAsC,CAAqC;IAEnF,YACU,KAAK,EAAE,iBAAiB,EAChC,SAAS,GAAE,eAAsC,EACzC,GAAG,yCAAyC,EAerD;IAED,OAAO,CAAC,SAAS,CAIf;IAEF,yCAAyC;IAC5B,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,CAQvC;IAED,OAAO,CAAC,cAAc;IAYtB,OAAO,CAAC,iBAAiB;IAIzB,2EAA2E;IAC3E,OAAO,CAAC,6BAA6B;IAKrC,yFAAyF;IACzF,OAAO,CAAC,iCAAiC;IAKzC,gHAAgH;IAChH,OAAO,CAAC,gBAAgB;IAKxB,0EAA0E;IAC1E,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAM;IACxC,6DAA6D;IAC7D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAyC;IAE1E,wFAAwF;IACxF,OAAO,CAAC,mBAAmB;IAS3B;;;;;;;;;;OAUG;IACU,mBAAmB,CAAC,aAAa,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAsCpF;IAED,4FAA4F;IAC5F,OAAO,CAAC,gCAAgC;YAS1B,gBAAgB;IAU9B;;;;;;OAMG;IACU,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAW5E;IAED;;;;;;;;;;;;;;OAcG;IACU,wBAAwB,CAAC,QAAQ,EAAE,sBAAsB,GAAG,OAAO,CAAC,YAAY,CAAC,CA2B7F;YAGa,qBAAqB;IAQnC;;;;;;;;OAQG;IACU,qBAAqB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC,CAW1F;IAED;;;OAGG;IACU,4BAA4B,CAAC,YAAY,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAgC9F;IAED;;;;;OAKG;IACU,gCAAgC,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAShG;IAED;;;;;;OAMG;IACU,2CAA2C,CACtD,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,qBAAqB,EAAE,CAAC,CASlC;IAED;;;;OAIG;IACU,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAmDlE;IAED;;;;;;;;;;;OAWG;IACU,2BAA2B,CAAC,WAAW,EAAE,qBAAqB,GAAG,OAAO,CAAC,YAAY,CAAC,CA8DlG;YAGa,gCAAgC;CAI/C;AAED,0EAA0E;AAC1E,wBAAsB,yBAAyB,CAAC,SAAS,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAIrG"}

package/dest/mem_pools/attestation_pool/attestation_pool.js

@@ -4,9 +4,9 @@ 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 = 5;
+export const MAX_BLOCK_PROPOSALS_PER_POSITION = 3;
+/** Maximum attestations a single signer can make per slot before being rejected. */ export const MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER = 3;
 /**
  * Pool for storing attestations and proposals collected by a validator.
  *
@@ -29,6 +29,9 @@ export const ATTESTATION_CAP_BUFFER = 10;
     // Block proposals indexed by slot and index-within-checkpoint for duplicate detection
     // Key: (slot << 10) | indexWithinCheckpoint, Value: archive string
     blockProposalsForSlotAndIndex;
+    // Checkpoint attestations indexed by (slot, signer) for tracking attestations per (slot, signer) for duplicate detection
+    // Key: `${Fr(slot).toString()}-${signerAddress}` string (padded for lexicographic ordering), Value: `proposalId` strings
+    checkpointAttestationsPerSlotAndSigner;
     constructor(store, telemetry = getTelemetryClient(), log = createLogger('aztec:attestation_pool')){
         this.store = store;
         this.log = log;
@@ -42,6 +45,7 @@ export const ATTESTATION_CAP_BUFFER = 10;
         this.blockProposalsForSlotAndIndex = store.openMultiMap('block_proposals_for_slot_and_index');
         // Initialize checkpoint attestations storage
         this.checkpointAttestations = store.openMap('checkpoint_attestations');
+        this.checkpointAttestationsPerSlotAndSigner = store.openMultiMap('checkpoint_attestations_per_slot_and_signer');
         // Initialize checkpoint proposal storage
         this.checkpointProposals = store.openMap('checkpoint_proposals');
         this.checkpointProposalsForSlot = store.openMultiMap('checkpoint_proposals_for_slot');
@@ -79,6 +83,10 @@ export const ATTESTATION_CAP_BUFFER = 10;
             end: `${proposalKey}-Z`
         };
     }
+    /** Creates a key for the per-signer-per-slot attestation index. Uses padded slot for lexicographic ordering. */ getSlotSignerKey(slot, signerAddress) {
+        const slotStr = new Fr(slot).toString();
+        return `${slotStr}-${signerAddress}`;
+    }
     /** 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) {
@@ -103,20 +111,20 @@ export const ATTESTATION_CAP_BUFFER = 10;
             // Check if already exists
             const alreadyExists = await this.blockProposals.hasAsync(proposalId);
             if (alreadyExists) {
-                const totalForPosition = await this.getBlockProposalCountForPosition(blockProposal.slotNumber, blockProposal.indexWithinCheckpoint);
+                const count = await this.getBlockProposalCountForPosition(blockProposal.slotNumber, blockProposal.indexWithinCheckpoint);
                 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) {
+            const count = await this.getBlockProposalCountForPosition(blockProposal.slotNumber, blockProposal.indexWithinCheckpoint);
+            if (count >= MAX_BLOCK_PROPOSALS_PER_POSITION) {
                 return {
                     added: false,
                     alreadyExists: false,
-                    totalForPosition
+                    count
                 };
             }
             // Add the proposal
@@ -129,7 +137,7 @@ export const ATTESTATION_CAP_BUFFER = 10;
             return {
                 added: true,
                 alreadyExists: false,
-                totalForPosition: totalForPosition + 1
+                count: count + 1
             };
         });
     }
@@ -182,20 +190,20 @@ export const ATTESTATION_CAP_BUFFER = 10;
             // Check if already exists
             const alreadyExists = await this.checkpointProposals.hasAsync(proposalId);
             if (alreadyExists) {
-                const totalForPosition = await this.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
+                const count = await this.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
                 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.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
+            if (count >= MAX_CHECKPOINT_PROPOSALS_PER_SLOT) {
                 return {
                     added: false,
                     alreadyExists: false,
-                    totalForPosition
+                    count
                 };
             }
             // Add the proposal if cap not exceeded
@@ -207,7 +215,7 @@ export const ATTESTATION_CAP_BUFFER = 10;
             return {
                 added: true,
                 alreadyExists: false,
-                totalForPosition: totalForPosition + 1
+                count: count + 1
             };
         });
     }
@@ -310,6 +318,15 @@ export const ATTESTATION_CAP_BUFFER = 10;
                 await this.checkpointAttestations.delete(key);
                 numberOfAttestations++;
             }
+            // Clean up per-signer-per-slot index. Keys are formatted as `${Fr(slot).toString()}-${signerAddress}`.
+            // Since Fr pads to fixed-width hex, Fr(oldestSlot) is lexicographically greater than any key with
+            // a smaller slot (even with the signer suffix), so using it as the exclusive end bound is correct.
+            const slotSignerEndKey = new Fr(oldestSlot).toString();
+            for await (const key of this.checkpointAttestationsPerSlotAndSigner.keysAsync({
+                end: slotSignerEndKey
+            })){
+                await this.checkpointAttestationsPerSlotAndSigner.delete(key);
+            }
             // Delete checkpoint proposals for slots < oldestSlot, using checkpointProposalsForSlot as index
             for await (const slot of this.checkpointProposalsForSlot.keysAsync({
                 end: oldestSlot
@@ -347,13 +364,13 @@ export const ATTESTATION_CAP_BUFFER = 10;
    *
    * This method performs validation and addition in a single call:
    * - Checks if the attestation already exists (returns alreadyExists: true if so)
-   * - Checks if the (slot, proposalId) has reached the attestation cap (returns added: false if so)
+   * - Checks if this signer has reached the per-signer attestation cap for this slot
    * - Adds the attestation if validation passes
    *
    * @param attestation - The checkpoint attestation to add
-   * @param committeeSize - Committee size for the attestation's slot
-   * @returns Result indicating whether the attestation was added and existence info
-   */ async tryAddCheckpointAttestation(attestation, committeeSize) {
+   * @returns Result indicating whether the attestation was added, existence info, and count of
+   *          attestations 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();
@@ -361,50 +378,58 @@ export const ATTESTATION_CAP_BUFFER = 10;
             return {
                 added: false,
                 alreadyExists: false,
-                totalForPosition: 0
+                count: 0
             };
         }
+        const signerAddress = sender.toString();
         return await this.store.transactionAsync(async ()=>{
-            const key = this.getAttestationKey(slotNumber, proposalId, sender.toString());
+            const key = this.getAttestationKey(slotNumber, proposalId, signerAddress);
             const alreadyExists = await this.checkpointAttestations.hasAsync(key);
+            // Get count of attestations by this signer for this slot (for duplicate detection)
+            const signerAttestationCount = await this.getSignerAttestationCountForSlot(slotNumber, signerAddress);
             if (alreadyExists) {
-                const total = await this.getAttestationCount(slotNumber, proposalId);
                 return {
                     added: false,
                     alreadyExists: true,
-                    totalForPosition: total
+                    count: signerAttestationCount
                 };
             }
-            const limit = committeeSize + ATTESTATION_CAP_BUFFER;
-            const currentCount = await this.getAttestationCount(slotNumber, proposalId);
-            if (currentCount >= limit) {
+            // Check if this signer has exceeded the per-signer cap for this slot
+            if (signerAttestationCount >= MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER) {
+                this.log.debug(`Rejecting attestation: signer ${signerAddress} exceeded per-slot cap for slot ${slotNumber}`, {
+                    slotNumber,
+                    signerAddress,
+                    proposalId,
+                    signerAttestationCount
+                });
                 return {
                     added: false,
                     alreadyExists: false,
-                    totalForPosition: currentCount
+                    count: signerAttestationCount
                 };
             }
+            // Add the attestation
             await this.checkpointAttestations.set(key, attestation.toBuffer());
-            this.log.debug(`Added checkpoint attestation for slot ${slotNumber} from ${sender.toString()}`, {
+            // Track this attestation in the per-signer-per-slot index for duplicate detection
+            const slotSignerKey = this.getSlotSignerKey(slotNumber, signerAddress);
+            await this.checkpointAttestationsPerSlotAndSigner.set(slotSignerKey, proposalId);
+            this.log.debug(`Added checkpoint attestation for slot ${slotNumber} from ${signerAddress}`, {
                 signature: attestation.signature.toString(),
                 slotNumber,
-                address: sender.toString(),
+                address: signerAddress,
                 proposalId
             });
+            // Return the new count
             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;
+    /** Gets the count of attestations by a specific signer for a given slot. */ async getSignerAttestationCountForSlot(slot, signerAddress) {
+        const slotSignerKey = this.getSlotSignerKey(slot, signerAddress);
+        return await this.checkpointAttestationsPerSlotAndSigner.getValueCountAsync(slotSignerKey);
     }
 }
 /** Creates an AttestationPool backed by a temporary store for testing. */ export async function createTestAttestationPool(telemetry) {

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0ZXN0YXRpb25fcG9vbF90ZXN0X3N1aXRlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVtX3Bvb2xzL2F0dGVzdGF0aW9uX3Bvb2wvYXR0ZXN0YXRpb25fcG9vbF90ZXN0X3N1aXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVlBLE9BQU8sRUFBRSxLQUFLLGVBQWUsRUFBc0QsTUFBTSx1QkFBdUIsQ0FBQztBQUtqSCx3QkFBZ0IsdUJBQXVCLENBQUMsa0JBQWtCLEVBQUUsTUFBTSxlQUFlLFFBMnJCaEYifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0ZXN0YXRpb25fcG9vbF90ZXN0X3N1aXRlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVtX3Bvb2xzL2F0dGVzdGF0aW9uX3Bvb2wvYXR0ZXN0YXRpb25fcG9vbF90ZXN0X3N1aXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVlBLE9BQU8sRUFDTCxLQUFLLGVBQWUsRUFHckIsTUFBTSx1QkFBdUIsQ0FBQztBQUsvQix3QkFBZ0IsdUJBQXVCLENBQUMsa0JBQWtCLEVBQUUsTUFBTSxlQUFlLFFBMnJCaEYifQ==

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,EAAE,KAAK,eAAe,EAAsD,MAAM,uBAAuB,CAAC;AAKjH,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,QA2rBhF"}

package/dest/mem_pools/attestation_pool/attestation_pool_test_suite.js

@@ -3,7 +3,7 @@ import { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { makeBlockHeader, makeBlockProposal, makeCheckpointHeader, makeCheckpointProposal } from '@aztec/stdlib/testing';
-import { MAX_PROPOSALS_PER_POSITION, MAX_PROPOSALS_PER_SLOT } from './attestation_pool.js';
+import { MAX_BLOCK_PROPOSALS_PER_POSITION, MAX_CHECKPOINT_PROPOSALS_PER_SLOT } from './attestation_pool.js';
 import { mockCheckpointAttestation } from './mocks.js';
 const NUMBER_OF_SIGNERS_PER_TEST = 4;
 export function describeAttestationPool(getAttestationPool) {
@@ -167,7 +167,7 @@ export function describeAttestationPool(getAttestationPool) {
             const result = await ap.tryAddBlockProposal(proposal);
             expect(result.added).toBe(true);
             expect(result.alreadyExists).toBe(false);
-            expect(result.totalForPosition).toBe(1);
+            expect(result.count).toBe(1);
             const retrievedProposal = await ap.getBlockProposal(proposalId);
             expect(retrievedProposal).toBeDefined();
             expect(retrievedProposal).toEqual(proposal);
@@ -222,7 +222,7 @@ export function describeAttestationPool(getAttestationPool) {
             const result = await ap.tryAddCheckpointProposal(proposal);
             expect(result.added).toBe(true);
             expect(result.alreadyExists).toBe(false);
-            expect(result.totalForPosition).toBe(1);
+            expect(result.count).toBe(1);
             const retrievedProposal = await ap.getCheckpointProposal(proposalId);
             expect(retrievedProposal).toBeDefined();
             expect(retrievedProposal.toBuffer()).toEqual(proposal.toBuffer());
@@ -275,19 +275,19 @@ export function describeAttestationPool(getAttestationPool) {
         });
         it('should return added=false when exceeding capacity', async ()=>{
             const slotNumber = 420;
-            // Add MAX_PROPOSALS_PER_SLOT proposals
-            for(let i = 0; i < MAX_PROPOSALS_PER_SLOT; i++){
+            // Add MAX_CHECKPOINT_PROPOSALS_PER_SLOT 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.totalForPosition).toBe(i + 1);
+                expect(result.count).toBe(i + 1);
             }
             // 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);
             expect(result.alreadyExists).toBe(false);
-            expect(result.totalForPosition).toBe(MAX_PROPOSALS_PER_SLOT);
+            expect(result.count).toBe(MAX_CHECKPOINT_PROPOSALS_PER_SLOT);
         });
     });
     describe('Duplicate proposal detection', ()=>{
@@ -303,12 +303,12 @@ export function describeAttestationPool(getAttestationPool) {
             });
         };
         describe('tryAddBlockProposal duplicate detection', ()=>{
-            it('should return totalForPosition=1 when pool is empty', async ()=>{
+            it('should return count=1 when pool is empty', async ()=>{
                 const proposal = await mockBlockProposalWithIndex(signers[0], 100, 0);
                 const result = await ap.tryAddBlockProposal(proposal);
                 expect(result.added).toBe(true);
                 expect(result.alreadyExists).toBe(false);
-                expect(result.totalForPosition).toBe(1);
+                expect(result.count).toBe(1);
             });
             it('should return alreadyExists when same proposal exists', async ()=>{
                 const proposal = await mockBlockProposalWithIndex(signers[0], 100, 0);
@@ -316,22 +316,22 @@ export function describeAttestationPool(getAttestationPool) {
                 const result = await ap.tryAddBlockProposal(proposal);
                 expect(result.added).toBe(false);
                 expect(result.alreadyExists).toBe(true);
-                expect(result.totalForPosition).toBe(1);
+                expect(result.count).toBe(1);
             });
-            it('should detect duplicate via totalForPosition when different proposal exists at same position', async ()=>{
+            it('should detect duplicate via count when different proposal exists at same position', async ()=>{
                 const slotNumber = 100;
                 const indexWithinCheckpoint = 2;
                 // Add first proposal
                 const proposal1 = await mockBlockProposalWithIndex(signers[0], slotNumber, indexWithinCheckpoint);
                 const result1 = await ap.tryAddBlockProposal(proposal1);
-                expect(result1.totalForPosition).toBe(1);
+                expect(result1.count).toBe(1);
                 // Add a different proposal at same position - this is a duplicate (equivocation)
                 const proposal2 = await mockBlockProposalWithIndex(signers[1], slotNumber, indexWithinCheckpoint);
                 const result2 = await ap.tryAddBlockProposal(proposal2);
                 expect(result2.added).toBe(true);
                 expect(result2.alreadyExists).toBe(false);
-                // totalForPosition >= 2 indicates duplicate detection
-                expect(result2.totalForPosition).toBe(2);
+                // count >= 2 indicates duplicate detection
+                expect(result2.count).toBe(2);
             });
             it('should not detect duplicate for different positions in same slot', async ()=>{
                 const slotNumber = 100;
@@ -342,8 +342,8 @@ export function describeAttestationPool(getAttestationPool) {
                 const proposal2 = await mockBlockProposalWithIndex(signers[1], slotNumber, 1);
                 const result = await ap.tryAddBlockProposal(proposal2);
                 expect(result.added).toBe(true);
-                // totalForPosition = 1 means no duplicate for this position
-                expect(result.totalForPosition).toBe(1);
+                // count = 1 means no duplicate for this position
+                expect(result.count).toBe(1);
             });
             it('should not detect duplicate for same position in different slots', async ()=>{
                 const indexWithinCheckpoint = 0;
@@ -354,41 +354,41 @@ export function describeAttestationPool(getAttestationPool) {
                 const proposal2 = await mockBlockProposalWithIndex(signers[1], 200, indexWithinCheckpoint);
                 const result = await ap.tryAddBlockProposal(proposal2);
                 expect(result.added).toBe(true);
-                // totalForPosition = 1 means no duplicate for this position
-                expect(result.totalForPosition).toBe(1);
+                // count = 1 means no duplicate for this position
+                expect(result.count).toBe(1);
             });
-            it('should track multiple duplicates correctly via totalForPosition', async ()=>{
+            it('should track multiple duplicates correctly via count', async ()=>{
                 const slotNumber = 100;
                 const indexWithinCheckpoint = 0;
                 // Add multiple proposals for same position
                 const proposal1 = await mockBlockProposalWithIndex(signers[0], slotNumber, indexWithinCheckpoint);
                 const result1 = await ap.tryAddBlockProposal(proposal1);
-                expect(result1.totalForPosition).toBe(1);
+                expect(result1.count).toBe(1);
                 const proposal2 = await mockBlockProposalWithIndex(signers[1], slotNumber, indexWithinCheckpoint);
                 const result2 = await ap.tryAddBlockProposal(proposal2);
-                expect(result2.totalForPosition).toBe(2);
+                expect(result2.count).toBe(2);
                 // Add a third proposal for same position
                 const proposal3 = await mockBlockProposalWithIndex(signers[2], slotNumber, indexWithinCheckpoint);
                 const result3 = await ap.tryAddBlockProposal(proposal3);
                 expect(result3.added).toBe(true);
-                expect(result3.totalForPosition).toBe(3);
+                expect(result3.count).toBe(3);
             });
             it('should return added=false when exceeding capacity', async ()=>{
                 const slotNumber = 100;
                 const indexWithinCheckpoint = 0;
-                // Add MAX_PROPOSALS_PER_POSITION proposals
-                for(let i = 0; i < MAX_PROPOSALS_PER_POSITION; i++){
+                // Add MAX_BLOCK_PROPOSALS_PER_POSITION proposals
+                for(let i = 0; i < MAX_BLOCK_PROPOSALS_PER_POSITION; i++){
                     const proposal = await mockBlockProposalWithIndex(signers[i % NUMBER_OF_SIGNERS_PER_TEST], slotNumber, indexWithinCheckpoint);
                     const result = await ap.tryAddBlockProposal(proposal);
                     expect(result.added).toBe(true);
-                    expect(result.totalForPosition).toBe(i + 1);
+                    expect(result.count).toBe(i + 1);
                 }
                 // The next proposal should not be added
                 const extraProposal = await mockBlockProposalWithIndex(signers[0], slotNumber, indexWithinCheckpoint);
                 const result = await ap.tryAddBlockProposal(extraProposal);
                 expect(result.added).toBe(false);
                 expect(result.alreadyExists).toBe(false);
-                expect(result.totalForPosition).toBe(MAX_PROPOSALS_PER_POSITION);
+                expect(result.count).toBe(MAX_BLOCK_PROPOSALS_PER_POSITION);
             });
             it('should clean up block position index when deleting old data', async ()=>{
                 const slotNumber = 100;
@@ -396,16 +396,16 @@ export function describeAttestationPool(getAttestationPool) {
                 // Add proposal
                 const proposal1 = await mockBlockProposalWithIndex(signers[0], slotNumber, indexWithinCheckpoint);
                 await ap.tryAddBlockProposal(proposal1);
-                // Verify it's tracked (adding another should show totalForPosition = 2)
+                // Verify it's tracked (adding another should show count = 2)
                 const proposal2 = await mockBlockProposalWithIndex(signers[1], slotNumber, indexWithinCheckpoint);
                 let result = await ap.tryAddBlockProposal(proposal2);
-                expect(result.totalForPosition).toBe(2);
+                expect(result.count).toBe(2);
                 // Delete old data
                 await ap.deleteOlderThan(SlotNumber(slotNumber + 1));
-                // Verify position index is cleaned up (totalForPosition should be 1 now)
+                // Verify position index is cleaned up (count should be 1 now)
                 const proposal3 = await mockBlockProposalWithIndex(signers[2], slotNumber, indexWithinCheckpoint);
                 result = await ap.tryAddBlockProposal(proposal3);
-                expect(result.totalForPosition).toBe(1);
+                expect(result.count).toBe(1);
             });
             it('should correctly delete block proposals at slot boundary', async ()=>{
                 // Add proposals at slots 99, 100, and 101 with various indices
@@ -422,14 +422,14 @@ export function describeAttestationPool(getAttestationPool) {
                 // Slot 99 proposals should have their index cleaned up
                 const newProposal99 = await mockBlockProposalWithIndex(signers[0], 99, 0);
                 const result99 = await ap.tryAddBlockProposal(newProposal99);
-                expect(result99.totalForPosition).toBe(1); // Index was cleaned up
+                expect(result99.count).toBe(1); // Index was cleaned up
                 // Slot 100 and 101 should still be tracked
                 const newProposal100 = await mockBlockProposalWithIndex(signers[1], 100, 0);
                 const result100 = await ap.tryAddBlockProposal(newProposal100);
-                expect(result100.totalForPosition).toBe(2); // Still has the original
+                expect(result100.count).toBe(2); // Still has the original
                 const newProposal101 = await mockBlockProposalWithIndex(signers[2], 101, 0);
                 const result101 = await ap.tryAddBlockProposal(newProposal101);
-                expect(result101.totalForPosition).toBe(2); // Still has the original
+                expect(result101.count).toBe(2); // Still has the original
             });
             it('should delete all indices for a given slot', async ()=>{
                 const slotNumber = 50;
@@ -445,13 +445,13 @@ export function describeAttestationPool(getAttestationPool) {
                 // All indices should be cleaned up
                 const newProposal0 = await mockBlockProposalWithIndex(signers[0], slotNumber, 0);
                 const result0 = await ap.tryAddBlockProposal(newProposal0);
-                expect(result0.totalForPosition).toBe(1);
+                expect(result0.count).toBe(1);
                 const newProposal1 = await mockBlockProposalWithIndex(signers[1], slotNumber, 1);
                 const result1 = await ap.tryAddBlockProposal(newProposal1);
-                expect(result1.totalForPosition).toBe(1);
+                expect(result1.count).toBe(1);
                 const newProposal2 = await mockBlockProposalWithIndex(signers[2], slotNumber, 2);
                 const result2 = await ap.tryAddBlockProposal(newProposal2);
-                expect(result2.totalForPosition).toBe(1);
+                expect(result2.count).toBe(1);
             });
             it('should delete block proposals from storage when deleting old data', async ()=>{
                 const oldSlot = 50;
@@ -488,12 +488,12 @@ export function describeAttestationPool(getAttestationPool) {
                 });
                 return proposal.toCore();
             };
-            it('should return totalForPosition=1 when pool is empty', async ()=>{
+            it('should return count=1 when pool is empty', async ()=>{
                 const proposal = await mockCheckpointProposalCoreForPool(signers[0], 100);
                 const result = await ap.tryAddCheckpointProposal(proposal);
                 expect(result.added).toBe(true);
                 expect(result.alreadyExists).toBe(false);
-                expect(result.totalForPosition).toBe(1);
+                expect(result.count).toBe(1);
             });
             it('should return alreadyExists when same proposal exists', async ()=>{
                 const proposal = await mockCheckpointProposalCoreForPool(signers[0], 100);
@@ -501,21 +501,21 @@ export function describeAttestationPool(getAttestationPool) {
                 const result = await ap.tryAddCheckpointProposal(proposal);
                 expect(result.added).toBe(false);
                 expect(result.alreadyExists).toBe(true);
-                expect(result.totalForPosition).toBe(1);
+                expect(result.count).toBe(1);
             });
-            it('should detect duplicate via totalForPosition when different proposal exists for same slot', async ()=>{
+            it('should detect duplicate via count when different proposal exists for same slot', async ()=>{
                 const slotNumber = 100;
                 // Add first proposal
                 const proposal1 = await mockCheckpointProposalCoreForPool(signers[0], slotNumber);
                 const result1 = await ap.tryAddCheckpointProposal(proposal1);
-                expect(result1.totalForPosition).toBe(1);
+                expect(result1.count).toBe(1);
                 // Add a different proposal for same slot - this is a duplicate (equivocation)
                 const proposal2 = await mockCheckpointProposalCoreForPool(signers[1], slotNumber);
                 const result2 = await ap.tryAddCheckpointProposal(proposal2);
                 expect(result2.added).toBe(true);
                 expect(result2.alreadyExists).toBe(false);
-                // totalForPosition >= 2 indicates duplicate detection
-                expect(result2.totalForPosition).toBe(2);
+                // count >= 2 indicates duplicate detection
+                expect(result2.count).toBe(2);
             });
             it('should not detect duplicate for different slots', async ()=>{
                 // Add proposal at slot 100
@@ -525,23 +525,23 @@ export function describeAttestationPool(getAttestationPool) {
                 const proposal2 = await mockCheckpointProposalCoreForPool(signers[1], 200);
                 const result = await ap.tryAddCheckpointProposal(proposal2);
                 expect(result.added).toBe(true);
-                // totalForPosition = 1 means no duplicate for this slot
-                expect(result.totalForPosition).toBe(1);
+                // count = 1 means no duplicate for this slot
+                expect(result.count).toBe(1);
             });
-            it('should track multiple duplicates correctly via totalForPosition', async ()=>{
+            it('should track multiple duplicates correctly via count', async ()=>{
                 const slotNumber = 100;
                 // Add multiple proposals for same slot
                 const proposal1 = await mockCheckpointProposalCoreForPool(signers[0], slotNumber);
                 const result1 = await ap.tryAddCheckpointProposal(proposal1);
-                expect(result1.totalForPosition).toBe(1);
+                expect(result1.count).toBe(1);
                 const proposal2 = await mockCheckpointProposalCoreForPool(signers[1], slotNumber);
                 const result2 = await ap.tryAddCheckpointProposal(proposal2);
-                expect(result2.totalForPosition).toBe(2);
+                expect(result2.count).toBe(2);
                 // Add a third proposal for same slot
                 const proposal3 = await mockCheckpointProposalCoreForPool(signers[2], slotNumber);
                 const result3 = await ap.tryAddCheckpointProposal(proposal3);
                 expect(result3.added).toBe(true);
-                expect(result3.totalForPosition).toBe(3);
+                expect(result3.count).toBe(3);
             });
             it('should not count attestations as proposals for duplicate detection', async ()=>{
                 const slotNumber = 100;
@@ -556,8 +556,8 @@ export function describeAttestationPool(getAttestationPool) {
                 const result = await ap.tryAddCheckpointProposal(proposal);
                 expect(result.added).toBe(true);
                 expect(result.alreadyExists).toBe(false);
-                // totalForPosition should be 1, NOT 2 - attestations should not count as proposals
-                expect(result.totalForPosition).toBe(1);
+                // count should be 1, NOT 2 - attestations should not count as proposals
+                expect(result.count).toBe(1);
             });
             it('should not count attestations for different proposals as duplicates', async ()=>{
                 const slotNumber = 100;
@@ -574,12 +574,12 @@ export function describeAttestationPool(getAttestationPool) {
                 const proposal1 = await mockCheckpointProposalCoreForPool(signers[2], slotNumber, archive1);
                 const result1 = await ap.tryAddCheckpointProposal(proposal1);
                 expect(result1.added).toBe(true);
-                expect(result1.totalForPosition).toBe(1);
+                expect(result1.count).toBe(1);
                 // Add the second checkpoint proposal - this IS a duplicate (different archive, same slot)
                 const proposal2 = await mockCheckpointProposalCoreForPool(signers[3], slotNumber, archive2);
                 const result2 = await ap.tryAddCheckpointProposal(proposal2);
                 expect(result2.added).toBe(true);
-                expect(result2.totalForPosition).toBe(2);
+                expect(result2.count).toBe(2);
             });
         });
     });

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

@@ -1,2 +1,2 @@
-export { AttestationPool, type AttestationPoolApi, type TryAddResult, createTestAttestationPool, MAX_PROPOSALS_PER_SLOT, MAX_PROPOSALS_PER_POSITION, ATTESTATION_CAP_BUFFER, } from './attestation_pool.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvYXR0ZXN0YXRpb25fcG9vbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsZUFBZSxFQUNmLEtBQUssa0JBQWtCLEVBQ3ZCLEtBQUssWUFBWSxFQUNqQix5QkFBeUIsRUFDekIsc0JBQXNCLEVBQ3RCLDBCQUEwQixFQUMxQixzQkFBc0IsR0FDdkIsTUFBTSx1QkFBdUIsQ0FBQyJ9
+export { AttestationPool, type AttestationPoolApi, type TryAddResult, createTestAttestationPool, MAX_CHECKPOINT_PROPOSALS_PER_SLOT, MAX_BLOCK_PROPOSALS_PER_POSITION, MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER, } from './attestation_pool.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvYXR0ZXN0YXRpb25fcG9vbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsZUFBZSxFQUNmLEtBQUssa0JBQWtCLEVBQ3ZCLEtBQUssWUFBWSxFQUNqQix5QkFBeUIsRUFDekIsaUNBQWlDLEVBQ2pDLGdDQUFnQyxFQUNoQyxvQ0FBb0MsR0FDckMsTUFBTSx1QkFBdUIsQ0FBQyJ9

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,yBAAyB,EACzB,sBAAsB,EACtB,0BAA0B,EAC1B,sBAAsB,GACvB,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,yBAAyB,EACzB,iCAAiC,EACjC,gCAAgC,EAChC,oCAAoC,GACrC,MAAM,uBAAuB,CAAC"}

package/dest/mem_pools/attestation_pool/index.js

@@ -1 +1 @@
-export { AttestationPool, createTestAttestationPool, MAX_PROPOSALS_PER_SLOT, MAX_PROPOSALS_PER_POSITION, ATTESTATION_CAP_BUFFER } from './attestation_pool.js';
+export { AttestationPool, createTestAttestationPool, MAX_CHECKPOINT_PROPOSALS_PER_SLOT, MAX_BLOCK_PROPOSALS_PER_POSITION, MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER } from './attestation_pool.js';

package/dest/mem_pools/index.d.ts

@@ -1,4 +1,5 @@
 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';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tZW1fcG9vbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxLQUFLLGtCQUFrQixFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFDbEcsT0FBTyxFQUFFLEtBQUssUUFBUSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDL0MsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLE1BQU0sc0JBQXNCLENBQUMifQ==
+export { type TxPoolV2, type TxPoolV2Config, type TxPoolV2Events, type AddTxsResult } from './tx_pool_v2/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tZW1fcG9vbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxLQUFLLGtCQUFrQixFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFDbEcsT0FBTyxFQUFFLEtBQUssUUFBUSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFL0MsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFbkQsT0FBTyxFQUFFLEtBQUssUUFBUSxFQUFFLEtBQUssY0FBYyxFQUFFLEtBQUssY0FBYyxFQUFFLEtBQUssWUFBWSxFQUFFLE1BQU0sdUJBQXVCLENBQUMifQ==

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;AAC/C,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,sBAAsB,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;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"}

package/dest/mem_pools/interface.d.ts

@@ -1,10 +1,10 @@
 import type { AttestationPoolApi } from './attestation_pool/attestation_pool.js';
-import type { TxPool } from './tx_pool/tx_pool.js';
+import type { TxPoolV2 } from './tx_pool_v2/interfaces.js';
 /**
  * A interface the combines all mempools
  */
 export type MemPools = {
-    txPool: TxPool;
+    txPool: TxPoolV2;
     attestationPool: AttestationPoolApi;
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWVtX3Bvb2xzL2ludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQ2pGLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRW5EOztHQUVHO0FBQ0gsTUFBTSxNQUFNLFFBQVEsR0FBRztJQUNyQixNQUFNLEVBQUUsTUFBTSxDQUFDO0lBQ2YsZUFBZSxFQUFFLGtCQUFrQixDQUFDO0NBQ3JDLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWVtX3Bvb2xzL2ludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQ2pGLE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRTNEOztHQUVHO0FBQ0gsTUFBTSxNQUFNLFFBQVEsR0FBRztJQUNyQixNQUFNLEVBQUUsUUFBUSxDQUFDO0lBQ2pCLGVBQWUsRUFBRSxrQkFBa0IsQ0FBQztDQUNyQyxDQUFDIn0=

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

@@ -1 +1 @@
-{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../src/mem_pools/interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AACjF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,kBAAkB,CAAC;CACrC,CAAC"}
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../src/mem_pools/interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AACjF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,QAAQ,CAAC;IACjB,eAAe,EAAE,kBAAkB,CAAC;CACrC,CAAC"}