@aztec/p2p 0.0.1-commit.2448fdb → 0.0.1-commit.2606882

package/dest/mem_pools/tx_pool/tx_pool_test_suite.js

@@ -1,402 +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)=>{
-            const gs = unfreeze(tx.data.constants.txContext.gasSettings);
-            gs.maxPriorityFeesPerGas = new GasFees(fee, fee);
-            gs.maxFeesPerGas = 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/services/reqresp/connection-sampler/batch_connection_sampler.d.ts

@@ -1,64 +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;
-    /** Tracks peer-index combinations that returned empty/invalid responses */
-    private readonly failedPeerIndices;
-    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.
-     * If the primary peer has previously failed for this index, tries other peers.
-     * If all batch peers have failed, attempts to sample a new peer.
-     *
-     * @param index - The request index
-     * @returns The peer assigned to handle this request, or undefined if no peer available
-     */
-    getPeerForRequest(index: number): PeerId | undefined;
-    /**
-     * Attempts to sample a new peer that isn't already in the batch.
-     * If successful, adds the peer to the batch.
-     *
-     * @returns The new peer if one was sampled, undefined otherwise
-     */
-    private sampleNewPeer;
-    /**
-     * Marks that a peer returned an empty/invalid response for a specific request index.
-     * The peer will not be assigned this index again.
-     *
-     * @param peerId - The peer that failed
-     * @param index - The request index that failed
-     */
-    markPeerFailedForIndex(peerId: PeerId, index: number): void;
-    /**
-     * 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmF0Y2hfY29ubmVjdGlvbl9zYW1wbGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc2VydmljZXMvcmVxcmVzcC9jb25uZWN0aW9uLXNhbXBsZXIvYmF0Y2hfY29ubmVjdGlvbl9zYW1wbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRWhELE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFakU7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gscUJBQWEsc0JBQXNCO0lBTy9CLE9BQU8sQ0FBQyxRQUFRLENBQUMsaUJBQWlCO0lBSWxDLE9BQU8sQ0FBQyxRQUFRLENBQUMsTUFBTTtJQVZ6QixPQUFPLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBZ0I7SUFDdEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxlQUFlLENBQVM7SUFDekMsMkVBQTJFO0lBQzNFLE9BQU8sQ0FBQyxRQUFRLENBQUMsaUJBQWlCLENBQXVDO0lBRXpFLFlBQ21CLGlCQUFpQixFQUFFLGlCQUFpQixFQUNyRCxTQUFTLEVBQUUsTUFBTSxFQUNqQixRQUFRLEVBQUUsTUFBTSxFQUNoQixPQUFPLENBQUMsRUFBRSxNQUFNLEVBQUUsRUFDRCxNQUFNLHlDQUF1RCxFQWUvRTtJQUVEOzs7Ozs7O09BT0c7SUFDSCxpQkFBaUIsQ0FBQyxLQUFLLEVBQUUsTUFBTSxHQUFHLE1BQU0sR0FBRyxTQUFTLENBMkJuRDtJQUVEOzs7OztPQUtHO0lBQ0gsT0FBTyxDQUFDLGFBQWE7SUFjckI7Ozs7OztPQU1HO0lBQ0gsc0JBQXNCLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLElBQUksQ0FTMUQ7SUFFRDs7Ozs7T0FLRztJQUNILG9CQUFvQixDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsSUFBSSxDQWlCekM7SUFFRDs7T0FFRztJQUNILElBQUksZUFBZSxJQUFJLE1BQU0sQ0FFNUI7SUFFRDs7T0FFRztJQUNILElBQUksaUJBQWlCLElBQUksTUFBTSxDQUU5QjtDQUNGIn0=

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;IAO/B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAIlC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAVzB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,2EAA2E;IAC3E,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAuC;IAEzE,YACmB,iBAAiB,EAAE,iBAAiB,EACrD,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,EAAE,EACD,MAAM,yCAAuD,EAe/E;IAED;;;;;;;OAOG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CA2BnD;IAED;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAcrB;;;;;;OAMG;IACH,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAS1D;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"}

package/dest/services/reqresp/connection-sampler/batch_connection_sampler.js

@@ -1,151 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-/**
- * 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 class BatchConnectionSampler {
-    connectionSampler;
-    logger;
-    batch;
-    requestsPerPeer;
-    /** Tracks peer-index combinations that returned empty/invalid responses */ failedPeerIndices;
-    constructor(connectionSampler, batchSize, maxPeers, exclude, logger = createLogger('p2p:reqresp:batch-connection-sampler')){
-        this.connectionSampler = connectionSampler;
-        this.logger = logger;
-        this.batch = [];
-        this.failedPeerIndices = new Map();
-        if (maxPeers <= 0) {
-            throw new Error('Max peers cannot be 0');
-        }
-        if (batchSize <= 0) {
-            throw new Error('Batch size cannot be 0');
-        }
-        // Calculate how many requests each peer should handle, cannot be 0
-        this.requestsPerPeer = Math.max(1, Math.floor(batchSize / maxPeers));
-        // Sample initial peers
-        const excluding = exclude && new Map(exclude.map((peerId)=>[
-                peerId.toString(),
-                true
-            ]));
-        this.batch = this.connectionSampler.samplePeersBatch(maxPeers, excluding);
-    }
-    /**
-   * Gets the peer responsible for handling a specific request index.
-   * If the primary peer has previously failed for this index, tries other peers.
-   * If all batch peers have failed, attempts to sample a new peer.
-   *
-   * @param index - The request index
-   * @returns The peer assigned to handle this request, or undefined if no peer available
-   */ getPeerForRequest(index) {
-        if (this.batch.length === 0) {
-            return undefined;
-        }
-        // Calculate which peer bucket this index belongs to
-        const primaryPeerIndex = Math.floor(index / this.requestsPerPeer) % this.batch.length;
-        // Try peers starting from primary, wrapping around
-        for(let offset = 0; offset < this.batch.length; offset++){
-            const peerIndex = (primaryPeerIndex + offset) % this.batch.length;
-            const peer = this.batch[peerIndex];
-            const peerKey = peer.toString();
-            const failedIndices = this.failedPeerIndices.get(peerKey);
-            if (!failedIndices || !failedIndices.has(index)) {
-                return peer;
-            }
-        }
-        // All batch peers have failed for this index - try to sample a new peer
-        const newPeer = this.sampleNewPeer();
-        if (newPeer) {
-            return newPeer;
-        }
-        return undefined;
-    }
-    /**
-   * Attempts to sample a new peer that isn't already in the batch.
-   * If successful, adds the peer to the batch.
-   *
-   * @returns The new peer if one was sampled, undefined otherwise
-   */ sampleNewPeer() {
-        // Exclude all current batch peers
-        const excluding = new Map(this.batch.map((p)=>[
-                p.toString(),
-                true
-            ]));
-        const newPeer = this.connectionSampler.getPeer(excluding);
-        if (newPeer) {
-            this.batch.push(newPeer);
-            this.logger.trace('Sampled new peer for exhausted index', {
-                newPeer: newPeer.toString()
-            });
-            return newPeer;
-        }
-        return undefined;
-    }
-    /**
-   * Marks that a peer returned an empty/invalid response for a specific request index.
-   * The peer will not be assigned this index again.
-   *
-   * @param peerId - The peer that failed
-   * @param index - The request index that failed
-   */ markPeerFailedForIndex(peerId, index) {
-        const peerKey = peerId.toString();
-        let failedIndices = this.failedPeerIndices.get(peerKey);
-        if (!failedIndices) {
-            failedIndices = new Set();
-            this.failedPeerIndices.set(peerKey, failedIndices);
-        }
-        failedIndices.add(index);
-        this.logger.trace('Marked peer failed for index', {
-            peerId: peerKey,
-            index
-        });
-    }
-    /**
-   * 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) {
-        const index = this.batch.findIndex((p)=>p === peerId);
-        if (index === -1) {
-            return;
-        }
-        const excluding = new Map([
-            [
-                peerId.toString(),
-                true
-            ]
-        ]);
-        const newPeer = this.connectionSampler.getPeer(excluding); // Q: Shouldn't we accumulate all excluded peers? Otherwise the sampler could return us a previously excluded peer?
-        if (newPeer) {
-            this.batch[index] = newPeer;
-            this.logger.trace('Replaced peer', {
-                peerId,
-                newPeer
-            });
-        } else {
-            // If we couldn't get a replacement, remove the peer and compact the array
-            this.batch.splice(index, 1);
-            this.logger.trace('Removed peer', {
-                peerId
-            });
-        }
-    }
-    /**
-   * Gets the number of active peers
-   */ get activePeerCount() {
-        return this.batch.length;
-    }
-    /**
-   * Gets the number of requests each peer is assigned to handle
-   */ get requestsPerBucket() {
-        return this.requestsPerPeer;
-    }
-}

package/dest/services/reqresp/protocols/block.d.ts

@@ -1,9 +0,0 @@
-import type { L2BlockSource } from '@aztec/stdlib/block';
-import type { ReqRespSubProtocolHandler } from '../interface.js';
-/**
- * Handler for L2 Block requests
- * @param l2BlockSource - source for L2 blocks
- * @returns the Block request handler
- * */
-export declare function reqRespBlockHandler(l2BlockSource: L2BlockSource): ReqRespSubProtocolHandler;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvY2suZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9zZXJ2aWNlcy9yZXFyZXNwL3Byb3RvY29scy9ibG9jay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUl6RCxPQUFPLEtBQUssRUFBRSx5QkFBeUIsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBR2pFOzs7O0tBSUs7QUFDTCx3QkFBZ0IsbUJBQW1CLENBQUMsYUFBYSxFQUFFLGFBQWEsR0FBRyx5QkFBeUIsQ0FzQjNGIn0=

package/dest/services/reqresp/protocols/block.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../../src/services/reqresp/protocols/block.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAGjE;;;;KAIK;AACL,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,aAAa,GAAG,yBAAyB,CAsB3F"}

package/dest/services/reqresp/protocols/block.js

@@ -1,32 +0,0 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { ReqRespStatus, ReqRespStatusError } from '../status.js';
-/**
- * Handler for L2 Block requests
- * @param l2BlockSource - source for L2 blocks
- * @returns the Block request handler
- * */ export function reqRespBlockHandler(l2BlockSource) {
-    /**
-   * @param peerId - the peer ID of the requester
-   * @param msg - the block request message, which is expected to contain valid block number as a Buffer
-   * @returns a Buffer containing the requested block data, or an empty Buffer if the block is not found
-   * @throws  ReqRespStatusError if the input msg is not a valid block number
-   * */ return async (_peerId, msg)=>{
-        let blockNumber;
-        try {
-            blockNumber = Fr.fromBuffer(msg);
-        } catch (err) {
-            throw new ReqRespStatusError(ReqRespStatus.BADLY_FORMED_REQUEST, {
-                cause: err
-            });
-        }
-        try {
-            const foundBlock = await l2BlockSource.getBlock(BlockNumber(Number(blockNumber)));
-            return foundBlock ? foundBlock.toBuffer() : Buffer.alloc(0);
-        } catch (err) {
-            throw new ReqRespStatusError(ReqRespStatus.INTERNAL_ERROR, {
-                cause: err
-            });
-        }
-    };
-}