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

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
             };
         });
     }
@@ -162,6 +170,11 @@ export const ATTESTATION_CAP_BUFFER = 10;
         }
         return undefined;
     }
+    /** Checks if any block proposals exist for a given slot (at index 0). */ async hasBlockProposalsForSlot(slot) {
+        const positionKey = this.getBlockPositionKey(slot, 0);
+        const count = await this.blockProposalsForSlotAndIndex.getValueCountAsync(positionKey);
+        return count > 0;
+    }
     /**
    * Attempts to add a checkpoint proposal to the pool.
    *
@@ -182,20 +195,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 +220,7 @@ export const ATTESTATION_CAP_BUFFER = 10;
             return {
                 added: true,
                 alreadyExists: false,
-                totalForPosition: totalForPosition + 1
+                count: count + 1
             };
         });
     }
@@ -255,7 +268,9 @@ export const ATTESTATION_CAP_BUFFER = 10;
                     continue;
                 }
                 const address = sender.toString();
-                await this.checkpointAttestations.set(this.getAttestationKey(slotNumber, proposalId, address), attestation.toBuffer());
+                const ownKey = this.getAttestationKey(slotNumber, proposalId, address);
+                await this.checkpointAttestations.set(ownKey, attestation.toBuffer());
+                this.metrics.trackMempoolItemAdded(ownKey);
                 this.log.debug(`Added own checkpoint attestation for slot ${slotNumber} from ${address}`, {
                     signature: attestation.signature.toString(),
                     slotNumber,
@@ -308,8 +323,18 @@ export const ATTESTATION_CAP_BUFFER = 10;
                 end: attestationEndKey
             })){
                 await this.checkpointAttestations.delete(key);
+                this.metrics.trackMempoolItemRemoved(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 +372,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 +386,59 @@ 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()}`, {
+            this.metrics.trackMempoolItemAdded(key);
+            // 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/attestation_pool/mocks.d.ts

@@ -238,5 +238,5 @@ export declare const generateAccount: () => {
  * @param header The checkpoint header (defaults to random with given slot)
  * @returns A Checkpoint Attestation
  */
-export declare const mockCheckpointAttestation: (signer: Secp256k1Signer, slot?: number, archive?: Fr, header?: CheckpointHeader | undefined) => CheckpointAttestation;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9ja3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvYXR0ZXN0YXRpb25fcG9vbC9tb2Nrcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUNqRixPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxFQUNMLHFCQUFxQixFQUl0QixNQUFNLG1CQUFtQixDQUFDO0FBQzNCLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBSXhEOzs7O0dBSUc7QUFDSCxlQUFPLE1BQU0sZUFBZTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBRzNCLENBQUM7QUFFRjs7Ozs7OztHQU9HO0FBQ0gsZUFBTyxNQUFNLHlCQUF5Qix3SEFtQnJDLENBQUMifQ==
+export declare const mockCheckpointAttestation: (signer: Secp256k1Signer, slot?: number, archive?: Fr, header?: CheckpointHeader | undefined, feeAssetPriceModifier?: bigint) => CheckpointAttestation;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9ja3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvYXR0ZXN0YXRpb25fcG9vbC9tb2Nrcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUNqRixPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxFQUNMLHFCQUFxQixFQUl0QixNQUFNLG1CQUFtQixDQUFDO0FBQzNCLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBSXhEOzs7O0dBSUc7QUFDSCxlQUFPLE1BQU0sZUFBZTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBRzNCLENBQUM7QUFFRjs7Ozs7OztHQU9HO0FBQ0gsZUFBTyxNQUFNLHlCQUF5Qix3SkFvQnJDLENBQUMifQ==

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,wHAmBrC,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;AAIxD;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG3B,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,wJAoBrC,CAAC"}

package/dest/mem_pools/attestation_pool/mocks.js

@@ -18,11 +18,11 @@ import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
  * @param archive The archive root (defaults to random)
  * @param header The checkpoint header (defaults to random with given slot)
  * @returns A Checkpoint Attestation
- */ export const mockCheckpointAttestation = (signer, slot = 0, archive = Fr.random(), header)=>{
+ */ export const mockCheckpointAttestation = (signer, slot = 0, archive = Fr.random(), header, feeAssetPriceModifier = 0n)=>{
     header = header ?? CheckpointHeader.random({
         slotNumber: SlotNumber(slot)
     });
-    const payload = new ConsensusPayload(header, archive);
+    const payload = new ConsensusPayload(header, archive, feeAssetPriceModifier);
     const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.checkpointAttestation);
     const attestationSignature = signer.sign(attestationHash);
     const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.checkpointProposal);

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==