@aztec/p2p 0.0.1-commit.87a0206 → 0.0.1-commit.8f9871590

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

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"}

package/dest/mem_pools/tx_pool/eviction/invalid_txs_after_mining_rule.js

@@ -50,9 +50,9 @@ import { EvictionEvent } from './eviction_strategy.js';
                     continue;
                 }
                 // Evict pending txs with an expiration timestamp less than or equal to the mined block timestamp
-                const includeByTimestamp = tx.data.includeByTimestamp;
-                if (includeByTimestamp <= timestamp) {
-                    this.log.verbose(`Evicting tx ${txHash} from pool due to the tx being expired (includeByTimestamp: ${includeByTimestamp}, mined block timestamp: ${timestamp})`);
+                const expirationTimestamp = tx.data.expirationTimestamp;
+                if (expirationTimestamp <= timestamp) {
+                    this.log.verbose(`Evicting tx ${txHash} from pool due to the tx being expired (expirationTimestamp: ${expirationTimestamp}, mined block timestamp: ${timestamp})`);
                     txsToEvict.push(txHash);
                     continue;
                 }

package/dest/mem_pools/tx_pool_v2/deleted_pool.d.ts

@@ -0,0 +1,102 @@
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { Logger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+/**
+ * Manages all transaction deletions in the pool.
+ *
+ * When a chain prune (reorg) happens, transactions from pruned blocks are tracked here.
+ * This class is responsible for ALL deletion decisions:
+ *
+ * - Transactions from pruned blocks are "prune-soft-deleted" - removed from indices but kept
+ *   in the database for later re-execution until their mined block is finalized
+ * - Transactions NOT from pruned blocks are "slot-soft-deleted" - kept in the database
+ *   until the next slot, so other nodes can still fetch them via reqresp
+ *
+ * When a block is finalized, prune-soft-deleted transactions that were originally mined at or
+ * before that block number are permanently (hard) deleted. Slot-soft-deleted transactions
+ * are hard-deleted when `prepareForSlot` advances to a new slot.
+ */
+export declare class DeletedPool {
+    #private;
+    constructor(store: AztecAsyncKVStore, txsDB: AztecAsyncMap<string, Buffer>, log: Logger);
+    /**
+     * Loads state from the database on startup.
+     * Slot-deleted txs are stale after restart and are immediately hard-deleted.
+     */
+    hydrateFromDatabase(): Promise<void>;
+    /**
+     * Marks transactions as being from a pruned block.
+     * Called during handlePrunedBlocks for ALL transactions that were un-mined.
+     *
+     * If a tx was previously tracked (e.g., mined at block 4, pruned, re-mined at block 5,
+     * pruned again), updates to the higher block number. This ensures the tx is kept until
+     * its most recent mined block is finalized.
+     *
+     * @param txs - Array of {txHash, minedAtBlock} pairs, where minedAtBlock is the block
+     *              number in which the tx was mined before being un-mined
+     */
+    markFromPrunedBlock(txs: {
+        txHash: string;
+        minedAtBlock: BlockNumber;
+    }[]): Promise<void>;
+    /**
+     * Deletes a transaction. This is the single entry point for ALL deletions.
+     * The tx is always soft-deleted (kept in DB):
+     *
+     * - If the tx is from a pruned block: prune-soft-delete (kept until finalized)
+     * - If the tx is NOT from a pruned block: slot-soft-delete (kept until next slot)
+     */
+    deleteTx(txHash: string): Promise<void>;
+    /**
+     * Clears tracking for a transaction if it re-mines at a block number >= the tracked minedAtBlock.
+     *
+     * When a tx re-mines at a higher (or equal) block, the old high-water mark is no longer needed:
+     * any future prune would re-add the tx with an even higher block number. Clearing keeps
+     * DeletedPool consistent — only txs that are actually un-mined should be tracked here.
+     *
+     * When a tx re-mines at a lower block, we must preserve the existing entry to retain
+     * the high-water mark for re-execution purposes.
+     */
+    clearIfMinedHigher(txHash: string, minedAtBlock: BlockNumber): Promise<void>;
+    /**
+     * Checks if a transaction is from a pruned block.
+     */
+    isFromPrunedBlock(txHash: string): boolean;
+    /**
+     * Checks if a transaction is soft-deleted (either prune-based or slot-based).
+     */
+    isSoftDeleted(txHash: string): boolean;
+    /**
+     * Gets the block number in which a transaction was originally mined.
+     */
+    getMinedAtBlock(txHash: string): BlockNumber | undefined;
+    /**
+     * Finalizes transactions when a block is finalized.
+     * Hard-deletes transactions that were originally mined at or before the finalized block.
+     *
+     * @returns The hashes of transactions that were hard-deleted
+     */
+    finalizeBlock(finalizedBlockNumber: BlockNumber): Promise<string[]>;
+    /**
+     * Cleans up slot-deleted transactions from previous slots.
+     * Called at the start of prepareForSlot. Updates #currentSlot and hard-deletes
+     * any txs that were deleted in an earlier slot.
+     */
+    cleanupSlotDeleted(currentSlot: SlotNumber): Promise<void>;
+    /**
+     * Clears soft-deletion status for a transaction being re-added to the pool.
+     * Removes slot-deleted tracking entirely, and resets the prune-soft-deleted flag
+     * while preserving the prune tracking itself (so a subsequent delete still uses
+     * the prune path).
+     */
+    clearSoftDeleted(txHash: string): Promise<void>;
+    /**
+     * Gets the count of transactions from pruned blocks.
+     */
+    getCount(): number;
+    /**
+     * Gets all transaction hashes from pruned blocks.
+     */
+    getPrunedTxHashes(): string[];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsZXRlZF9wb29sLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVtX3Bvb2xzL3R4X3Bvb2xfdjIvZGVsZXRlZF9wb29sLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsVUFBVSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDMUUsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDcEQsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsYUFBYSxFQUFpQixNQUFNLGlCQUFpQixDQUFDO0FBaUN2Rjs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILHFCQUFhLFdBQVc7O0lBcUJ0QixZQUFZLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxLQUFLLEVBQUUsYUFBYSxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsRUFBRSxHQUFHLEVBQUUsTUFBTSxFQUt0RjtJQUVEOzs7T0FHRztJQUNHLG1CQUFtQixJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0E0QnpDO0lBRUQ7Ozs7Ozs7Ozs7T0FVRztJQUNHLG1CQUFtQixDQUFDLEdBQUcsRUFBRTtRQUFFLE1BQU0sRUFBRSxNQUFNLENBQUM7UUFBQyxZQUFZLEVBQUUsV0FBVyxDQUFBO0tBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0F1QjdGO0lBRUQ7Ozs7OztPQU1HO0lBQ0csUUFBUSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQWU1QztJQUVEOzs7Ozs7Ozs7T0FTRztJQUNHLGtCQUFrQixDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsWUFBWSxFQUFFLFdBQVcsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBU2pGO0lBRUQ7O09BRUc7SUFDSCxpQkFBaUIsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FFekM7SUFFRDs7T0FFRztJQUNILGFBQWEsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FFckM7SUFFRDs7T0FFRztJQUNILGVBQWUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFdBQVcsR0FBRyxTQUFTLENBRXZEO0lBRUQ7Ozs7O09BS0c7SUFDRyxhQUFhLENBQUMsb0JBQW9CLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQXVCeEU7SUFFRDs7OztPQUlHO0lBQ0csa0JBQWtCLENBQUMsV0FBVyxFQUFFLFVBQVUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBeUIvRDtJQUVEOzs7OztPQUtHO0lBQ0csZ0JBQWdCLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBV3BEO0lBRUQ7O09BRUc7SUFDSCxRQUFRLElBQUksTUFBTSxDQUVqQjtJQUVEOztPQUVHO0lBQ0gsaUJBQWlCLElBQUksTUFBTSxFQUFFLENBRTVCO0NBQ0YifQ==

package/dest/mem_pools/tx_pool_v2/deleted_pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleted_pool.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool_v2/deleted_pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAiB,MAAM,iBAAiB,CAAC;AAiCvF;;;;;;;;;;;;;;GAcG;AACH,qBAAa,WAAW;;IAqBtB,YAAY,KAAK,EAAE,iBAAiB,EAAE,KAAK,EAAE,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,MAAM,EAKtF;IAED;;;OAGG;IACG,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CA4BzC;IAED;;;;;;;;;;OAUG;IACG,mBAAmB,CAAC,GAAG,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,WAAW,CAAA;KAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB7F;IAED;;;;;;OAMG;IACG,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAe5C;IAED;;;;;;;;;OASG;IACG,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CASjF;IAED;;OAEG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEzC;IAED;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAErC;IAED;;OAEG;IACH,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAEvD;IAED;;;;;OAKG;IACG,aAAa,CAAC,oBAAoB,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAuBxE;IAED;;;;OAIG;IACG,kBAAkB,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAyB/D;IAED;;;;;OAKG;IACG,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAWpD;IAED;;OAEG;IACH,QAAQ,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,iBAAiB,IAAI,MAAM,EAAE,CAE5B;CACF"}