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

package/dest/mem_pools/tx_pool/tx_pool_test_suite.js

@@ -1,400 +0,0 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { unfreeze } from '@aztec/foundation/types';
-import { GasFees } from '@aztec/stdlib/gas';
-import { mockTx } from '@aztec/stdlib/testing';
-import { BlockHeader, GlobalVariables } from '@aztec/stdlib/tx';
-/**
- * Tests a TxPool implementation.
- * @param getTxPool - Gets a fresh TxPool
- */ export function describeTxPool(getTxPool) {
-    let pool;
-    const minedBlockHeader = BlockHeader.empty({
-        globalVariables: GlobalVariables.empty({
-            blockNumber: BlockNumber(1),
-            timestamp: 0n
-        })
-    });
-    beforeEach(()=>{
-        pool = getTxPool();
-    });
-    afterEach(()=>{
-        pool.removeAllListeners('txs-added');
-    });
-    it('adds txs to the pool as pending', async ()=>{
-        const tx1 = await mockTx(1);
-        await pool.addTxs([
-            tx1
-        ]);
-        const poolTx = await pool.getTxByHash(tx1.getTxHash());
-        expect(poolTx.getTxHash()).toEqual(tx1.getTxHash());
-        await expect(pool.getTxStatus(tx1.getTxHash())).resolves.toEqual('pending');
-        await expect(pool.getPendingTxHashes()).resolves.toEqual([
-            tx1.getTxHash()
-        ]);
-        await expect(pool.getPendingTxCount()).resolves.toEqual(1);
-    });
-    it('emits txs-added event with new txs', async ()=>{
-        const tx1 = await mockTx(1); // existing and pending
-        const tx2 = await mockTx(2); // mined but not known
-        const tx3 = await mockTx(3); // brand new
-        await pool.addTxs([
-            tx1
-        ]);
-        await pool.markAsMined([
-            tx2.getTxHash()
-        ], minedBlockHeader);
-        let txsFromEvent = undefined;
-        pool.once('txs-added', ({ txs })=>{
-            txsFromEvent = txs;
-        });
-        await pool.addTxs([
-            tx1,
-            tx2,
-            tx3
-        ]);
-        expect(txsFromEvent).toBeDefined();
-        expect(txsFromEvent).toHaveLength(2);
-        const eventHashes = txsFromEvent.map((tx)=>tx.getTxHash());
-        expect(eventHashes).toEqual(expect.arrayContaining([
-            tx2.getTxHash(),
-            tx3.getTxHash()
-        ]));
-    });
-    it('removes txs from the pool', async ()=>{
-        const pendingTx = await mockTx(1);
-        const minedTx = await mockTx(2);
-        await pool.addTxs([
-            pendingTx,
-            minedTx
-        ]);
-        await pool.markAsMined([
-            minedTx.getTxHash()
-        ], minedBlockHeader);
-        // Delete a pending tx - should be permanently deleted
-        await pool.deleteTxs([
-            pendingTx.getTxHash()
-        ]);
-        await expect(pool.getTxByHash(pendingTx.getTxHash())).resolves.toBeUndefined();
-        await expect(pool.getTxStatus(pendingTx.getTxHash())).resolves.toBeUndefined();
-        // Delete a mined tx - should be soft-deleted (still in storage)
-        await pool.deleteTxs([
-            minedTx.getTxHash()
-        ]);
-        await expect(pool.getTxByHash(minedTx.getTxHash())).resolves.toBeDefined();
-        await expect(pool.getTxStatus(minedTx.getTxHash())).resolves.toEqual('deleted');
-        await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
-        await expect(pool.getPendingTxCount()).resolves.toEqual(0);
-    });
-    it('marks txs as mined', async ()=>{
-        const tx1 = await mockTx(1);
-        const tx2 = await mockTx(2);
-        await pool.addTxs([
-            tx1,
-            tx2
-        ]);
-        await pool.markAsMined([
-            tx1.getTxHash()
-        ], minedBlockHeader);
-        const retrievedTx = await pool.getTxByHash(tx1.getTxHash());
-        expect(retrievedTx?.getTxHash()).toEqual(tx1.getTxHash());
-        await expect(pool.getTxStatus(tx1.getTxHash())).resolves.toEqual('mined');
-        await expect(pool.getMinedTxHashes()).resolves.toEqual([
-            [
-                tx1.getTxHash(),
-                1
-            ]
-        ]);
-        await expect(pool.getPendingTxHashes()).resolves.toEqual([
-            tx2.getTxHash()
-        ]);
-        await expect(pool.getPendingTxCount()).resolves.toEqual(1);
-    });
-    it('marks txs as pending after being mined', async ()=>{
-        const tx1 = await mockTx(1);
-        const tx2 = await mockTx(2);
-        await pool.addTxs([
-            tx1,
-            tx2
-        ]);
-        await pool.markAsMined([
-            tx1.getTxHash()
-        ], minedBlockHeader);
-        await pool.markMinedAsPending([
-            tx1.getTxHash()
-        ], BlockNumber(1));
-        await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
-        const pending = await pool.getPendingTxHashes();
-        expect(pending).toHaveLength(2);
-        expect(pending).toEqual(expect.arrayContaining([
-            tx1.getTxHash(),
-            tx2.getTxHash()
-        ]));
-        await expect(pool.getPendingTxCount()).resolves.toEqual(2);
-    });
-    it('only marks txs as pending if they are known', async ()=>{
-        const tx1 = await mockTx(1);
-        // simulate a situation where not all peers have all the txs
-        const tx2 = await mockTx(2);
-        const someTxHashThatThisPeerDidNotSee = tx2.getTxHash();
-        await pool.addTxs([
-            tx1
-        ]);
-        // this peer knows that tx2 was mined, but it does not have the tx object
-        await pool.markAsMined([
-            tx1.getTxHash(),
-            someTxHashThatThisPeerDidNotSee
-        ], minedBlockHeader);
-        expect(await pool.getMinedTxHashes()).toEqual(expect.arrayContaining([
-            [
-                tx1.getTxHash(),
-                1
-            ],
-            [
-                someTxHashThatThisPeerDidNotSee,
-                1
-            ]
-        ]));
-        // reorg: both txs should now become available again
-        await pool.markMinedAsPending([
-            tx1.getTxHash(),
-            someTxHashThatThisPeerDidNotSee
-        ], BlockNumber(1));
-        await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
-        await expect(pool.getPendingTxHashes()).resolves.toEqual([
-            tx1.getTxHash()
-        ]); // tx2 is not in the pool
-        await expect(pool.getPendingTxCount()).resolves.toEqual(1);
-    });
-    it('returns all transactions in the pool', async ()=>{
-        const tx1 = await mockTx(1);
-        const tx2 = await mockTx(2);
-        const tx3 = await mockTx(3);
-        await pool.addTxs([
-            tx1,
-            tx2,
-            tx3
-        ]);
-        const poolTxs = await pool.getAllTxs();
-        expect(poolTxs).toHaveLength(3);
-        const poolHashes = poolTxs.map((tx)=>tx.getTxHash());
-        expect(poolHashes).toEqual(expect.arrayContaining([
-            tx1.getTxHash(),
-            tx2.getTxHash(),
-            tx3.getTxHash()
-        ]));
-        await expect(pool.getPendingTxCount()).resolves.toEqual(3);
-    });
-    it('returns all txHashes in the pool', async ()=>{
-        const tx1 = await mockTx(1);
-        const tx2 = await mockTx(2);
-        const tx3 = await mockTx(3);
-        await pool.addTxs([
-            tx1,
-            tx2,
-            tx3
-        ]);
-        const poolTxHashes = await pool.getAllTxHashes();
-        const expectedHashes = [
-            tx1,
-            tx2,
-            tx3
-        ].map((tx)=>tx.getTxHash());
-        expect(poolTxHashes).toHaveLength(3);
-        expect(poolTxHashes).toEqual(expect.arrayContaining(expectedHashes));
-        await expect(pool.getPendingTxCount()).resolves.toEqual(3);
-    });
-    it('returns txs by their hash', async ()=>{
-        const tx1 = await mockTx(1);
-        const tx2 = await mockTx(2);
-        const tx3 = await mockTx(3);
-        await pool.addTxs([
-            tx1,
-            tx2,
-            tx3
-        ]);
-        const requestedTxs = await pool.getTxsByHash([
-            tx1.getTxHash(),
-            tx3.getTxHash()
-        ]);
-        expect(requestedTxs).toHaveLength(2);
-        const requestedHashes = requestedTxs.map((tx)=>tx.getTxHash());
-        expect(requestedHashes).toEqual(expect.arrayContaining([
-            tx1.getTxHash(),
-            tx3.getTxHash()
-        ]));
-    });
-    it('returns a large number of transactions by their hash', async ()=>{
-        const numTxs = 1_000;
-        const txs = await Promise.all(Array.from({
-            length: numTxs
-        }, (_, i)=>mockTx(i)));
-        const hashes = txs.map((tx)=>tx.getTxHash());
-        await pool.addTxs(txs);
-        const requestedTxs = await pool.getTxsByHash(hashes);
-        expect(requestedTxs).toHaveLength(numTxs);
-        const requestedHashes = requestedTxs.map((tx)=>tx.getTxHash());
-        expect(requestedHashes).toEqual(expect.arrayContaining(hashes));
-    });
-    it('returns whether or not txs exist', async ()=>{
-        const tx1 = await mockTx(1);
-        const tx2 = await mockTx(2);
-        const tx3 = await mockTx(3);
-        await pool.addTxs([
-            tx1,
-            tx2,
-            tx3
-        ]);
-        const tx4 = await mockTx(4);
-        const tx5 = await mockTx(5);
-        const availability = await pool.hasTxs([
-            tx1.getTxHash(),
-            tx2.getTxHash(),
-            tx3.getTxHash(),
-            tx4.getTxHash(),
-            tx5.getTxHash()
-        ]);
-        expect(availability).toHaveLength(5);
-        expect(availability).toEqual(expect.arrayContaining([
-            true,
-            true,
-            true,
-            false,
-            false
-        ]));
-    });
-    it('returns pending tx hashes sorted by priority', async ()=>{
-        const withPriorityFee = (tx, fee)=>{
-            unfreeze(tx.data.constants.txContext.gasSettings).maxPriorityFeesPerGas = new GasFees(fee, fee);
-            return tx;
-        };
-        const tx1 = withPriorityFee(await mockTx(0), 1000);
-        const tx2 = withPriorityFee(await mockTx(1), 100);
-        const tx3 = withPriorityFee(await mockTx(2), 200);
-        const tx4 = withPriorityFee(await mockTx(3), 3000);
-        await pool.addTxs([
-            tx1,
-            tx2,
-            tx3,
-            tx4
-        ]);
-        const poolTxHashes = await pool.getPendingTxHashes();
-        expect(poolTxHashes).toHaveLength(4);
-        expect(poolTxHashes).toEqual([
-            tx4,
-            tx1,
-            tx3,
-            tx2
-        ].map((tx)=>tx.getTxHash()));
-    });
-    describe('soft-delete', ()=>{
-        it('soft-deletes mined txs and keeps them in storage', async ()=>{
-            const txs = await Promise.all([
-                mockTx(1),
-                mockTx(2),
-                mockTx(3)
-            ]);
-            await pool.addTxs(txs);
-            // Mark first tx as mined
-            await pool.markAsMined([
-                txs[0].getTxHash()
-            ], minedBlockHeader);
-            // Verify initial state
-            await expect(pool.getPendingTxCount()).resolves.toBe(2);
-            await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
-            await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeDefined();
-            // Delete mined tx - should be soft-deleted
-            await pool.deleteTxs([
-                txs[0].getTxHash()
-            ]);
-            // Delete pending tx - should be permanently deleted
-            await pool.deleteTxs([
-                txs[1].getTxHash()
-            ]);
-            // Verify mined tx still exists in storage but has 'deleted' status
-            await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
-            await expect(pool.getTxStatus(txs[0].getTxHash())).resolves.toEqual('deleted');
-            // Verify pending tx is permanently deleted
-            await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeUndefined();
-            await expect(pool.getTxStatus(txs[1].getTxHash())).resolves.toBeUndefined();
-            // Verify remaining pending count
-            await expect(pool.getPendingTxCount()).resolves.toBe(1);
-            // Verify pending hashes don't include deleted txs
-            const pendingHashes = await pool.getPendingTxHashes();
-            expect(pendingHashes).toHaveLength(1);
-            expect(pendingHashes.map((h)=>h.toString())).toContain(txs[2].getTxHash().toString());
-        });
-        it('cleans up old deleted mined transactions', async ()=>{
-            const txs = await Promise.all([
-                mockTx(1),
-                mockTx(2),
-                mockTx(3)
-            ]);
-            await pool.addTxs(txs);
-            // Mark first two as mined in block 1
-            await pool.markAsMined([
-                txs[0].getTxHash(),
-                txs[1].getTxHash()
-            ], minedBlockHeader);
-            // Soft-delete mined transactions
-            await pool.deleteTxs([
-                txs[0].getTxHash(),
-                txs[1].getTxHash()
-            ]);
-            // Clean up deleted mined txs from block 1 and earlier
-            const deletedCount = await pool.cleanupDeletedMinedTxs(BlockNumber(1));
-            // Verify old transactions are permanently deleted
-            expect(deletedCount).toBe(2);
-            await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeUndefined();
-            await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeUndefined();
-            await expect(pool.getTxByHash(txs[2].getTxHash())).resolves.toBeDefined();
-        });
-        it('does not clean up recent deleted mined transactions', async ()=>{
-            const txs = await Promise.all([
-                mockTx(1),
-                mockTx(2)
-            ]);
-            await pool.addTxs(txs);
-            // Mark as mined in block 2
-            const laterBlockHeader = BlockHeader.empty({
-                globalVariables: GlobalVariables.empty({
-                    blockNumber: BlockNumber(2),
-                    timestamp: 0n
-                })
-            });
-            await pool.markAsMined([
-                txs[0].getTxHash()
-            ], laterBlockHeader);
-            // Soft-delete a mined transaction
-            await pool.deleteTxs([
-                txs[0].getTxHash()
-            ]);
-            // Try to clean up with block 1 (before the mined block)
-            const deletedCount = await pool.cleanupDeletedMinedTxs(BlockNumber(1));
-            // Verify no transactions were cleaned up
-            expect(deletedCount).toBe(0);
-            await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
-        });
-        it('restores deleted mined tx when it is mined again', async ()=>{
-            const tx = await mockTx(1);
-            await pool.addTxs([
-                tx
-            ]);
-            // Mark as mined
-            await pool.markAsMined([
-                tx.getTxHash()
-            ], minedBlockHeader);
-            // Soft-delete it
-            await pool.deleteTxs([
-                tx.getTxHash()
-            ]);
-            await expect(pool.getTxStatus(tx.getTxHash())).resolves.toEqual('deleted');
-            // Mark as mined again (e.g., after a reorg)
-            await pool.markAsMined([
-                tx.getTxHash()
-            ], minedBlockHeader);
-            // Should be back to mined status
-            await expect(pool.getTxStatus(tx.getTxHash())).resolves.toEqual('mined');
-            await expect(pool.getTxByHash(tx.getTxHash())).resolves.toBeDefined();
-        });
-    });
-}

package/dest/msg_validators/proposal_validator/proposal_validator_test_suite.d.ts

@@ -1,24 +0,0 @@
-import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import { type BlockProposal, type CheckpointProposal, type ValidationResult } from '@aztec/stdlib/p2p';
-import type { TxHash } from '@aztec/stdlib/tx';
-import type { MockProxy } from 'jest-mock-extended';
-export interface ProposalValidatorTestParams<TProposal extends BlockProposal | CheckpointProposal> {
-    validatorFactory: (epochCache: EpochCacheInterface, opts: {
-        txsPermitted: boolean;
-        maxTxsPerBlock?: number;
-    }) => {
-        validate: (proposal: TProposal) => Promise<ValidationResult>;
-    };
-    makeProposal: (options?: any) => Promise<TProposal>;
-    makeHeader: (epochNumber: number | bigint, slotNumber: number | bigint, blockNumber: number | bigint) => any;
-    getSigner: () => Secp256k1Signer;
-    getAddress: (signer?: Secp256k1Signer) => EthAddress;
-    getSlot: (slot: number | bigint) => any;
-    getTxHashes: (n: number) => TxHash[];
-    getTxs: () => any[];
-    epochCacheMock: () => MockProxy<EpochCacheInterface>;
-}
-export declare function sharedProposalValidatorTests<TProposal extends BlockProposal | CheckpointProposal>(params: ProposalValidatorTestParams<TProposal>): void;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvcG9zYWxfdmFsaWRhdG9yX3Rlc3Rfc3VpdGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tc2dfdmFsaWRhdG9ycy9wcm9wb3NhbF92YWxpZGF0b3IvcHJvcG9zYWxfdmFsaWRhdG9yX3Rlc3Rfc3VpdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUU5RCxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUNqRixPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUNoRSxPQUFPLEVBQ0wsS0FBSyxhQUFhLEVBQ2xCLEtBQUssa0JBQWtCLEVBRXZCLEtBQUssZ0JBQWdCLEVBQ3RCLE1BQU0sbUJBQW1CLENBQUM7QUFDM0IsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFHL0MsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFcEQsTUFBTSxXQUFXLDJCQUEyQixDQUFDLFNBQVMsU0FBUyxhQUFhLEdBQUcsa0JBQWtCO0lBQy9GLGdCQUFnQixFQUFFLENBQ2hCLFVBQVUsRUFBRSxtQkFBbUIsRUFDL0IsSUFBSSxFQUFFO1FBQUUsWUFBWSxFQUFFLE9BQU8sQ0FBQztRQUFDLGNBQWMsQ0FBQyxFQUFFLE1BQU0sQ0FBQTtLQUFFLEtBQ3JEO1FBQUUsUUFBUSxFQUFFLENBQUMsUUFBUSxFQUFFLFNBQVMsS0FBSyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FBQTtLQUFFLENBQUM7SUFDdEUsWUFBWSxFQUFFLENBQUMsT0FBTyxDQUFDLEVBQUUsR0FBRyxLQUFLLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNwRCxVQUFVLEVBQUUsQ0FBQyxXQUFXLEVBQUUsTUFBTSxHQUFHLE1BQU0sRUFBRSxVQUFVLEVBQUUsTUFBTSxHQUFHLE1BQU0sRUFBRSxXQUFXLEVBQUUsTUFBTSxHQUFHLE1BQU0sS0FBSyxHQUFHLENBQUM7SUFDN0csU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0lBQ2pDLFVBQVUsRUFBRSxDQUFDLE1BQU0sQ0FBQyxFQUFFLGVBQWUsS0FBSyxVQUFVLENBQUM7SUFDckQsT0FBTyxFQUFFLENBQUMsSUFBSSxFQUFFLE1BQU0sR0FBRyxNQUFNLEtBQUssR0FBRyxDQUFDO0lBQ3hDLFdBQVcsRUFBRSxDQUFDLENBQUMsRUFBRSxNQUFNLEtBQUssTUFBTSxFQUFFLENBQUM7SUFDckMsTUFBTSxFQUFFLE1BQU0sR0FBRyxFQUFFLENBQUM7SUFDcEIsY0FBYyxFQUFFLE1BQU0sU0FBUyxDQUFDLG1CQUFtQixDQUFDLENBQUM7Q0FDdEQ7QUFFRCx3QkFBZ0IsNEJBQTRCLENBQUMsU0FBUyxTQUFTLGFBQWEsR0FBRyxrQkFBa0IsRUFDL0YsTUFBTSxFQUFFLDJCQUEyQixDQUFDLFNBQVMsQ0FBQyxRQXFWL0MifQ==

package/dest/msg_validators/proposal_validator/proposal_validator_test_suite.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"proposal_validator_test_suite.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/proposal_validator/proposal_validator_test_suite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,kBAAkB,EAEvB,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAG/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,MAAM,WAAW,2BAA2B,CAAC,SAAS,SAAS,aAAa,GAAG,kBAAkB;IAC/F,gBAAgB,EAAE,CAChB,UAAU,EAAE,mBAAmB,EAC/B,IAAI,EAAE;QAAE,YAAY,EAAE,OAAO,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,KACrD;QAAE,QAAQ,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAA;KAAE,CAAC;IACtE,YAAY,EAAE,CAAC,OAAO,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACpD,UAAU,EAAE,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,KAAK,GAAG,CAAC;IAC7G,SAAS,EAAE,MAAM,eAAe,CAAC;IACjC,UAAU,EAAE,CAAC,MAAM,CAAC,EAAE,eAAe,KAAK,UAAU,CAAC;IACrD,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,KAAK,GAAG,CAAC;IACxC,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;IACrC,MAAM,EAAE,MAAM,GAAG,EAAE,CAAC;IACpB,cAAc,EAAE,MAAM,SAAS,CAAC,mBAAmB,CAAC,CAAC;CACtD;AAED,wBAAgB,4BAA4B,CAAC,SAAS,SAAS,aAAa,GAAG,kBAAkB,EAC/F,MAAM,EAAE,2BAA2B,CAAC,SAAS,CAAC,QAqV/C"}