@aztec/p2p 0.0.1-commit.f504929 → 0.0.1-commit.f5d02921e

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

@@ -1,106 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-import type { TxHash } from '@aztec/stdlib/tx';
-
-import type { TxPoolOptions } from '../tx_pool.js';
-import {
-  type EvictionContext,
-  EvictionEvent,
-  type EvictionResult,
-  type EvictionRule,
-  type TxPoolOperations,
-} from './eviction_strategy.js';
-
-export interface LowPriorityEvictionConfig {
-  /** Maximum number of pending transactions before eviction kicks in */
-  maxPoolSize: number;
-}
-
-/**
- * Eviction rule that removes low-priority transactions when the number of pending transactions exceeds configured limits.
- * Only triggers on TXS_ADDED events and respects non-evictable transactions.
- */
-export class LowPriorityEvictionRule implements EvictionRule {
-  public readonly name = 'LowPriorityEviction';
-
-  private log = createLogger('p2p:mempool:tx_pool:low_priority_eviction_rule');
-
-  constructor(private config: LowPriorityEvictionConfig) {}
-
-  public async evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult> {
-    if (context.event !== EvictionEvent.TXS_ADDED) {
-      return {
-        reason: 'low_priority',
-        success: true,
-        txsEvicted: [],
-      };
-    }
-
-    if (this.config.maxPoolSize === 0) {
-      return {
-        reason: 'low_priority',
-        success: true,
-        txsEvicted: [],
-      };
-    }
-
-    try {
-      const currentTxCount = await txPool.getPendingTxCount();
-      const maxCount = this.config.maxPoolSize;
-
-      if (currentTxCount <= maxCount) {
-        this.log.trace(`Not evicting low priority txs. Pending tx count below limit ${currentTxCount} <= ${maxCount}`);
-        return {
-          reason: 'low_priority',
-          success: true,
-          txsEvicted: [],
-        };
-      }
-
-      this.log.verbose(`Evicting low priority txs. Pending tx count above limit: ${currentTxCount} > ${maxCount}`);
-      const numberToEvict = currentTxCount - maxCount;
-      const txsToEvict: TxHash[] = await txPool.getLowestPriorityEvictable(numberToEvict);
-
-      if (txsToEvict.length > 0) {
-        await txPool.deleteTxs(txsToEvict);
-      }
-
-      const numNewTxsEvicted = context.newTxs.filter(newTxHash =>
-        txsToEvict.some(evictedTx => evictedTx.equals(newTxHash)),
-      ).length;
-
-      this.log.verbose(`Evicted ${txsToEvict.length} low priority txs, including ${numNewTxsEvicted} newly added txs`, {
-        txsEvicted: txsToEvict,
-      });
-
-      return {
-        reason: 'low_priority',
-        success: true,
-        txsEvicted: txsToEvict,
-      };
-    } catch (err) {
-      this.log.error('Failed to evict low priority transactions', { err });
-      return {
-        reason: 'low_priority',
-        success: false,
-        txsEvicted: [],
-        error: new Error('Failed to evict low priority txs', { cause: err }),
-      };
-    }
-  }
-
-  /**
-   * Updates the configuration for this eviction rule
-   */
-  updateConfig(config: TxPoolOptions): void {
-    if (config.maxPendingTxCount !== undefined) {
-      this.config.maxPoolSize = config.maxPendingTxCount;
-    }
-  }
-
-  /**
-   * Gets the current configuration
-   */
-  getConfig(): LowPriorityEvictionConfig {
-    return { ...this.config };
-  }
-}

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

@@ -1,75 +0,0 @@
-import { findIndexInSortedArray, insertIntoSortedArray } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { createLogger } from '@aztec/foundation/log';
-import { type Tx, TxHash } from '@aztec/stdlib/tx';
-
-import type { PreAddEvictionResult, PreAddEvictionRule, PreAddPoolAccess } from './eviction_strategy.js';
-
-const cmpTxHash = (a: TxHash, b: TxHash) => Fr.cmp(a.hash, b.hash);
-
-/**
- * Pre-add eviction rule that checks for nullifier conflicts between incoming and existing transactions.
- *
- * When an incoming tx shares nullifiers with existing pending txs:
- * - If the incoming tx has strictly higher priority fee, evict all conflicting txs
- * - If any conflicting tx has equal or higher priority fee, reject the incoming tx
- *
- * This prevents nullifier spam attacks where an attacker floods the mempool with
- * transactions spending the same nullifiers.
- */
-export class NullifierConflictPreAddRule implements PreAddEvictionRule {
-  public readonly name = 'NullifierConflictPreAdd';
-
-  private log = createLogger('p2p:mempool:tx_pool:nullifier_conflict_pre_add_rule');
-
-  /**
-   * Check if the incoming transaction conflicts with existing transactions via nullifiers.
-   *
-   * @param tx - The incoming transaction
-   * @param poolAccess - Read-only access to pool state
-   * @returns Result with rejection status and txs to evict
-   */
-  async check(tx: Tx, poolAccess: PreAddPoolAccess): Promise<PreAddEvictionResult> {
-    const txHash = tx.getTxHash();
-    const nullifiers = tx.data.getNonEmptyNullifiers();
-    const txHashesToEvict: TxHash[] = [];
-    const incomingPriority = poolAccess.getTxPriority(tx);
-
-    for (const nullifier of nullifiers) {
-      const conflictingHash = await poolAccess.getTxHashByNullifier(nullifier);
-
-      if (
-        !conflictingHash ||
-        conflictingHash.equals(txHash) ||
-        findIndexInSortedArray(txHashesToEvict, conflictingHash, cmpTxHash) !== -1
-      ) {
-        continue;
-      }
-
-      // Get the conflicting tx's priority
-      const conflictingTx = await poolAccess.getPendingTxByHash(conflictingHash);
-      if (!conflictingTx) {
-        continue;
-      }
-
-      const conflictingPriority = poolAccess.getTxPriority(conflictingTx);
-
-      // If incoming tx has strictly higher priority, mark for eviction
-      // Otherwise, reject incoming tx (ties go to existing tx)
-      if (incomingPriority > conflictingPriority) {
-        insertIntoSortedArray(txHashesToEvict, conflictingHash, cmpTxHash);
-      } else {
-        this.log.debug(
-          `Rejecting tx ${txHash.toString()}: nullifier conflict with ${conflictingHash.toString()} which has higher or equal fee`,
-        );
-        return {
-          shouldReject: true,
-          txHashesToEvict: [],
-          reason: `nullifier conflict with ${conflictingHash.toString()}`,
-        };
-      }
-    }
-
-    return { shouldReject: false, txHashesToEvict };
-  }
-}

package/src/mem_pools/tx_pool/index.ts

@@ -1,2 +0,0 @@
-export * from './tx_pool.js';
-export * from './aztec_kv_tx_pool.js';

package/src/mem_pools/tx_pool/priority.ts

@@ -1,20 +0,0 @@
-import { Buffer32 } from '@aztec/foundation/buffer';
-import type { Tx } from '@aztec/stdlib/tx';
-
-/**
- * Returns a string representing the priority of a tx.
- * 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: Tx): string {
-  return Buffer32.fromBigInt(getTxPriorityFee(tx)).toString();
-}
-
-/**
- * Returns the priority of a tx.
- */
-export function getTxPriorityFee(tx: Tx): bigint {
-  const priorityFees = tx.getGasSettings().maxPriorityFeesPerGas;
-  const totalFees = priorityFees.feePerDaGas + priorityFees.feePerL2Gas;
-  return totalFees;
-}

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -1,141 +0,0 @@
-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 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[], 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.
-   * @returns The transaction, if found, 'undefined' otherwise.
-   */
-  getArchivedTxByHash(txHash: TxHash): Promise<Tx | undefined>;
-
-  /**
-   * 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[], 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[], 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[], opts?: { permanently?: boolean }): Promise<void>;
-
-  /**
-   * Gets all transactions currently in the tx pool.
-   * @returns An array of transaction objects found in the tx pool.
-   */
-  getAllTxs(): Promise<Tx[]>;
-
-  /**
-   * Gets the hashes of all transactions currently in the tx pool.
-   * @returns An array of transaction hashes found in the tx pool.
-   */
-  getAllTxHashes(): Promise<TxHash[]>;
-
-  /**
-   * Gets the hashes of pending transactions currently in the tx pool sorted by priority (see getPendingTxPriority).
-   * @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: BlockNumber][]>;
-
-  /**
-   * Returns whether the given tx hash is flagged as pending, mined, or deleted.
-   * @param txHash - Hash of the tx to query.
-   * @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.
-   */
-  cleanupDeletedMinedTxs(blockNumber: BlockNumber): Promise<number>;
-}

package/src/mem_pools/tx_pool/tx_pool_test_suite.ts

@@ -1,319 +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, type Tx } from '@aztec/stdlib/tx';
-
-import type { TxPool } from './tx_pool.js';
-
-/**
- * Tests a TxPool implementation.
- * @param getTxPool - Gets a fresh TxPool
- */
-export function describeTxPool(getTxPool: () => TxPool) {
-  let pool: TxPool;
-
-  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: Tx[] | undefined = 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: Tx, fee: number) => {
-      unfreeze(tx.data.constants.txContext.gasSettings).maxPriorityFeesPerGas = new GasFees(fee, fee);
-      return tx;
-    };
-
-    const tx1 = withPriorityFee(await mockTx(0), 1000);
-    const tx2 = withPriorityFee(await mockTx(1), 100);
-    const tx3 = withPriorityFee(await mockTx(2), 200);
-    const tx4 = withPriorityFee(await mockTx(3), 3000);
-
-    await pool.addTxs([tx1, tx2, tx3, tx4]);
-
-    const poolTxHashes = await pool.getPendingTxHashes();
-    expect(poolTxHashes).toHaveLength(4);
-    expect(poolTxHashes).toEqual([tx4, tx1, tx3, tx2].map(tx => tx.getTxHash()));
-  });
-
-  describe('soft-delete', () => {
-    it('soft-deletes mined txs and keeps them in storage', async () => {
-      const txs = await Promise.all([mockTx(1), mockTx(2), mockTx(3)]);
-      await pool.addTxs(txs);
-
-      // Mark first tx as mined
-      await pool.markAsMined([txs[0].getTxHash()], minedBlockHeader);
-
-      // Verify initial state
-      await expect(pool.getPendingTxCount()).resolves.toBe(2);
-      await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
-      await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeDefined();
-
-      // Delete mined tx - should be soft-deleted
-      await pool.deleteTxs([txs[0].getTxHash()]);
-
-      // Delete pending tx - should be permanently deleted
-      await pool.deleteTxs([txs[1].getTxHash()]);
-
-      // Verify mined tx still exists in storage but has 'deleted' status
-      await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
-      await expect(pool.getTxStatus(txs[0].getTxHash())).resolves.toEqual('deleted');
-
-      // Verify pending tx is permanently deleted
-      await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeUndefined();
-      await expect(pool.getTxStatus(txs[1].getTxHash())).resolves.toBeUndefined();
-
-      // Verify remaining pending count
-      await expect(pool.getPendingTxCount()).resolves.toBe(1);
-
-      // Verify pending hashes don't include deleted txs
-      const pendingHashes = await pool.getPendingTxHashes();
-      expect(pendingHashes).toHaveLength(1);
-      expect(pendingHashes.map(h => h.toString())).toContain(txs[2].getTxHash().toString());
-    });
-
-    it('cleans up old deleted mined transactions', async () => {
-      const txs = await Promise.all([mockTx(1), mockTx(2), mockTx(3)]);
-      await pool.addTxs(txs);
-
-      // Mark first two as mined in block 1
-      await pool.markAsMined([txs[0].getTxHash(), txs[1].getTxHash()], minedBlockHeader);
-
-      // Soft-delete mined transactions
-      await pool.deleteTxs([txs[0].getTxHash(), txs[1].getTxHash()]);
-
-      // Clean up deleted mined txs from block 1 and earlier
-      const deletedCount = await pool.cleanupDeletedMinedTxs(BlockNumber(1));
-
-      // Verify old transactions are permanently deleted
-      expect(deletedCount).toBe(2);
-      await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeUndefined();
-      await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeUndefined();
-      await expect(pool.getTxByHash(txs[2].getTxHash())).resolves.toBeDefined();
-    });
-
-    it('does not clean up recent deleted mined transactions', async () => {
-      const txs = await Promise.all([mockTx(1), mockTx(2)]);
-      await pool.addTxs(txs);
-
-      // Mark as mined in block 2
-      const laterBlockHeader = BlockHeader.empty({
-        globalVariables: GlobalVariables.empty({ blockNumber: BlockNumber(2), timestamp: 0n }),
-      });
-      await pool.markAsMined([txs[0].getTxHash()], laterBlockHeader);
-
-      // Soft-delete a mined transaction
-      await pool.deleteTxs([txs[0].getTxHash()]);
-
-      // Try to clean up with block 1 (before the mined block)
-      const deletedCount = await pool.cleanupDeletedMinedTxs(BlockNumber(1));
-
-      // Verify no transactions were cleaned up
-      expect(deletedCount).toBe(0);
-      await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
-    });
-
-    it('restores deleted mined tx when it is mined again', async () => {
-      const tx = await mockTx(1);
-      await pool.addTxs([tx]);
-
-      // Mark as mined
-      await pool.markAsMined([tx.getTxHash()], minedBlockHeader);
-
-      // Soft-delete it
-      await pool.deleteTxs([tx.getTxHash()]);
-      await expect(pool.getTxStatus(tx.getTxHash())).resolves.toEqual('deleted');
-
-      // Mark as mined again (e.g., after a reorg)
-      await pool.markAsMined([tx.getTxHash()], minedBlockHeader);
-
-      // Should be back to mined status
-      await expect(pool.getTxStatus(tx.getTxHash())).resolves.toEqual('mined');
-      await expect(pool.getTxByHash(tx.getTxHash())).resolves.toBeDefined();
-    });
-  });
-}