@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.1142ef1

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

@@ -1 +1 @@
-{"version":3,"file":"priority.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool/priority.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAE3C;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,EAAE,GAAG,MAAM,CAInD"}
+{"version":3,"file":"priority.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool/priority.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAE3C;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,EAAE,GAAG,MAAM,CAEnD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,EAAE,GAAG,MAAM,CAI/C"}

package/dest/mem_pools/tx_pool/priority.js

@@ -4,7 +4,12 @@ import { Buffer32 } from '@aztec/foundation/buffer';
  * Txs with a higher priority value are returned first when retrieving pending tx hashes.
  * We currently use the sum of the priority fees for the tx for this value, represented as hex.
  */ export function getPendingTxPriority(tx) {
+    return Buffer32.fromBigInt(getTxPriorityFee(tx)).toString();
+}
+/**
+ * Returns the priority of a tx.
+ */ export function getTxPriorityFee(tx) {
     const priorityFees = tx.getGasSettings().maxPriorityFeesPerGas;
-    const totalFees = priorityFees.feePerDaGas.toBigInt() + priorityFees.feePerL2Gas.toBigInt();
-    return Buffer32.fromBigInt(totalFees).toString();
+    const totalFees = priorityFees.feePerDaGas + priorityFees.feePerL2Gas;
+    return totalFees;
 }

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

@@ -1,19 +1,52 @@
-import type { Tx, TxHash } from '@aztec/stdlib/tx';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { TypedEventEmitter } from '@aztec/foundation/types';
+import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
+export type TxPoolOptions = {
+    maxPendingTxCount?: number;
+    archivedTxLimit?: number;
+};
+export type TxPoolEvents = {
+    ['txs-added']: (args: {
+        txs: Tx[];
+        source?: string;
+    }) => void | Promise<void>;
+};
 /**
  * Interface of a transaction pool. The pool includes tx requests and is kept up-to-date by a P2P client.
  */
-export interface TxPool {
+export interface TxPool extends TypedEventEmitter<TxPoolEvents> {
     /**
      * Adds a list of transactions to the pool. Duplicates are ignored.
      * @param txs - An array of txs to be added to the pool.
+     * @returns The number of txs added to the pool. Note if the transaction already exists, it will not be added again.
      */
-    addTxs(txs: Tx[]): Promise<void>;
+    addTxs(txs: Tx[], opts?: {
+        source?: string;
+    }): Promise<number>;
     /**
      * Checks if a transaction exists in the pool and returns it.
      * @param txHash - The hash of the transaction, used as an ID.
      * @returns The transaction, if found, 'undefined' otherwise.
      */
     getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
+    /**
+     * Checks if transactions exist in the pool and returns them.
+     * @param txHashes - The hashes of the transactions
+     * @returns The transactions, if found, 'undefined' otherwise.
+     */
+    getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+    /**
+     * Checks if transactions exist in the pool
+     * @param txHashes - The hashes of the transactions to check for
+     * @returns True or False for each tx hash
+     */
+    hasTxs(txHashes: TxHash[]): Promise<boolean[]>;
+    /**
+     * Checks if a transaction exists in the pool
+     * @param txHash - The hash of the transaction to check for
+     * @returns True if the transaction exists, false otherwise
+     */
+    hasTx(txHash: TxHash): Promise<boolean>;
     /**
      * Checks if an archived transaction exists in the pool and returns it.
      * @param txHash - The hash of the transaction, used as an ID.
@@ -23,19 +56,23 @@ export interface TxPool {
     /**
      * Marks the set of txs as mined, as opposed to pending.
      * @param txHashes - Hashes of the txs to flag as mined.
+     * @param blockHeader - The header of the mined block.
      */
-    markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void>;
+    markAsMined(txHashes: TxHash[], blockHeader: BlockHeader): Promise<void>;
     /**
      * Moves mined txs back to the pending set in the case of a reorg.
      * Note: txs not known by this peer will be ignored.
      * @param txHashes - Hashes of the txs to flag as pending.
+     * @param latestBlock - The block number the chain was pruned to.
      */
-    markMinedAsPending(txHashes: TxHash[]): Promise<void>;
+    markMinedAsPending(txHashes: TxHash[], latestBlock: BlockNumber): Promise<void>;
     /**
      * Deletes transactions from the pool. Tx hashes that are not present are ignored.
      * @param txHashes - An array of tx hashes to be removed from the tx pool.
      */
-    deleteTxs(txHashes: TxHash[]): Promise<void>;
+    deleteTxs(txHashes: TxHash[], opts?: {
+        permanently?: boolean;
+    }): Promise<void>;
     /**
      * Gets all transactions currently in the tx pool.
      * @returns An array of transaction objects found in the tx pool.
@@ -51,16 +88,40 @@ export interface TxPool {
      * @returns An array of pending transaction hashes found in the tx pool.
      */
     getPendingTxHashes(): Promise<TxHash[]>;
+    /** Returns the number of pending txs in the pool. */
+    getPendingTxCount(): Promise<number>;
     /**
      * Gets the hashes of mined transactions currently in the tx pool.
      * @returns An array of mined transaction hashes found in the tx pool.
      */
-    getMinedTxHashes(): Promise<[tx: TxHash, blockNumber: number][]>;
+    getMinedTxHashes(): Promise<[tx: TxHash, blockNumber: BlockNumber][]>;
     /**
-     * Returns whether the given tx hash is flagged as pending or mined.
+     * Returns whether the given tx hash is flagged as pending, mined, or deleted.
      * @param txHash - Hash of the tx to query.
-     * @returns Pending or mined depending on its status, or undefined if not found.
+     * @returns Pending, mined, or deleted depending on its status, or undefined if not found.
+     */
+    getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | 'deleted' | undefined>;
+    /**
+     * Configure the maximum size of the tx pool
+     * @param maxSizeBytes - The maximum size in bytes of the mempool. Set to undefined to disable it
+     */
+    updateConfig(config: TxPoolOptions): void;
+    /** Returns whether the pool is empty. */
+    isEmpty(): Promise<boolean>;
+    /**
+     * Marks transactions as non-evictible in the pool.
+     * @param txHashes - Hashes of the transactions to mark as non-evictible.
+     */
+    markTxsAsNonEvictable(txHashes: TxHash[]): Promise<void>;
+    /**
+     * Clears collection of non-evictable transactions in the pool
+     */
+    clearNonEvictableTxs(): Promise<void>;
+    /**
+     * Permanently deletes deleted mined transactions from blocks up to and including the specified block number.
+     * @param blockNumber - Block number threshold. Deleted mined txs from this block or earlier will be permanently deleted.
+     * @returns The number of transactions permanently deleted.
      */
-    getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined>;
+    cleanupDeletedMinedTxs(blockNumber: BlockNumber): Promise<number>;
 }
-//# sourceMappingURL=tx_pool.d.ts.map
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"tx_pool.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool/tx_pool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjC;;;;OAIG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC;IAErD;;;;OAIG;IACH,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC;IAE7D;;;OAGG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEpE;;;;OAIG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtD;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE7C;;;OAGG;IACH,SAAS,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC;IAE3B;;;OAGG;IACH,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEpC;;;OAGG;IACH,kBAAkB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAExC;;;OAGG;IACH,gBAAgB,IAAI,OAAO,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;IAEjE;;;;OAIG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC,CAAC;CACvE"}
+{"version":3,"file":"tx_pool.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool/tx_pool.ts"],"names":[],"mappings":"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"}

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

@@ -4,4 +4,4 @@ import type { TxPool } from './tx_pool.js';
  * @param getTxPool - Gets a fresh TxPool
  */
 export declare function describeTxPool(getTxPool: () => TxPool): void;
-//# sourceMappingURL=tx_pool_test_suite.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfcG9vbF90ZXN0X3N1aXRlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVtX3Bvb2xzL3R4X3Bvb2wvdHhfcG9vbF90ZXN0X3N1aXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUUzQzs7O0dBR0c7QUFDSCx3QkFBZ0IsY0FBYyxDQUFDLFNBQVMsRUFBRSxNQUFNLE1BQU0sUUFrVHJEIn0=

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

@@ -1 +1 @@
-{"version":3,"file":"tx_pool_test_suite.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool/tx_pool_test_suite.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C;;;GAGG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,MAAM,QAsHrD"}
+{"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,38 +1,91 @@
+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();
     });
-    it('Adds txs to the pool as pending', async ()=>{
-        const tx1 = await mockTx();
+    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(await tx1.getTxHash());
-        expect(await poolTx.getTxHash()).toEqual(await tx1.getTxHash());
-        await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('pending');
+        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([
-            await tx1.getTxHash()
+            tx1.getTxHash()
         ]);
+        await expect(pool.getPendingTxCount()).resolves.toEqual(1);
     });
-    it('Removes txs from the pool', async ()=>{
-        const tx1 = await mockTx();
+    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([
-            await tx1.getTxHash()
+            minedTx.getTxHash()
         ]);
-        await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toBeFalsy();
-        await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toBeUndefined();
+        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 ()=>{
+    it('marks txs as mined', async ()=>{
         const tx1 = await mockTx(1);
         const tx2 = await mockTx(2);
         await pool.addTxs([
@@ -40,21 +93,23 @@ import { mockTx } from '@aztec/stdlib/testing';
             tx2
         ]);
         await pool.markAsMined([
-            await tx1.getTxHash()
-        ], 1);
-        await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toEqual(tx1);
-        await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('mined');
+            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([
             [
-                await tx1.getTxHash(),
+                tx1.getTxHash(),
                 1
             ]
         ]);
         await expect(pool.getPendingTxHashes()).resolves.toEqual([
-            await tx2.getTxHash()
+            tx2.getTxHash()
         ]);
+        await expect(pool.getPendingTxCount()).resolves.toEqual(1);
     });
-    it('Marks txs as pending after being mined', async ()=>{
+    it('marks txs as pending after being mined', async ()=>{
         const tx1 = await mockTx(1);
         const tx2 = await mockTx(2);
         await pool.addTxs([
@@ -62,35 +117,36 @@ import { mockTx } from '@aztec/stdlib/testing';
             tx2
         ]);
         await pool.markAsMined([
-            await tx1.getTxHash()
-        ], 1);
+            tx1.getTxHash()
+        ], minedBlockHeader);
         await pool.markMinedAsPending([
-            await tx1.getTxHash()
-        ]);
+            tx1.getTxHash()
+        ], BlockNumber(1));
         await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
         const pending = await pool.getPendingTxHashes();
         expect(pending).toHaveLength(2);
         expect(pending).toEqual(expect.arrayContaining([
-            await tx1.getTxHash(),
-            await tx2.getTxHash()
+            tx1.getTxHash(),
+            tx2.getTxHash()
         ]));
+        await expect(pool.getPendingTxCount()).resolves.toEqual(2);
     });
-    it('Only marks txs as pending if they are known', async ()=>{
+    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 = await tx2.getTxHash();
+        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([
-            await tx1.getTxHash(),
+            tx1.getTxHash(),
             someTxHashThatThisPeerDidNotSee
-        ], 1);
+        ], minedBlockHeader);
         expect(await pool.getMinedTxHashes()).toEqual(expect.arrayContaining([
             [
-                await tx1.getTxHash(),
+                tx1.getTxHash(),
                 1
             ],
             [
@@ -100,15 +156,16 @@ import { mockTx } from '@aztec/stdlib/testing';
         ]));
         // reorg: both txs should now become available again
         await pool.markMinedAsPending([
-            await tx1.getTxHash(),
+            tx1.getTxHash(),
             someTxHashThatThisPeerDidNotSee
-        ]);
+        ], BlockNumber(1));
         await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
         await expect(pool.getPendingTxHashes()).resolves.toEqual([
-            await tx1.getTxHash()
+            tx1.getTxHash()
         ]); // tx2 is not in the pool
+        await expect(pool.getPendingTxCount()).resolves.toEqual(1);
     });
-    it('Returns all transactions in the pool', async ()=>{
+    it('returns all transactions in the pool', async ()=>{
         const tx1 = await mockTx(1);
         const tx2 = await mockTx(2);
         const tx3 = await mockTx(3);
@@ -119,13 +176,66 @@ import { mockTx } from '@aztec/stdlib/testing';
         ]);
         const poolTxs = await pool.getAllTxs();
         expect(poolTxs).toHaveLength(3);
-        expect(poolTxs).toEqual(expect.arrayContaining([
+        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 all txHashes in the pool', async ()=>{
+    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);
@@ -134,15 +244,25 @@ import { mockTx } from '@aztec/stdlib/testing';
             tx2,
             tx3
         ]);
-        const poolTxHashes = await pool.getAllTxHashes();
-        expect(poolTxHashes).toHaveLength(3);
-        expect(poolTxHashes).toEqual(expect.arrayContaining([
-            await tx1.getTxHash(),
-            await tx2.getTxHash(),
-            await tx3.getTxHash()
+        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 ()=>{
+    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;
@@ -159,11 +279,122 @@ import { mockTx } from '@aztec/stdlib/testing';
         ]);
         const poolTxHashes = await pool.getPendingTxHashes();
         expect(poolTxHashes).toHaveLength(4);
-        expect(poolTxHashes).toEqual(await Promise.all([
+        expect(poolTxHashes).toEqual([
             tx4,
             tx1,
             tx3,
             tx2
-        ].map((tx)=>tx.getTxHash())));
+        ].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/attestation_validator/attestation_validator.d.ts

@@ -1,8 +1,10 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { type BlockAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
-export declare class AttestationValidator implements P2PValidator<BlockAttestation> {
-    private epochCache;
+import { type Logger } from '@aztec/foundation/log';
+import { type CheckpointAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+export declare class CheckpointAttestationValidator implements P2PValidator<CheckpointAttestation> {
+    protected epochCache: EpochCacheInterface;
+    protected logger: Logger;
     constructor(epochCache: EpochCacheInterface);
-    validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined>;
+    validate(message: CheckpointAttestation): Promise<PeerErrorSeverity | undefined>;
 }
-//# sourceMappingURL=attestation_validator.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0ZXN0YXRpb25fdmFsaWRhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbXNnX3ZhbGlkYXRvcnMvYXR0ZXN0YXRpb25fdmFsaWRhdG9yL2F0dGVzdGF0aW9uX3ZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRTlELE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUNsRSxPQUFPLEVBQUUsS0FBSyxxQkFBcUIsRUFBRSxLQUFLLFlBQVksRUFBRSxpQkFBaUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRXJHLHFCQUFhLDhCQUErQixZQUFXLFlBQVksQ0FBQyxxQkFBcUIsQ0FBQztJQUN4RixTQUFTLENBQUMsVUFBVSxFQUFFLG1CQUFtQixDQUFDO0lBQzFDLFNBQVMsQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDO0lBRXpCLFlBQVksVUFBVSxFQUFFLG1CQUFtQixFQUcxQztJQUVLLFFBQVEsQ0FBQyxPQUFPLEVBQUUscUJBQXFCLEdBQUcsT0FBTyxDQUFDLGlCQUFpQixHQUFHLFNBQVMsQ0FBQyxDQXdEckY7Q0FDRiJ9

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

@@ -1 +1 @@
-{"version":3,"file":"attestation_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/attestation_validator/attestation_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEhG,qBAAa,oBAAqB,YAAW,YAAY,CAAC,gBAAgB,CAAC;IACzE,OAAO,CAAC,UAAU,CAAsB;gBAE5B,UAAU,EAAE,mBAAmB;IAIrC,QAAQ,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;CAelF"}
+{"version":3,"file":"attestation_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/attestation_validator/attestation_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAErG,qBAAa,8BAA+B,YAAW,YAAY,CAAC,qBAAqB,CAAC;IACxF,SAAS,CAAC,UAAU,EAAE,mBAAmB,CAAC;IAC1C,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IAEzB,YAAY,UAAU,EAAE,mBAAmB,EAG1C;IAEK,QAAQ,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAwDrF;CACF"}