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

package/dest/mem_pools/tx_pool/tx_pool_test_suite.d.ts

@@ -1,7 +0,0 @@
-import type { TxPool } from './tx_pool.js';
-/**
- * Tests a TxPool implementation.
- * @param getTxPool - Gets a fresh TxPool
- */
-export declare function describeTxPool(getTxPool: () => TxPool): void;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfcG9vbF90ZXN0X3N1aXRlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVtX3Bvb2xzL3R4X3Bvb2wvdHhfcG9vbF90ZXN0X3N1aXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUUzQzs7O0dBR0c7QUFDSCx3QkFBZ0IsY0FBYyxDQUFDLFNBQVMsRUFBRSxNQUFNLE1BQU0sUUFrVHJEIn0=

package/dest/mem_pools/tx_pool/tx_pool_test_suite.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tx_pool_test_suite.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool/tx_pool_test_suite.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C;;;GAGG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,MAAM,QAkTrD"}

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,23 +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, PeerErrorSeverity } 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;
-    }) => {
-        validate: (proposal: TProposal) => Promise<PeerErrorSeverity | undefined>;
-    };
-    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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvcG9zYWxfdmFsaWRhdG9yX3Rlc3Rfc3VpdGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tc2dfdmFsaWRhdG9ycy9wcm9wb3NhbF92YWxpZGF0b3IvcHJvcG9zYWxfdmFsaWRhdG9yX3Rlc3Rfc3VpdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUM5RCxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUNqRixPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUNoRSxPQUFPLEVBQUUsS0FBSyxhQUFhLEVBQUUsS0FBSyxrQkFBa0IsRUFBRSxpQkFBaUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ25HLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRS9DLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXBELE1BQU0sV0FBVywyQkFBMkIsQ0FBQyxTQUFTLFNBQVMsYUFBYSxHQUFHLGtCQUFrQjtJQUMvRixnQkFBZ0IsRUFBRSxDQUNoQixVQUFVLEVBQUUsbUJBQW1CLEVBQy9CLElBQUksRUFBRTtRQUFFLFlBQVksRUFBRSxPQUFPLENBQUE7S0FBRSxLQUM1QjtRQUFFLFFBQVEsRUFBRSxDQUFDLFFBQVEsRUFBRSxTQUFTLEtBQUssT0FBTyxDQUFDLGlCQUFpQixHQUFHLFNBQVMsQ0FBQyxDQUFBO0tBQUUsQ0FBQztJQUNuRixZQUFZLEVBQUUsQ0FBQyxPQUFPLENBQUMsRUFBRSxHQUFHLEtBQUssT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ3BELFVBQVUsRUFBRSxDQUFDLFdBQVcsRUFBRSxNQUFNLEdBQUcsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLEdBQUcsTUFBTSxFQUFFLFdBQVcsRUFBRSxNQUFNLEdBQUcsTUFBTSxLQUFLLEdBQUcsQ0FBQztJQUM3RyxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7SUFDakMsVUFBVSxFQUFFLENBQUMsTUFBTSxDQUFDLEVBQUUsZUFBZSxLQUFLLFVBQVUsQ0FBQztJQUNyRCxPQUFPLEVBQUUsQ0FBQyxJQUFJLEVBQUUsTUFBTSxHQUFHLE1BQU0sS0FBSyxHQUFHLENBQUM7SUFDeEMsV0FBVyxFQUFFLENBQUMsQ0FBQyxFQUFFLE1BQU0sS0FBSyxNQUFNLEVBQUUsQ0FBQztJQUNyQyxNQUFNLEVBQUUsTUFBTSxHQUFHLEVBQUUsQ0FBQztJQUNwQixjQUFjLEVBQUUsTUFBTSxTQUFTLENBQUMsbUJBQW1CLENBQUMsQ0FBQztDQUN0RDtBQUVELHdCQUFnQiw0QkFBNEIsQ0FBQyxTQUFTLFNBQVMsYUFBYSxHQUFHLGtCQUFrQixFQUMvRixNQUFNLEVBQUUsMkJBQTJCLENBQUMsU0FBUyxDQUFDLFFBcUwvQyJ9

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;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACnG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/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,CAAA;KAAE,KAC5B;QAAE,QAAQ,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAAA;KAAE,CAAC;IACnF,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,QAqL/C"}

package/dest/msg_validators/proposal_validator/proposal_validator_test_suite.js

@@ -1,183 +0,0 @@
-import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
-export function sharedProposalValidatorTests(params) {
-    const { validatorFactory, makeProposal, makeHeader, getSigner, getAddress, getSlot, getTxHashes, epochCacheMock } = params;
-    describe('shared proposal validation logic', ()=>{
-        let epochCache;
-        let validator;
-        beforeEach(()=>{
-            epochCache = epochCacheMock();
-            validator = validatorFactory(epochCache, {
-                txsPermitted: true
-            });
-        });
-        it('returns high tolerance error if slot number is not current or next slot', async ()=>{
-            const header = makeHeader(1, 97, 97);
-            const mockProposal = await makeProposal({
-                blockHeader: header,
-                lastBlockHeader: header
-            });
-            epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-                currentSlot: getSlot(98),
-                nextSlot: getSlot(99),
-                currentProposer: getAddress(),
-                nextProposer: getAddress()
-            });
-            const result = await validator.validate(mockProposal);
-            expect(result).toBe(PeerErrorSeverity.HighToleranceError);
-        });
-        it('returns mid tolerance error if proposer is not current proposer for current slot', async ()=>{
-            const currentProposer = getSigner();
-            const nextProposer = getSigner();
-            const invalidProposer = getSigner();
-            const header = makeHeader(1, 100, 100);
-            const mockProposal = await makeProposal({
-                blockHeader: header,
-                lastBlockHeader: header,
-                signer: invalidProposer
-            });
-            epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-                currentSlot: getSlot(100),
-                nextSlot: getSlot(101),
-                currentProposer: getAddress(currentProposer),
-                nextProposer: getAddress(nextProposer)
-            });
-            const result = await validator.validate(mockProposal);
-            expect(result).toBe(PeerErrorSeverity.MidToleranceError);
-        });
-        it('returns mid tolerance error if proposer is not next proposer for next slot', async ()=>{
-            const currentProposer = getSigner();
-            const nextProposer = getSigner();
-            const invalidProposer = getSigner();
-            const header = makeHeader(1, 101, 101);
-            const mockProposal = await makeProposal({
-                blockHeader: header,
-                lastBlockHeader: header,
-                signer: invalidProposer
-            });
-            epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-                currentSlot: getSlot(100),
-                nextSlot: getSlot(101),
-                currentProposer: getAddress(currentProposer),
-                nextProposer: getAddress(nextProposer)
-            });
-            const result = await validator.validate(mockProposal);
-            expect(result).toBe(PeerErrorSeverity.MidToleranceError);
-        });
-        it('returns mid tolerance error if proposer is current proposer but proposal is for next slot', async ()=>{
-            const currentProposer = getSigner();
-            const nextProposer = getSigner();
-            const header = makeHeader(1, 101, 101);
-            const mockProposal = await makeProposal({
-                blockHeader: header,
-                lastBlockHeader: header,
-                signer: currentProposer
-            });
-            epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-                currentSlot: getSlot(100),
-                nextSlot: getSlot(101),
-                currentProposer: getAddress(currentProposer),
-                nextProposer: getAddress(nextProposer)
-            });
-            const result = await validator.validate(mockProposal);
-            expect(result).toBe(PeerErrorSeverity.MidToleranceError);
-        });
-        it('returns undefined if proposal is valid for current slot and proposer', async ()=>{
-            const currentProposer = getSigner();
-            const nextProposer = getSigner();
-            const header = makeHeader(1, 100, 100);
-            const mockProposal = await makeProposal({
-                blockHeader: header,
-                lastBlockHeader: header,
-                signer: currentProposer
-            });
-            epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-                currentSlot: getSlot(100),
-                nextSlot: getSlot(101),
-                currentProposer: getAddress(currentProposer),
-                nextProposer: getAddress(nextProposer)
-            });
-            const result = await validator.validate(mockProposal);
-            expect(result).toBeUndefined();
-        });
-        it('returns undefined if proposal is valid for next slot and proposer', async ()=>{
-            const currentProposer = getSigner();
-            const nextProposer = getSigner();
-            const header = makeHeader(1, 101, 101);
-            const mockProposal = await makeProposal({
-                blockHeader: header,
-                lastBlockHeader: header,
-                signer: nextProposer
-            });
-            epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-                currentSlot: getSlot(100),
-                nextSlot: getSlot(101),
-                currentProposer: getAddress(currentProposer),
-                nextProposer: getAddress(nextProposer)
-            });
-            const result = await validator.validate(mockProposal);
-            expect(result).toBeUndefined();
-        });
-        describe('transaction permission validation', ()=>{
-            it('returns mid tolerance error if txs not permitted and proposal contains txHashes', async ()=>{
-                const currentProposer = getSigner();
-                const validatorWithTxsDisabled = validatorFactory(epochCache, {
-                    txsPermitted: false
-                });
-                const header = makeHeader(1, 100, 100);
-                const mockProposal = await makeProposal({
-                    blockHeader: header,
-                    lastBlockHeader: header,
-                    signer: currentProposer,
-                    txHashes: getTxHashes(2)
-                });
-                epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-                    currentSlot: getSlot(100),
-                    nextSlot: getSlot(101),
-                    currentProposer: getAddress(currentProposer),
-                    nextProposer: getAddress()
-                });
-                const result = await validatorWithTxsDisabled.validate(mockProposal);
-                expect(result).toBe(PeerErrorSeverity.MidToleranceError);
-            });
-            it('returns undefined if txs not permitted but proposal has no txHashes', async ()=>{
-                const currentProposer = getSigner();
-                const validatorWithTxsDisabled = validatorFactory(epochCache, {
-                    txsPermitted: false
-                });
-                const header = makeHeader(1, 100, 100);
-                const mockProposal = await makeProposal({
-                    blockHeader: header,
-                    lastBlockHeader: header,
-                    signer: currentProposer,
-                    txHashes: getTxHashes(0)
-                });
-                epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-                    currentSlot: getSlot(100),
-                    nextSlot: getSlot(101),
-                    currentProposer: getAddress(currentProposer),
-                    nextProposer: getAddress()
-                });
-                const result = await validatorWithTxsDisabled.validate(mockProposal);
-                expect(result).toBeUndefined();
-            });
-            it('returns undefined if txs permitted and proposal contains txHashes', async ()=>{
-                const currentProposer = getSigner();
-                const header = makeHeader(1, 100, 100);
-                const mockProposal = await makeProposal({
-                    blockHeader: header,
-                    lastBlockHeader: header,
-                    signer: currentProposer,
-                    txHashes: getTxHashes(2)
-                });
-                epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-                    currentSlot: getSlot(100),
-                    nextSlot: getSlot(101),
-                    currentProposer: getAddress(currentProposer),
-                    nextProposer: getAddress()
-                });
-                const result = await validator.validate(mockProposal);
-                expect(result).toBeUndefined();
-            });
-        });
-    });
-}

package/dest/services/reqresp/connection-sampler/batch_connection_sampler.d.ts

@@ -1,45 +0,0 @@
-import type { PeerId } from '@libp2p/interface';
-import type { ConnectionSampler } from './connection_sampler.js';
-/**
- * Manages batches of peers for parallel request processing.
- * Tracks active peers and provides deterministic peer assignment for requests.
- *
- * Example with 3 peers and 10 requests:
- *
- * Peers:    [P1]      [P2]     [P3]
- *           ↓ ↓ ↓ ↓   ↓ ↓ ↓   ↓ ↓ ↓
- * Requests: 0,1,2,9 | 3,4,5 | 6,7,8
- *
- * Each peer handles a bucket of consecutive requests.
- * If a peer fails, it is replaced while maintaining the same bucket.
- */
-export declare class BatchConnectionSampler {
-    private readonly connectionSampler;
-    private readonly logger;
-    private readonly batch;
-    private readonly requestsPerPeer;
-    constructor(connectionSampler: ConnectionSampler, batchSize: number, maxPeers: number, exclude?: PeerId[], logger?: import("@aztec/foundation/log").Logger);
-    /**
-     * Gets the peer responsible for handling a specific request index
-     *
-     * @param index - The request index
-     * @returns The peer assigned to handle this request
-     */
-    getPeerForRequest(index: number): PeerId | undefined;
-    /**
-     * Removes a peer and replaces it with a new one, maintaining the same position
-     * in the batch array to keep request distribution consistent
-     *
-     * @param peerId - The peer to remove and replace
-     */
-    removePeerAndReplace(peerId: PeerId): void;
-    /**
-     * Gets the number of active peers
-     */
-    get activePeerCount(): number;
-    /**
-     * Gets the number of requests each peer is assigned to handle
-     */
-    get requestsPerBucket(): number;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmF0Y2hfY29ubmVjdGlvbl9zYW1wbGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc2VydmljZXMvcmVxcmVzcC9jb25uZWN0aW9uLXNhbXBsZXIvYmF0Y2hfY29ubmVjdGlvbl9zYW1wbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRWhELE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFakU7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gscUJBQWEsc0JBQXNCO0lBSy9CLE9BQU8sQ0FBQyxRQUFRLENBQUMsaUJBQWlCO0lBSWxDLE9BQU8sQ0FBQyxRQUFRLENBQUMsTUFBTTtJQVJ6QixPQUFPLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBZ0I7SUFDdEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxlQUFlLENBQVM7SUFFekMsWUFDbUIsaUJBQWlCLEVBQUUsaUJBQWlCLEVBQ3JELFNBQVMsRUFBRSxNQUFNLEVBQ2pCLFFBQVEsRUFBRSxNQUFNLEVBQ2hCLE9BQU8sQ0FBQyxFQUFFLE1BQU0sRUFBRSxFQUNELE1BQU0seUNBQXVELEVBZS9FO0lBRUQ7Ozs7O09BS0c7SUFDSCxpQkFBaUIsQ0FBQyxLQUFLLEVBQUUsTUFBTSxHQUFHLE1BQU0sR0FBRyxTQUFTLENBUW5EO0lBRUQ7Ozs7O09BS0c7SUFDSCxvQkFBb0IsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLElBQUksQ0FpQnpDO0lBRUQ7O09BRUc7SUFDSCxJQUFJLGVBQWUsSUFBSSxNQUFNLENBRTVCO0lBRUQ7O09BRUc7SUFDSCxJQUFJLGlCQUFpQixJQUFJLE1BQU0sQ0FFOUI7Q0FDRiJ9

package/dest/services/reqresp/connection-sampler/batch_connection_sampler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"batch_connection_sampler.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/connection-sampler/batch_connection_sampler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE;;;;;;;;;;;;GAYG;AACH,qBAAa,sBAAsB;IAK/B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAIlC,OAAO,CAAC,QAAQ,CAAC,MAAM;IARzB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IAEzC,YACmB,iBAAiB,EAAE,iBAAiB,EACrD,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,EAAE,EACD,MAAM,yCAAuD,EAe/E;IAED;;;;;OAKG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAQnD;IAED;;;;;OAKG;IACH,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAiBzC;IAED;;OAEG;IACH,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED;;OAEG;IACH,IAAI,iBAAiB,IAAI,MAAM,CAE9B;CACF"}