@aztec/p2p 0.0.1-commit.87a0206 → 0.0.1-commit.8f9871590

package/src/mem_pools/attestation_pool/attestation_pool_test_suite.ts

@@ -10,7 +10,11 @@ import {
   makeCheckpointProposal,
 } from '@aztec/stdlib/testing';
 
-import { type AttestationPool, MAX_PROPOSALS_PER_POSITION, MAX_PROPOSALS_PER_SLOT } from './attestation_pool.js';
+import {
+  type AttestationPool,
+  MAX_BLOCK_PROPOSALS_PER_POSITION,
+  MAX_CHECKPOINT_PROPOSALS_PER_SLOT,
+} from './attestation_pool.js';
 import { mockCheckpointAttestation } from './mocks.js';
 
 const NUMBER_OF_SIGNERS_PER_TEST = 4;
@@ -191,7 +195,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
       expect(result.added).toBe(true);
       expect(result.alreadyExists).toBe(false);
-      expect(result.totalForPosition).toBe(1);
+      expect(result.count).toBe(1);
 
       const retrievedProposal = await ap.getBlockProposal(proposalId);
 
@@ -258,7 +262,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
       expect(result.added).toBe(true);
       expect(result.alreadyExists).toBe(false);
-      expect(result.totalForPosition).toBe(1);
+      expect(result.count).toBe(1);
 
       const retrievedProposal = await ap.getCheckpointProposal(proposalId);
 
@@ -324,12 +328,12 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     it('should return added=false when exceeding capacity', async () => {
       const slotNumber = 420;
 
-      // Add MAX_PROPOSALS_PER_SLOT proposals
-      for (let i = 0; i < MAX_PROPOSALS_PER_SLOT; i++) {
+      // Add MAX_CHECKPOINT_PROPOSALS_PER_SLOT proposals
+      for (let i = 0; i < MAX_CHECKPOINT_PROPOSALS_PER_SLOT; i++) {
         const proposal = await mockCheckpointProposalForPool(signers[i % NUMBER_OF_SIGNERS_PER_TEST], slotNumber);
         const result = await ap.tryAddCheckpointProposal(proposal);
         expect(result.added).toBe(true);
-        expect(result.totalForPosition).toBe(i + 1);
+        expect(result.count).toBe(i + 1);
       }
 
       // The next proposal should not be added
@@ -337,7 +341,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       const result = await ap.tryAddCheckpointProposal(extraProposal);
       expect(result.added).toBe(false);
       expect(result.alreadyExists).toBe(false);
-      expect(result.totalForPosition).toBe(MAX_PROPOSALS_PER_SLOT);
+      expect(result.count).toBe(MAX_CHECKPOINT_PROPOSALS_PER_SLOT);
     });
   });
 
@@ -358,13 +362,13 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     };
 
     describe('tryAddBlockProposal duplicate detection', () => {
-      it('should return totalForPosition=1 when pool is empty', async () => {
+      it('should return count=1 when pool is empty', async () => {
         const proposal = await mockBlockProposalWithIndex(signers[0], 100, 0);
         const result = await ap.tryAddBlockProposal(proposal);
 
         expect(result.added).toBe(true);
         expect(result.alreadyExists).toBe(false);
-        expect(result.totalForPosition).toBe(1);
+        expect(result.count).toBe(1);
       });
 
       it('should return alreadyExists when same proposal exists', async () => {
@@ -375,17 +379,17 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
         expect(result.added).toBe(false);
         expect(result.alreadyExists).toBe(true);
-        expect(result.totalForPosition).toBe(1);
+        expect(result.count).toBe(1);
       });
 
-      it('should detect duplicate via totalForPosition when different proposal exists at same position', async () => {
+      it('should detect duplicate via count when different proposal exists at same position', async () => {
         const slotNumber = 100;
         const indexWithinCheckpoint = 2;
 
         // Add first proposal
         const proposal1 = await mockBlockProposalWithIndex(signers[0], slotNumber, indexWithinCheckpoint);
         const result1 = await ap.tryAddBlockProposal(proposal1);
-        expect(result1.totalForPosition).toBe(1);
+        expect(result1.count).toBe(1);
 
         // Add a different proposal at same position - this is a duplicate (equivocation)
         const proposal2 = await mockBlockProposalWithIndex(signers[1], slotNumber, indexWithinCheckpoint);
@@ -393,8 +397,8 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
         expect(result2.added).toBe(true);
         expect(result2.alreadyExists).toBe(false);
-        // totalForPosition >= 2 indicates duplicate detection
-        expect(result2.totalForPosition).toBe(2);
+        // count >= 2 indicates duplicate detection
+        expect(result2.count).toBe(2);
       });
 
       it('should not detect duplicate for different positions in same slot', async () => {
@@ -409,8 +413,8 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         const result = await ap.tryAddBlockProposal(proposal2);
 
         expect(result.added).toBe(true);
-        // totalForPosition = 1 means no duplicate for this position
-        expect(result.totalForPosition).toBe(1);
+        // count = 1 means no duplicate for this position
+        expect(result.count).toBe(1);
       });
 
       it('should not detect duplicate for same position in different slots', async () => {
@@ -425,37 +429,37 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         const result = await ap.tryAddBlockProposal(proposal2);
 
         expect(result.added).toBe(true);
-        // totalForPosition = 1 means no duplicate for this position
-        expect(result.totalForPosition).toBe(1);
+        // count = 1 means no duplicate for this position
+        expect(result.count).toBe(1);
       });
 
-      it('should track multiple duplicates correctly via totalForPosition', async () => {
+      it('should track multiple duplicates correctly via count', async () => {
         const slotNumber = 100;
         const indexWithinCheckpoint = 0;
 
         // Add multiple proposals for same position
         const proposal1 = await mockBlockProposalWithIndex(signers[0], slotNumber, indexWithinCheckpoint);
         const result1 = await ap.tryAddBlockProposal(proposal1);
-        expect(result1.totalForPosition).toBe(1);
+        expect(result1.count).toBe(1);
 
         const proposal2 = await mockBlockProposalWithIndex(signers[1], slotNumber, indexWithinCheckpoint);
         const result2 = await ap.tryAddBlockProposal(proposal2);
-        expect(result2.totalForPosition).toBe(2);
+        expect(result2.count).toBe(2);
 
         // Add a third proposal for same position
         const proposal3 = await mockBlockProposalWithIndex(signers[2], slotNumber, indexWithinCheckpoint);
         const result3 = await ap.tryAddBlockProposal(proposal3);
 
         expect(result3.added).toBe(true);
-        expect(result3.totalForPosition).toBe(3);
+        expect(result3.count).toBe(3);
       });
 
       it('should return added=false when exceeding capacity', async () => {
         const slotNumber = 100;
         const indexWithinCheckpoint = 0;
 
-        // Add MAX_PROPOSALS_PER_POSITION proposals
-        for (let i = 0; i < MAX_PROPOSALS_PER_POSITION; i++) {
+        // Add MAX_BLOCK_PROPOSALS_PER_POSITION proposals
+        for (let i = 0; i < MAX_BLOCK_PROPOSALS_PER_POSITION; i++) {
           const proposal = await mockBlockProposalWithIndex(
             signers[i % NUMBER_OF_SIGNERS_PER_TEST],
             slotNumber,
@@ -463,7 +467,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
           );
           const result = await ap.tryAddBlockProposal(proposal);
           expect(result.added).toBe(true);
-          expect(result.totalForPosition).toBe(i + 1);
+          expect(result.count).toBe(i + 1);
         }
 
         // The next proposal should not be added
@@ -471,7 +475,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         const result = await ap.tryAddBlockProposal(extraProposal);
         expect(result.added).toBe(false);
         expect(result.alreadyExists).toBe(false);
-        expect(result.totalForPosition).toBe(MAX_PROPOSALS_PER_POSITION);
+        expect(result.count).toBe(MAX_BLOCK_PROPOSALS_PER_POSITION);
       });
 
       it('should clean up block position index when deleting old data', async () => {
@@ -482,18 +486,18 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         const proposal1 = await mockBlockProposalWithIndex(signers[0], slotNumber, indexWithinCheckpoint);
         await ap.tryAddBlockProposal(proposal1);
 
-        // Verify it's tracked (adding another should show totalForPosition = 2)
+        // Verify it's tracked (adding another should show count = 2)
         const proposal2 = await mockBlockProposalWithIndex(signers[1], slotNumber, indexWithinCheckpoint);
         let result = await ap.tryAddBlockProposal(proposal2);
-        expect(result.totalForPosition).toBe(2);
+        expect(result.count).toBe(2);
 
         // Delete old data
         await ap.deleteOlderThan(SlotNumber(slotNumber + 1));
 
-        // Verify position index is cleaned up (totalForPosition should be 1 now)
+        // Verify position index is cleaned up (count should be 1 now)
         const proposal3 = await mockBlockProposalWithIndex(signers[2], slotNumber, indexWithinCheckpoint);
         result = await ap.tryAddBlockProposal(proposal3);
-        expect(result.totalForPosition).toBe(1);
+        expect(result.count).toBe(1);
       });
 
       it('should correctly delete block proposals at slot boundary', async () => {
@@ -514,16 +518,16 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         // Slot 99 proposals should have their index cleaned up
         const newProposal99 = await mockBlockProposalWithIndex(signers[0], 99, 0);
         const result99 = await ap.tryAddBlockProposal(newProposal99);
-        expect(result99.totalForPosition).toBe(1); // Index was cleaned up
+        expect(result99.count).toBe(1); // Index was cleaned up
 
         // Slot 100 and 101 should still be tracked
         const newProposal100 = await mockBlockProposalWithIndex(signers[1], 100, 0);
         const result100 = await ap.tryAddBlockProposal(newProposal100);
-        expect(result100.totalForPosition).toBe(2); // Still has the original
+        expect(result100.count).toBe(2); // Still has the original
 
         const newProposal101 = await mockBlockProposalWithIndex(signers[2], 101, 0);
         const result101 = await ap.tryAddBlockProposal(newProposal101);
-        expect(result101.totalForPosition).toBe(2); // Still has the original
+        expect(result101.count).toBe(2); // Still has the original
       });
 
       it('should delete all indices for a given slot', async () => {
@@ -544,15 +548,15 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         // All indices should be cleaned up
         const newProposal0 = await mockBlockProposalWithIndex(signers[0], slotNumber, 0);
         const result0 = await ap.tryAddBlockProposal(newProposal0);
-        expect(result0.totalForPosition).toBe(1);
+        expect(result0.count).toBe(1);
 
         const newProposal1 = await mockBlockProposalWithIndex(signers[1], slotNumber, 1);
         const result1 = await ap.tryAddBlockProposal(newProposal1);
-        expect(result1.totalForPosition).toBe(1);
+        expect(result1.count).toBe(1);
 
         const newProposal2 = await mockBlockProposalWithIndex(signers[2], slotNumber, 2);
         const result2 = await ap.tryAddBlockProposal(newProposal2);
-        expect(result2.totalForPosition).toBe(1);
+        expect(result2.count).toBe(1);
       });
 
       it('should delete block proposals from storage when deleting old data', async () => {
@@ -598,13 +602,13 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         return proposal.toCore();
       };
 
-      it('should return totalForPosition=1 when pool is empty', async () => {
+      it('should return count=1 when pool is empty', async () => {
         const proposal = await mockCheckpointProposalCoreForPool(signers[0], 100);
         const result = await ap.tryAddCheckpointProposal(proposal);
 
         expect(result.added).toBe(true);
         expect(result.alreadyExists).toBe(false);
-        expect(result.totalForPosition).toBe(1);
+        expect(result.count).toBe(1);
       });
 
       it('should return alreadyExists when same proposal exists', async () => {
@@ -615,16 +619,16 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
         expect(result.added).toBe(false);
         expect(result.alreadyExists).toBe(true);
-        expect(result.totalForPosition).toBe(1);
+        expect(result.count).toBe(1);
       });
 
-      it('should detect duplicate via totalForPosition when different proposal exists for same slot', async () => {
+      it('should detect duplicate via count when different proposal exists for same slot', async () => {
         const slotNumber = 100;
 
         // Add first proposal
         const proposal1 = await mockCheckpointProposalCoreForPool(signers[0], slotNumber);
         const result1 = await ap.tryAddCheckpointProposal(proposal1);
-        expect(result1.totalForPosition).toBe(1);
+        expect(result1.count).toBe(1);
 
         // Add a different proposal for same slot - this is a duplicate (equivocation)
         const proposal2 = await mockCheckpointProposalCoreForPool(signers[1], slotNumber);
@@ -632,8 +636,8 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
         expect(result2.added).toBe(true);
         expect(result2.alreadyExists).toBe(false);
-        // totalForPosition >= 2 indicates duplicate detection
-        expect(result2.totalForPosition).toBe(2);
+        // count >= 2 indicates duplicate detection
+        expect(result2.count).toBe(2);
       });
 
       it('should not detect duplicate for different slots', async () => {
@@ -646,28 +650,28 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         const result = await ap.tryAddCheckpointProposal(proposal2);
 
         expect(result.added).toBe(true);
-        // totalForPosition = 1 means no duplicate for this slot
-        expect(result.totalForPosition).toBe(1);
+        // count = 1 means no duplicate for this slot
+        expect(result.count).toBe(1);
       });
 
-      it('should track multiple duplicates correctly via totalForPosition', async () => {
+      it('should track multiple duplicates correctly via count', async () => {
         const slotNumber = 100;
 
         // Add multiple proposals for same slot
         const proposal1 = await mockCheckpointProposalCoreForPool(signers[0], slotNumber);
         const result1 = await ap.tryAddCheckpointProposal(proposal1);
-        expect(result1.totalForPosition).toBe(1);
+        expect(result1.count).toBe(1);
 
         const proposal2 = await mockCheckpointProposalCoreForPool(signers[1], slotNumber);
         const result2 = await ap.tryAddCheckpointProposal(proposal2);
-        expect(result2.totalForPosition).toBe(2);
+        expect(result2.count).toBe(2);
 
         // Add a third proposal for same slot
         const proposal3 = await mockCheckpointProposalCoreForPool(signers[2], slotNumber);
         const result3 = await ap.tryAddCheckpointProposal(proposal3);
 
         expect(result3.added).toBe(true);
-        expect(result3.totalForPosition).toBe(3);
+        expect(result3.count).toBe(3);
       });
 
       it('should not count attestations as proposals for duplicate detection', async () => {
@@ -684,8 +688,8 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
         expect(result.added).toBe(true);
         expect(result.alreadyExists).toBe(false);
-        // totalForPosition should be 1, NOT 2 - attestations should not count as proposals
-        expect(result.totalForPosition).toBe(1);
+        // count should be 1, NOT 2 - attestations should not count as proposals
+        expect(result.count).toBe(1);
       });
 
       it('should not count attestations for different proposals as duplicates', async () => {
@@ -703,14 +707,14 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
         const result1 = await ap.tryAddCheckpointProposal(proposal1);
 
         expect(result1.added).toBe(true);
-        expect(result1.totalForPosition).toBe(1);
+        expect(result1.count).toBe(1);
 
         // Add the second checkpoint proposal - this IS a duplicate (different archive, same slot)
         const proposal2 = await mockCheckpointProposalCoreForPool(signers[3], slotNumber, archive2);
         const result2 = await ap.tryAddCheckpointProposal(proposal2);
 
         expect(result2.added).toBe(true);
-        expect(result2.totalForPosition).toBe(2);
+        expect(result2.count).toBe(2);
       });
     });
   });

package/src/mem_pools/attestation_pool/index.ts

@@ -3,7 +3,7 @@ export {
   type AttestationPoolApi,
   type TryAddResult,
   createTestAttestationPool,
-  MAX_PROPOSALS_PER_SLOT,
-  MAX_PROPOSALS_PER_POSITION,
-  ATTESTATION_CAP_BUFFER,
+  MAX_CHECKPOINT_PROPOSALS_PER_SLOT,
+  MAX_BLOCK_PROPOSALS_PER_POSITION,
+  MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER,
 } from './attestation_pool.js';

package/src/mem_pools/attestation_pool/mocks.ts

@@ -34,9 +34,10 @@ export const mockCheckpointAttestation = (
   slot: number = 0,
   archive: Fr = Fr.random(),
   header?: CheckpointHeader,
+  feeAssetPriceModifier: bigint = 0n,
 ): CheckpointAttestation => {
   header = header ?? CheckpointHeader.random({ slotNumber: SlotNumber(slot) });
-  const payload = new ConsensusPayload(header, archive);
+  const payload = new ConsensusPayload(header, archive, feeAssetPriceModifier);
 
   const attestationHash = getHashedSignaturePayloadEthSignedMessage(
     payload,

package/src/mem_pools/index.ts

@@ -1,3 +1,6 @@
 export { AttestationPool, type AttestationPoolApi } from './attestation_pool/attestation_pool.js';
 export { type MemPools } from './interface.js';
+// Old TxPool exports - kept temporarily for external consumers
 export { type TxPool } from './tx_pool/tx_pool.js';
+// New TxPoolV2 exports
+export { type TxPoolV2, type TxPoolV2Config, type TxPoolV2Events, type AddTxsResult } from './tx_pool_v2/index.js';

package/src/mem_pools/interface.ts

@@ -1,10 +1,10 @@
 import type { AttestationPoolApi } from './attestation_pool/attestation_pool.js';
-import type { TxPool } from './tx_pool/tx_pool.js';
+import type { TxPoolV2 } from './tx_pool_v2/interfaces.js';
 
 /**
  * A interface the combines all mempools
  */
 export type MemPools = {
-  txPool: TxPool;
+  txPool: TxPoolV2;
   attestationPool: AttestationPoolApi;
 };

package/src/mem_pools/tx_pool/README.md

@@ -213,7 +213,7 @@ The [`EvictionManager`](eviction/eviction_manager.ts) coordinates eviction by:
 Evicts transactions that become invalid after a block is mined:
 
 - Duplicate nullifiers: Txs with nullifiers already included in the mined block
-- Expired transactions: Txs with `includeByTimestamp` ≤ mined block timestamp
+- Expired transactions: Txs with `expirationTimestamp` ≤ mined block timestamp
 
 #### 2. `InvalidTxsAfterReorgRule`
 

package/src/mem_pools/tx_pool/eviction/invalid_txs_after_mining_rule.ts

@@ -68,10 +68,10 @@ export class InvalidTxsAfterMiningRule implements EvictionRule {
         }
 
         // Evict pending txs with an expiration timestamp less than or equal to the mined block timestamp
-        const includeByTimestamp = tx.data.includeByTimestamp;
-        if (includeByTimestamp <= timestamp) {
+        const expirationTimestamp = tx.data.expirationTimestamp;
+        if (expirationTimestamp <= timestamp) {
           this.log.verbose(
-            `Evicting tx ${txHash} from pool due to the tx being expired (includeByTimestamp: ${includeByTimestamp}, mined block timestamp: ${timestamp})`,
+            `Evicting tx ${txHash} from pool due to the tx being expired (expirationTimestamp: ${expirationTimestamp}, mined block timestamp: ${timestamp})`,
           );
           txsToEvict.push(txHash);
           continue;

package/src/mem_pools/tx_pool_v2/README.md

@@ -28,13 +28,22 @@ TxPoolV2 manages transactions through a state machine with clear transitions:
 │              MINED                  │───────────────────┘
 │   (included in a block)             │  handlePrunedBlocks()
 └─────────────────────────────────────┘  (reorg)
-        │
-        │ handleFinalizedBlock()
-        ▼
-┌─────────────────────────────────────┐
-│             DELETED                 │
-│   (optionally archived)             │
-└─────────────────────────────────────┘
+        │                                     │
+        │ handleFinalizedBlock()              │ eviction after reorg
+        │ / eviction / failed exec            │ (validation failure)
+        ▼                                     ▼
+┌─────────────────────────────────────┐  ┌─────────────────────────────────────┐
+│       SLOT-SOFT-DELETED             │  │       PRUNE-SOFT-DELETED            │
+│  (kept in DB until next slot)       │  │  (kept in DB until finalized)       │
+└─────────────────────────────────────┘  └─────────────────────────────────────┘
+        │                                        │
+        │ prepareForSlot()                       │ handleFinalizedBlock()
+        │ (slot advanced)                        │ (mined block finalized)
+        ▼                                        ▼
+┌─────────────────────────────────────┐  ┌─────────────────────────────────────┐
+│          HARD-DELETED               │  │          HARD-DELETED               │
+│   (permanently removed from DB)     │  │   (permanently removed from DB)     │
+└─────────────────────────────────────┘  └─────────────────────────────────────┘
 ```
 
 ## Key Components
@@ -52,6 +61,14 @@ Core implementation containing:
 - Pre-add rule execution
 - Post-event eviction rule execution
 
+### DeletedPool (`deleted_pool.ts`)
+
+Manages all transaction deletions in the pool with two soft-deletion mechanisms:
+- **Slot-based**: Non-pruned txs are kept in DB until the next slot, allowing other nodes to fetch them via reqresp
+- **Prune-based**: Txs from pruned blocks are kept in DB until their original mined block is finalized
+
+All deletions go through `DeletedPool.deleteTx()`, which routes to the appropriate path based on whether the tx is tracked as being from a pruned block.
+
 ### TxMetaData (`tx_metadata.ts`)
 
 Lightweight metadata stored alongside each transaction:
@@ -62,14 +79,60 @@ Lightweight metadata stored alongside each transaction:
 - `claimAmount`: Fee payer's claim from bridging
 - `feeLimit`: Maximum fee the tx can pay
 - `nullifiers`: For conflict detection
-- `includeByTimestamp`: Expiration timestamp
+- `expirationTimestamp`: Expiration timestamp
 - `minedL2BlockId`: Set when mined (undefined otherwise)
 
 State is derived by TxPoolIndices:
 - `mined` if `minedL2BlockId` is set
 - `protected` if in protection map
+- `deleted` if soft-deleted (slot-based or prune-based, evicted but kept in DB)
 - `pending` otherwise
 
+## Soft Deletion
+
+Deleted transactions are kept in the database for a grace period before being permanently removed. There are two soft-deletion mechanisms:
+
+### Slot-Based Soft Deletion
+
+When a transaction is deleted from the pool (eviction, validation failure, failed execution) and is **not** from a pruned block, it is "slot-soft-deleted":
+
+1. **Soft Delete**: The tx is removed from indices but kept in the database, tagged with the current slot number
+2. **Retrieval**: Slot-soft-deleted txs can still be retrieved via `getTxByHash` and return status `'deleted'` from `getTxStatus`
+3. **Hard Delete**: When `prepareForSlot` advances to a new slot, txs deleted in earlier slots are permanently removed
+4. **Re-addition**: If a slot-soft-deleted tx is re-added to the pool, the slot-deleted tracking is cleared
+
+This allows other nodes to still fetch recently-deleted transactions via reqresp during the current slot.
+
+### Prune-Based Soft Deletion
+
+When a chain reorganization occurs, transactions that were mined in pruned blocks are handled with longer retention:
+
+1. **Tracking**: When `handlePrunedBlocks` is called, all un-mined transactions are tracked by their original mined block number
+2. **Soft Delete**: If these transactions are later evicted (failed validation, nullifier conflict, etc.), they are "prune-soft-deleted" - removed from indices but kept in the database
+3. **Retrieval**: Prune-soft-deleted txs can still be retrieved via `getTxByHash` and return status `'deleted'` from `getTxStatus`
+4. **Hard Delete**: When `handleFinalizedBlock` is called and the finalized block number reaches or exceeds the transaction's original mined block, the transaction is permanently removed
+5. **Re-addition**: If a prune-soft-deleted tx is re-added, the `softDeleted` flag is reset to `false` but the prune tracking is preserved, so a subsequent deletion still uses the prune path
+
+Prune-soft-deleted transactions are **not** affected by slot cleanup - they survive across slot boundaries until finalized.
+
+**Prune example:**
+1. Tx mined at block 10
+2. Chain prunes to block 5 (tx becomes un-mined, tracked as minedAtBlock=10)
+3. Tx fails validation and is prune-soft-deleted
+4. Block 9 finalized → tx still in DB (minedAtBlock=10 > finalized=9)
+5. Block 10 finalized → tx hard-deleted (minedAtBlock=10 ≤ finalized=10)
+
+If the tx is re-mined at a higher block before being soft-deleted:
+1. Tx mined at block 10, pruned (tracked as minedAtBlock=10)
+2. Tx re-mined at block 15, pruned again (updated to minedAtBlock=15)
+3. Tx soft-deleted
+4. Block 10 finalized → tx still in DB
+5. Block 15 finalized → tx hard-deleted
+
+### Hydration
+
+On node restart, slot-soft-deleted transactions are immediately hard-deleted (they are stale by definition). Prune-soft-deleted transactions are loaded from the database and tracked normally.
+
 ## Architecture: Pre-add vs Post-event Rules
 
 **Pre-add rules** (run during `addPendingTxs`):
@@ -120,7 +183,7 @@ import { AztecKVTxPoolV2 } from './tx_pool_v2.js';
 const pool = new AztecKVTxPoolV2(txStore, archiveStore, {
   l2BlockSource: archiver,
   worldStateSynchronizer: worldState,
-  pendingTxValidator: validator,
+  createTxValidator: () => validator,
 });
 
 await pool.start();
@@ -195,9 +258,12 @@ The archive uses FIFO eviction when `archivedTxLimit` is reached.
 ## Testing
 
 ```bash
-# Unit tests (131 tests)
+# Unit tests (177 tests)
 yarn test src/mem_pools/tx_pool_v2/tx_pool_v2.test.ts
 
+# Deleted pool tests (17 tests)
+yarn test src/mem_pools/tx_pool_v2/deleted_pool.test.ts
+
 # Compatibility tests (25 tests)
 yarn test src/mem_pools/tx_pool_v2/tx_pool_v2.compat.test.ts