@aztec/p2p 0.0.1-commit.9b94fc1 → 0.0.1-commit.9badcec54

package/dest/mem_pools/tx_pool/tx_pool_test_suite.js

@@ -1,394 +0,0 @@
-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: 1,
-            timestamp: 0n
-        })
-    });
-    beforeEach(()=>{
-        pool = getTxPool();
-    });
-    afterEach(()=>{
-        pool.removeAllListeners('txs-added');
-    });
-    it('adds txs to the pool as pending', async ()=>{
-        const tx1 = await mockTx();
-        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(); // existing and pending
-        const tx2 = await mockTx(); // mined but not known
-        const tx3 = await mockTx(); // 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);
-        expect(txsFromEvent).toEqual(expect.arrayContaining([
-            tx2,
-            tx3
-        ]));
-    });
-    it('permanently deletes pending txs and soft-deletes mined txs', 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);
-        await expect(pool.getTxByHash(tx1.getTxHash())).resolves.toEqual(tx1);
-        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()
-        ]);
-        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
-        ]);
-        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);
-        expect(poolTxs).toEqual(expect.arrayContaining([
-            tx1,
-            tx2,
-            tx3
-        ]));
-        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);
-        expect(requestedTxs).toEqual(expect.arrayContaining([
-            tx1,
-            tx3
-        ]));
-    });
-    it('returns a large number of transactions by their hash', async ()=>{
-        const numTxs = 1000;
-        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);
-        expect(requestedTxs).toEqual(expect.arrayContaining(txs));
-    });
-    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(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: 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(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/block_proposal_validator/block_proposal_validator.d.ts

@@ -1,12 +0,0 @@
-import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { type BlockProposal, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
-export declare class BlockProposalValidator implements P2PValidator<BlockProposal> {
-    private epochCache;
-    private logger;
-    private txsPermitted;
-    constructor(epochCache: EpochCacheInterface, opts: {
-        txsPermitted: boolean;
-    });
-    validate(block: BlockProposal): Promise<PeerErrorSeverity | undefined>;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvY2tfcHJvcG9zYWxfdmFsaWRhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbXNnX3ZhbGlkYXRvcnMvYmxvY2tfcHJvcG9zYWxfdmFsaWRhdG9yL2Jsb2NrX3Byb3Bvc2FsX3ZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRzlELE9BQU8sRUFBRSxLQUFLLGFBQWEsRUFBRSxLQUFLLFlBQVksRUFBRSxpQkFBaUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRTdGLHFCQUFhLHNCQUF1QixZQUFXLFlBQVksQ0FBQyxhQUFhLENBQUM7SUFDeEUsT0FBTyxDQUFDLFVBQVUsQ0FBc0I7SUFDeEMsT0FBTyxDQUFDLE1BQU0sQ0FBUztJQUN2QixPQUFPLENBQUMsWUFBWSxDQUFVO0lBRTlCLFlBQVksVUFBVSxFQUFFLG1CQUFtQixFQUFFLElBQUksRUFBRTtRQUFFLFlBQVksRUFBRSxPQUFPLENBQUE7S0FBRSxFQUkzRTtJQUVLLFFBQVEsQ0FBQyxLQUFLLEVBQUUsYUFBYSxHQUFHLE9BQU8sQ0FBQyxpQkFBaUIsR0FBRyxTQUFTLENBQUMsQ0ErRTNFO0NBQ0YifQ==

package/dest/msg_validators/block_proposal_validator/block_proposal_validator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"block_proposal_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/block_proposal_validator/block_proposal_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAG9D,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE7F,qBAAa,sBAAuB,YAAW,YAAY,CAAC,aAAa,CAAC;IACxE,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,YAAY,CAAU;IAE9B,YAAY,UAAU,EAAE,mBAAmB,EAAE,IAAI,EAAE;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,EAI3E;IAEK,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CA+E3E;CACF"}

package/dest/msg_validators/block_proposal_validator/block_proposal_validator.js

@@ -1,82 +0,0 @@
-import { NoCommitteeError } from '@aztec/ethereum';
-import { createLogger } from '@aztec/foundation/log';
-import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
-export class BlockProposalValidator {
-    epochCache;
-    logger;
-    txsPermitted;
-    constructor(epochCache, opts){
-        this.epochCache = epochCache;
-        this.txsPermitted = opts.txsPermitted;
-        this.logger = createLogger('p2p:block_proposal_validator');
-    }
-    async validate(block) {
-        try {
-            // Check signature validity first - invalid signatures are a high-severity issue
-            const proposer = block.getSender();
-            if (!proposer) {
-                this.logger.debug(`Penalizing peer for block proposal with invalid signature`);
-                return PeerErrorSeverity.MidToleranceError;
-            }
-            // Check if transactions are permitted when the proposal contains transaction hashes
-            const embeddedTxCount = block.txs?.length ?? 0;
-            if (!this.txsPermitted && (block.txHashes.length > 0 || embeddedTxCount > 0)) {
-                this.logger.debug(`Penalizing peer for block proposal with ${block.txHashes.length} transaction(s) when transactions are not permitted`);
-                return PeerErrorSeverity.MidToleranceError;
-            }
-            // If there are embedded txs, they must be listed in txHashes; if there are no txHashes, there must be no txs
-            const hashSet = new Set(block.txHashes.map((h)=>h.toString()));
-            const missingTxHashes = embeddedTxCount > 0 ? block.txs.filter((tx)=>!hashSet.has(tx.getTxHash().toString())).map((tx)=>tx.getTxHash().toString()) : [];
-            if (embeddedTxCount > 0 && missingTxHashes.length > 0) {
-                this.logger.warn('Penalizing peer for embedded transaction(s) not included in txHashes', {
-                    embeddedTxCount,
-                    txHashesLength: block.txHashes.length,
-                    missingTxHashes
-                });
-                return PeerErrorSeverity.MidToleranceError;
-            }
-            const { currentProposer, nextProposer, currentSlot, nextSlot } = await this.epochCache.getProposerAttesterAddressInCurrentOrNextSlot();
-            // Check that the attestation is for the current or next slot
-            const slotNumber = block.payload.header.slotNumber;
-            if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
-                this.logger.debug(`Penalizing peer for invalid slot number ${slotNumber}`, {
-                    currentSlot,
-                    nextSlot
-                });
-                return PeerErrorSeverity.HighToleranceError;
-            }
-            // Check that the block proposal is from the current or next proposer
-            if (slotNumber === currentSlot && currentProposer !== undefined && !proposer.equals(currentProposer)) {
-                this.logger.debug(`Penalizing peer for invalid proposer for current slot ${slotNumber}`, {
-                    currentProposer,
-                    nextProposer,
-                    proposer: proposer.toString()
-                });
-                return PeerErrorSeverity.MidToleranceError;
-            }
-            if (slotNumber === nextSlot && nextProposer !== undefined && !proposer.equals(nextProposer)) {
-                this.logger.debug(`Penalizing peer for invalid proposer for next slot ${slotNumber}`, {
-                    currentProposer,
-                    nextProposer,
-                    proposer: proposer.toString()
-                });
-                return PeerErrorSeverity.MidToleranceError;
-            }
-            // Validate tx hashes for all txs embedded in the proposal
-            if (!(await Promise.all(block.txs?.map((tx)=>tx.validateTxHash()) ?? [])).every((v)=>v)) {
-                this.logger.warn(`Penalizing peer for invalid tx hashes in block proposal`, {
-                    proposer,
-                    slotNumber
-                });
-                return PeerErrorSeverity.LowToleranceError;
-            }
-            return undefined;
-        } catch (e) {
-            // People shouldn't be sending us block proposals if the committee doesn't exist
-            if (e instanceof NoCommitteeError) {
-                return PeerErrorSeverity.LowToleranceError;
-            }
-            throw e;
-        }
-    }
-}

package/dest/msg_validators/block_proposal_validator/index.d.ts

@@ -1,2 +0,0 @@
-export * from './block_proposal_validator.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tc2dfdmFsaWRhdG9ycy9ibG9ja19wcm9wb3NhbF92YWxpZGF0b3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywrQkFBK0IsQ0FBQyJ9

package/dest/msg_validators/block_proposal_validator/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/block_proposal_validator/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC"}

package/dest/msg_validators/block_proposal_validator/index.js

@@ -1 +0,0 @@
-export * from './block_proposal_validator.js';

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

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":"AACA,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,31 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-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(Number(blockNumber));
-            return foundBlock ? foundBlock.toBuffer() : Buffer.alloc(0);
-        } catch (err) {
-            throw new ReqRespStatusError(ReqRespStatus.INTERNAL_ERROR, {
-                cause: err
-            });
-        }
-    };
-}