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

package/dest/mem_pools/tx_pool/aztec_kv_tx_pool.js

@@ -1,617 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { toArray } from '@aztec/foundation/iterable';
-import { createLogger } from '@aztec/foundation/log';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { GasFees } from '@aztec/stdlib/gas';
-import { ChonkProof } from '@aztec/stdlib/proofs';
-import { DatabasePublicStateSource } from '@aztec/stdlib/trees';
-import { Tx, TxHash } from '@aztec/stdlib/tx';
-import { getTelemetryClient } from '@aztec/telemetry-client';
-import assert from 'assert';
-import EventEmitter from 'node:events';
-import { ArchiveCache } from '../../msg_validators/tx_validator/archive_cache.js';
-import { GasTxValidator } from '../../msg_validators/tx_validator/gas_validator.js';
-import { PoolInstrumentation, PoolName } from '../instrumentation.js';
-import { getPendingTxPriority } from './priority.js';
-/**
- * KV implementation of the Transaction Pool.
- */ export class AztecKVTxPool extends EventEmitter {
-    #store;
-    /** Our tx pool, stored as a Map, with K: tx hash and V: the transaction. */ #txs;
-    /** The maximum cumulative tx size that the pending txs in the pool take up. */ #maxTxPoolSize = 0;
-    /** The tx evicion logic will kick after pool size is greater than maxTxPoolSize * txPoolOverflowFactor */ txPoolOverflowFactor = 1;
-    /** Index from tx hash to the block number in which they were mined, filtered by mined txs. */ #minedTxHashToBlock;
-    /** Index from tx priority (stored as hex) to its tx hash, filtered by pending txs. */ #pendingTxPriorityToHash;
-    /** Index from tx hash to its tx size (in bytes), filtered by pending txs. */ #pendingTxHashToSize;
-    /** Index from tx hash to its header hash, filtered by pending txs. */ #pendingTxHashToHeaderHash;
-    /** Map from tx hash to the block number it was originally mined in (for soft-deleted txs). */ #deletedMinedTxHashes;
-    /** MultiMap from block number to deleted mined tx hashes for efficient cleanup. */ #blockToDeletedMinedTxHash;
-    /** The cumulative tx size in bytes that the pending txs in the pool take up. */ #pendingTxSize;
-    /** In-memory mapping of pending tx hashes to the hydrated pending tx in the pool. */ #pendingTxs;
-    /** In-memory set of txs that should not be evicted from the pool. */ #nonEvictableTxs;
-    /** KV store for archived txs. */ #archive;
-    /** Archived txs map for future lookup. */ #archivedTxs;
-    /** Indexes of the archived txs by insertion order. */ #archivedTxIndices;
-    /** Number of txs to archive. */ #archivedTxLimit = 0;
-    /** The world state synchronizer used in the node. */ #worldStateSynchronizer;
-    #log;
-    #metrics;
-    /**
-   * Class constructor for KV TxPool. Initiates our transaction pool as an AztecMap.
-   * @param store - A KV store for live txs in the pool.
-   * @param archive - A KV store for archived txs.
-   * @param telemetry - A telemetry client.
-   * @param archivedTxLimit - The number of txs to archive.
-   * @param log - A logger.
-   */ constructor(store, archive, worldStateSynchronizer, telemetry = getTelemetryClient(), config = {}, log = createLogger('p2p:tx_pool')){
-        super();
-        this.#log = log;
-        this.updateConfig(config);
-        this.#txs = store.openMap('txs');
-        this.#minedTxHashToBlock = store.openMap('txHashToBlockMined');
-        this.#pendingTxPriorityToHash = store.openMultiMap('pendingTxFeeToHash');
-        this.#pendingTxHashToSize = store.openMap('pendingTxHashToSize');
-        this.#pendingTxHashToHeaderHash = store.openMap('pendingTxHashToHeaderHash');
-        this.#pendingTxSize = store.openSingleton('pendingTxSize');
-        this.#deletedMinedTxHashes = store.openMap('deletedMinedTxHashes');
-        this.#blockToDeletedMinedTxHash = store.openMultiMap('blockToDeletedMinedTxHash');
-        this.#pendingTxs = new Map();
-        this.#nonEvictableTxs = new Set();
-        this.#archivedTxs = archive.openMap('archivedTxs');
-        this.#archivedTxIndices = archive.openMap('archivedTxIndices');
-        this.#store = store;
-        this.#archive = archive;
-        this.#worldStateSynchronizer = worldStateSynchronizer;
-        this.#metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL, this.countTxs, ()=>store.estimateSize());
-    }
-    countTxs = async ()=>{
-        const [pending = 0, mined = 0] = await Promise.all([
-            this.getPendingTxCount(),
-            this.getMinedTxCount()
-        ]);
-        return Promise.resolve({
-            itemCount: {
-                pending,
-                mined
-            }
-        });
-    };
-    async isEmpty() {
-        for await (const _ of this.#txs.entriesAsync()){
-            return false;
-        }
-        return true;
-    }
-    /**
-   * Marks transactions as mined in a block and updates the pool state accordingly.
-   * Removes the transactions from the pending set and adds them to the mined set.
-   * Also evicts any transactions that become invalid after the block is mined.
-   * @param txHashes - Array of transaction hashes that were mined
-   * @param blockHeader - The header of the block the transactions were mined in
-   */ async markAsMined(txHashes, blockHeader) {
-        if (txHashes.length === 0) {
-            return Promise.resolve();
-        }
-        const minedNullifiers = new Set();
-        const minedFeePayers = new Set();
-        await this.#store.transactionAsync(async ()=>{
-            let pendingTxSize = await this.#pendingTxSize.getAsync() ?? 0;
-            for (const hash of txHashes){
-                const key = hash.toString();
-                // If this tx was previously soft-deleted, remove it from the deleted sets
-                if (await this.#deletedMinedTxHashes.hasAsync(key)) {
-                    const originalBlock = await this.#deletedMinedTxHashes.getAsync(key);
-                    await this.#deletedMinedTxHashes.delete(key);
-                    // Remove from block-to-hash mapping
-                    if (originalBlock !== undefined) {
-                        await this.#blockToDeletedMinedTxHash.deleteValue(originalBlock, key);
-                    }
-                }
-                await this.#minedTxHashToBlock.set(key, blockHeader.globalVariables.blockNumber);
-                const tx = await this.getPendingTxByHash(hash);
-                if (tx) {
-                    const nullifiers = tx.data.getNonEmptyNullifiers();
-                    nullifiers.forEach((nullifier)=>minedNullifiers.add(nullifier.toString()));
-                    minedFeePayers.add(tx.data.feePayer.toString());
-                    pendingTxSize -= tx.getSize();
-                    await this.removePendingTxIndices(tx, key);
-                }
-            }
-            await this.#pendingTxSize.set(pendingTxSize);
-            await this.evictInvalidTxsAfterMining(txHashes, blockHeader, minedNullifiers, minedFeePayers);
-        });
-        // We update this after the transaction above. This ensures that the non-evictable transactions are not evicted
-        // until any that have been mined are marked as such.
-        // The non-evictable set is not considered when evicting transactions that are invalid after a block is mined.
-        this.#nonEvictableTxs.clear();
-    }
-    async markMinedAsPending(txHashes) {
-        if (txHashes.length === 0) {
-            return Promise.resolve();
-        }
-        await this.#store.transactionAsync(async ()=>{
-            let pendingTxSize = await this.#pendingTxSize.getAsync() ?? 0;
-            for (const hash of txHashes){
-                const key = hash.toString();
-                await this.#minedTxHashToBlock.delete(key);
-                // Rehydrate the tx in the in-memory pending txs mapping
-                const tx = await this.getPendingTxByHash(hash);
-                if (tx) {
-                    await this.addPendingTxIndices(tx, key);
-                    pendingTxSize += tx.getSize();
-                }
-            }
-            await this.#pendingTxSize.set(pendingTxSize);
-        });
-        await this.evictInvalidTxsAfterReorg(txHashes);
-        await this.evictLowPriorityTxs(txHashes);
-    }
-    async getPendingTxHashes() {
-        const vals = await toArray(this.#pendingTxPriorityToHash.valuesAsync({
-            reverse: true
-        }));
-        return vals.map(TxHash.fromString);
-    }
-    async getMinedTxHashes() {
-        const vals = await toArray(this.#minedTxHashToBlock.entriesAsync());
-        return vals.map(([txHash, blockNumber])=>[
-                TxHash.fromString(txHash),
-                blockNumber
-            ]);
-    }
-    async getPendingTxCount() {
-        return await this.#pendingTxHashToHeaderHash.sizeAsync() ?? 0;
-    }
-    async getMinedTxCount() {
-        return await this.#minedTxHashToBlock.sizeAsync() ?? 0;
-    }
-    async getTxStatus(txHash) {
-        const key = txHash.toString();
-        const [isMined, isKnown, isDeleted] = await Promise.all([
-            this.#minedTxHashToBlock.hasAsync(key),
-            this.#txs.hasAsync(key),
-            this.#deletedMinedTxHashes.hasAsync(key)
-        ]);
-        if (isDeleted) {
-            return 'deleted';
-        } else if (isMined) {
-            return 'mined';
-        } else if (isKnown) {
-            return 'pending';
-        } else {
-            return undefined;
-        }
-    }
-    /**
-   * Checks if a transaction exists in the pool and returns it.
-   * @param txHash - The generated tx hash.
-   * @returns The transaction, if found, 'undefined' otherwise.
-   */ async getTxByHash(txHash) {
-        const buffer = await this.#txs.getAsync(txHash.toString());
-        return buffer ? Tx.fromBuffer(buffer) : undefined;
-    }
-    async getTxsByHash(txHashes) {
-        const txs = await Promise.all(txHashes.map((txHash)=>this.#txs.getAsync(txHash.toString())));
-        return txs.map((buffer)=>buffer ? Tx.fromBuffer(buffer) : undefined);
-    }
-    async hasTxs(txHashes) {
-        return await Promise.all(txHashes.map((txHash)=>this.#txs.hasAsync(txHash.toString())));
-    }
-    async hasTx(txHash) {
-        const result = await this.hasTxs([
-            txHash
-        ]);
-        return result[0];
-    }
-    /**
-   * Checks if an archived tx exists and returns it.
-   * @param txHash - The tx hash.
-   * @returns The transaction metadata, if found, 'undefined' otherwise.
-   */ async getArchivedTxByHash(txHash) {
-        const buffer = await this.#archivedTxs.getAsync(txHash.toString());
-        return buffer ? Tx.fromBuffer(buffer) : undefined;
-    }
-    /**
-   * Adds a list of transactions to the pool. Duplicates are ignored.
-   * @param txs - An array of txs to be added to the pool.
-   * @returns Empty promise.
-   */ async addTxs(txs, opts = {}) {
-        const addedTxs = [];
-        const hashesAndStats = txs.map((tx)=>({
-                txHash: tx.getTxHash(),
-                txStats: tx.getStats()
-            }));
-        await this.#store.transactionAsync(async ()=>{
-            let pendingTxSize = await this.#pendingTxSize.getAsync() ?? 0;
-            await Promise.all(txs.map(async (tx, i)=>{
-                const { txHash, txStats } = hashesAndStats[i];
-                const key = txHash.toString();
-                if (await this.#txs.hasAsync(key)) {
-                    this.#log.debug(`Tx ${txHash.toString()} already exists in the pool`);
-                    return;
-                }
-                this.#log.verbose(`Adding tx ${txHash.toString()} to pool`, {
-                    eventName: 'tx-added-to-pool',
-                    ...txStats
-                });
-                await this.#txs.set(key, tx.toBuffer());
-                addedTxs.push(tx);
-                if (!await this.#minedTxHashToBlock.hasAsync(key)) {
-                    pendingTxSize += tx.getSize();
-                    await this.addPendingTxIndices(tx, key);
-                    this.#metrics.recordSize(tx);
-                }
-            }));
-            await this.#pendingTxSize.set(pendingTxSize);
-            await this.evictLowPriorityTxs(hashesAndStats.map(({ txHash })=>txHash));
-        });
-        if (addedTxs.length > 0) {
-            this.emit('txs-added', {
-                ...opts,
-                txs: addedTxs
-            });
-        }
-        return addedTxs.length;
-    }
-    /**
-   * Deletes transactions from the pool. Tx hashes that are not present are ignored.
-   * Mined transactions are soft-deleted with a timestamp, pending transactions are permanently deleted.
-   * @param txHashes - An array of tx hashes to be deleted from the tx pool.
-   * @returns Empty promise.
-   */ deleteTxs(txHashes, opts = {}) {
-        if (txHashes.length === 0) {
-            return Promise.resolve();
-        }
-        const deletedTxs = [];
-        const poolDbTx = this.#store.transactionAsync(async ()=>{
-            let pendingTxSize = await this.#pendingTxSize.getAsync() ?? 0;
-            for (const hash of txHashes){
-                const key = hash.toString();
-                const tx = await this.getTxByHash(hash);
-                if (tx) {
-                    const minedBlockNumber = await this.#minedTxHashToBlock.getAsync(key);
-                    if (minedBlockNumber !== undefined) {
-                        await this.#minedTxHashToBlock.delete(key);
-                        if (opts.permanently) {
-                            // Permanently delete mined transactions if specified
-                            this.#log.trace(`Deleting mined tx ${key} from pool`);
-                            await this.#txs.delete(key);
-                        } else {
-                            // Soft-delete mined transactions: remove from mined set but keep in storage
-                            this.#log.trace(`Soft-deleting mined tx ${key} from pool`);
-                            await this.#deletedMinedTxHashes.set(key, minedBlockNumber);
-                            await this.#blockToDeletedMinedTxHash.set(minedBlockNumber, key);
-                        }
-                    } else {
-                        // Permanently delete pending transactions
-                        this.#log.trace(`Deleting pending tx ${key} from pool`);
-                        pendingTxSize -= tx.getSize();
-                        await this.removePendingTxIndices(tx, key);
-                        await this.#txs.delete(key);
-                    }
-                    if (!opts.eviction && this.#archivedTxLimit) {
-                        deletedTxs.push(tx);
-                    }
-                } else {
-                    this.#log.trace(`Skipping deletion of missing tx ${key} from pool`);
-                }
-            }
-            await this.#pendingTxSize.set(pendingTxSize);
-        });
-        this.#log.debug(`Deleted ${txHashes.length} txs from pool`, {
-            txHashes
-        });
-        return this.#archivedTxLimit ? poolDbTx.then(()=>this.archiveTxs(deletedTxs)) : poolDbTx;
-    }
-    /**
-   * Gets all the transactions stored in the pool.
-   * @returns Array of tx objects in the order they were added to the pool.
-   */ async getAllTxs() {
-        const vals = await toArray(this.#txs.valuesAsync());
-        return vals.map((buffer)=>Tx.fromBuffer(buffer));
-    }
-    /**
-   * Gets the hashes of all transactions currently in the tx pool.
-   * @returns An array of transaction hashes found in the tx pool.
-   */ async getAllTxHashes() {
-        const vals = await toArray(this.#txs.keysAsync());
-        return vals.map((x)=>TxHash.fromString(x));
-    }
-    updateConfig({ maxTxPoolSize, txPoolOverflowFactor, archivedTxLimit }) {
-        if (typeof maxTxPoolSize === 'number') {
-            assert(maxTxPoolSize >= 0, 'maxTxPoolSize must be greater or equal to 0');
-            this.#maxTxPoolSize = maxTxPoolSize;
-            if (maxTxPoolSize === 0) {
-                this.#log.info(`Disabling maximum tx mempool size. Tx eviction stopped`);
-            } else {
-                this.#log.info(`Setting maximum tx mempool size`, {
-                    maxTxPoolSize
-                });
-            }
-        }
-        if (typeof txPoolOverflowFactor === 'number') {
-            assert(txPoolOverflowFactor >= 1, 'txPoolOveflowFactor must be greater or equal to 1');
-            this.txPoolOverflowFactor = txPoolOverflowFactor;
-            this.#log.info(`Allowing tx pool size to grow above limit`, {
-                maxTxPoolSize,
-                txPoolOverflowFactor
-            });
-        }
-        if (typeof archivedTxLimit === 'number') {
-            assert(archivedTxLimit >= 0, 'archivedTxLimit must be greater or equal to 0');
-            this.#archivedTxLimit = archivedTxLimit;
-        }
-    // deletedMinedCleanupThresholdMs is no longer used in block-based cleanup
-    }
-    markTxsAsNonEvictable(txHashes) {
-        txHashes.forEach((txHash)=>this.#nonEvictableTxs.add(txHash.toString()));
-        return Promise.resolve();
-    }
-    /**
-   * 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.
-   */ async cleanupDeletedMinedTxs(blockNumber) {
-        let deletedCount = 0;
-        const txHashesToDelete = [];
-        const blocksToDelete = [];
-        await this.#store.transactionAsync(async ()=>{
-            // Iterate through all entries and check block numbers
-            for await (const [block, txHash] of this.#blockToDeletedMinedTxHash.entriesAsync()){
-                if (block <= blockNumber) {
-                    // Permanently delete the transaction
-                    await this.#txs.delete(txHash);
-                    await this.#deletedMinedTxHashes.delete(txHash);
-                    txHashesToDelete.push(txHash);
-                    if (!blocksToDelete.includes(block)) {
-                        blocksToDelete.push(block);
-                    }
-                    deletedCount++;
-                }
-            }
-            // Clean up block-to-hash mapping - delete all values for each block
-            for (const block of blocksToDelete){
-                const txHashesForBlock = await toArray(this.#blockToDeletedMinedTxHash.getValuesAsync(block));
-                for (const txHash of txHashesForBlock){
-                    await this.#blockToDeletedMinedTxHash.deleteValue(block, txHash);
-                }
-            }
-        });
-        if (deletedCount > 0) {
-            this.#log.debug(`Permanently deleted ${deletedCount} deleted mined txs from blocks up to ${blockNumber}`);
-        }
-        return deletedCount;
-    }
-    /**
-   * Creates a GasTxValidator instance.
-   * @param db - DB for the validator to use
-   * @returns A GasTxValidator instance
-   */ createGasTxValidator(db) {
-        return new GasTxValidator(new DatabasePublicStateSource(db), ProtocolContractAddress.FeeJuice, GasFees.empty());
-    }
-    /**
-   * Creates an ArchiveCache instance.
-   * @param db - DB for the cache to use
-   * @returns An ArchiveCache instance
-   */ createArchiveCache(db) {
-        return new ArchiveCache(db);
-    }
-    /**
-   * Checks if a cached transaction exists in the in-memory pending tx pool and returns it.
-   * Otherwise, it checks the tx pool, updates the pending tx pool, and returns the tx.
-   * @param txHash - The generated tx hash.
-   * @returns The transaction, if found, 'undefined' otherwise.
-   */ async getPendingTxByHash(txHash) {
-        let key;
-        if (typeof txHash === 'string') {
-            key = txHash;
-            txHash = TxHash.fromString(txHash);
-        } else {
-            key = txHash.toString();
-        }
-        if (this.#pendingTxs.has(key)) {
-            return this.#pendingTxs.get(key);
-        }
-        const tx = await this.getTxByHash(txHash);
-        if (tx) {
-            this.#pendingTxs.set(key, tx);
-            return tx;
-        }
-        return undefined;
-    }
-    /**
-   * Archives a list of txs for future reference. The number of archived txs is limited by the specified archivedTxLimit.
-   * @param txs - The list of transactions to archive.
-   * @returns Empty promise.
-   */ async archiveTxs(txs) {
-        if (txs.length === 0) {
-            return;
-        }
-        try {
-            const txHashes = await Promise.all(txs.map((tx)=>tx.getTxHash()));
-            await this.#archive.transactionAsync(async ()=>{
-                // calculate the head and tail indices of the archived txs by insertion order.
-                let headIdx = ((await this.#archivedTxIndices.entriesAsync({
-                    limit: 1,
-                    reverse: true
-                }).next()).value?.[0] ?? -1) + 1;
-                let tailIdx = (await this.#archivedTxIndices.entriesAsync({
-                    limit: 1
-                }).next()).value?.[0] ?? 0;
-                for(let i = 0; i < txs.length; i++){
-                    const tx = txs[i];
-                    while(headIdx - tailIdx >= this.#archivedTxLimit){
-                        const txHash = await this.#archivedTxIndices.getAsync(tailIdx);
-                        if (txHash) {
-                            await this.#archivedTxs.delete(txHash);
-                            await this.#archivedTxIndices.delete(tailIdx);
-                        }
-                        tailIdx++;
-                    }
-                    const archivedTx = new Tx(tx.txHash, tx.data, ChonkProof.empty(), tx.contractClassLogFields, tx.publicFunctionCalldata);
-                    const txHash = txHashes[i].toString();
-                    await this.#archivedTxs.set(txHash, archivedTx.toBuffer());
-                    await this.#archivedTxIndices.set(headIdx, txHash);
-                    headIdx++;
-                }
-                this.#log.debug(`Archived ${txs.length} txs`, {
-                    txHashes
-                });
-                this.#log.debug(`Total archived txs: ${headIdx - tailIdx}`);
-            });
-        } catch (error) {
-            this.#log.error(`Error archiving txs`, {
-                error
-            });
-        }
-    }
-    /**
-   * Evicts pending txs with the lowest priority fees from the pool to accomodate the max tx count and cumulative max tx size
-   * after new txs are added.
-   *
-   * @param newTxHashes - The tx hashes of the new txs added to the pool.
-   * @returns The total number of txs evicted from the pool and the number of new txs that were evicted.
-   */ async evictLowPriorityTxs(newTxHashes) {
-        if (this.#maxTxPoolSize === undefined || this.#maxTxPoolSize === 0) {
-            return {
-                numLowPriorityTxsEvicted: 0,
-                numNewTxsEvicted: 0
-            };
-        }
-        let numNewTxsEvicted = 0;
-        const txsToEvict = [];
-        let pendingTxsSize = await this.#pendingTxSize.getAsync() ?? 0;
-        if (pendingTxsSize > this.#maxTxPoolSize * this.txPoolOverflowFactor) {
-            for await (const txHash of this.#pendingTxPriorityToHash.valuesAsync()){
-                if (this.#nonEvictableTxs.has(txHash.toString())) {
-                    continue;
-                }
-                const txSize = await this.#pendingTxHashToSize.getAsync(txHash.toString()) ?? (await this.getPendingTxByHash(txHash))?.getSize();
-                this.#log.verbose(`Evicting tx ${txHash} from pool due to low priority to satisfy max tx size limit`, {
-                    txHash,
-                    txSize
-                });
-                txsToEvict.push(TxHash.fromString(txHash));
-                if (txSize) {
-                    pendingTxsSize -= txSize;
-                    if (pendingTxsSize <= this.#maxTxPoolSize) {
-                        break;
-                    }
-                }
-            }
-            numNewTxsEvicted += newTxHashes.filter((txHash)=>txsToEvict.includes(txHash)).length;
-        }
-        if (txsToEvict.length > 0) {
-            await this.deleteTxs(txsToEvict, {
-                eviction: true
-            });
-        }
-        return {
-            numLowPriorityTxsEvicted: txsToEvict.length,
-            numNewTxsEvicted
-        };
-    }
-    /**
-   * Evicts invalid pending txs from the pool after a txs from a block are mined.
-   * Eviction criteria includes:
-   *   - txs with nullifiers that are already included in the mined block
-   *   - txs with an insufficient fee payer balance
-   *   - txs with an expiration timestamp lower than that of the mined block
-   *
-   * @param minedTxHashes - The tx hashes of the txs mined in the block.
-   * @param blockHeader - The header of the mined block.
-   * @returns The total number of txs evicted from the pool.
-   */ async evictInvalidTxsAfterMining(minedTxHashes, blockHeader, minedNullifiers, minedFeePayers) {
-        if (minedTxHashes.length === 0) {
-            return 0;
-        }
-        const { blockNumber, timestamp } = blockHeader.globalVariables;
-        // Wait for world state to be synced to at least the mined block number
-        await this.#worldStateSynchronizer.syncImmediate(blockNumber);
-        const db = this.#worldStateSynchronizer.getCommitted();
-        const gasTxValidator = this.createGasTxValidator(db);
-        const txsToEvict = [];
-        for await (const txHash of this.#pendingTxPriorityToHash.valuesAsync()){
-            const tx = await this.getPendingTxByHash(txHash);
-            if (!tx) {
-                continue;
-            }
-            // Evict pending txs that share nullifiers with mined txs
-            const txNullifiers = tx.data.getNonEmptyNullifiers();
-            if (txNullifiers.some((nullifier)=>minedNullifiers.has(nullifier.toString()))) {
-                this.#log.verbose(`Evicting tx ${txHash} from pool due to a duplicate nullifier with a mined tx`);
-                txsToEvict.push(TxHash.fromString(txHash));
-                continue;
-            }
-            // Evict pending txs with an insufficient fee payer balance
-            if (minedFeePayers.has(tx.data.feePayer.toString()) && (await gasTxValidator.validateTxFee(tx)).result === 'invalid') {
-                this.#log.verbose(`Evicting tx ${txHash} from pool due to an insufficient fee payer balance`);
-                txsToEvict.push(TxHash.fromString(txHash));
-                continue;
-            }
-            // Evict pending txs with an expiration timestamp less than or equal to the mined block timestamp
-            const includeByTimestamp = tx.data.includeByTimestamp;
-            if (includeByTimestamp <= timestamp) {
-                this.#log.verbose(`Evicting tx ${txHash} from pool due to the tx being expired (includeByTimestamp: ${includeByTimestamp}, mined block timestamp: ${timestamp})`);
-                txsToEvict.push(TxHash.fromString(txHash));
-                continue;
-            }
-        }
-        if (txsToEvict.length > 0) {
-            await this.deleteTxs(txsToEvict, {
-                eviction: true
-            });
-        }
-        return txsToEvict.length;
-    }
-    /**
-   * Evicts pending txs that no longer have valid archive roots or fee payer balances from the pool after a reorg.
-   *
-   * @param txHashes - The tx hashes of the txs that were moved from mined to pending.
-   * @returns The total number of txs evicted from the pool.
-   */ async evictInvalidTxsAfterReorg(txHashes) {
-        if (txHashes.length === 0) {
-            return 0;
-        }
-        await this.#worldStateSynchronizer.syncImmediate();
-        const db = this.#worldStateSynchronizer.getCommitted();
-        const archiveCache = this.createArchiveCache(db);
-        const gasTxValidator = this.createGasTxValidator(db);
-        const txsToEvict = [];
-        for await (const [txHash, headerHash] of this.#pendingTxHashToHeaderHash.entriesAsync()){
-            const tx = await this.getPendingTxByHash(txHash);
-            if (!tx) {
-                continue;
-            }
-            const [index] = await archiveCache.getArchiveIndices([
-                Fr.fromString(headerHash)
-            ]);
-            if (index === undefined) {
-                this.#log.verbose(`Evicting tx ${txHash} from pool due to an invalid archive root`);
-                txsToEvict.push(TxHash.fromString(txHash));
-                continue;
-            }
-            if ((await gasTxValidator.validateTxFee(tx)).result === 'invalid') {
-                this.#log.verbose(`Evicting tx ${txHash} from pool due to an insufficient fee payer balance`);
-                txsToEvict.push(TxHash.fromString(txHash));
-            }
-        }
-        if (txsToEvict.length > 0) {
-            await this.deleteTxs(txsToEvict, {
-                eviction: true
-            });
-        }
-        return txsToEvict.length;
-    }
-    async addPendingTxIndices(tx, txHash) {
-        await this.#pendingTxPriorityToHash.set(getPendingTxPriority(tx), txHash);
-        await this.#pendingTxHashToSize.set(txHash, tx.getSize());
-        await this.#pendingTxHashToHeaderHash.set(txHash, (await tx.data.constants.anchorBlockHeader.hash()).toString());
-    }
-    async removePendingTxIndices(tx, txHash) {
-        await this.#pendingTxPriorityToHash.deleteValue(getPendingTxPriority(tx), txHash);
-        await this.#pendingTxHashToSize.delete(txHash);
-        await this.#pendingTxHashToHeaderHash.delete(txHash);
-        this.#pendingTxs.delete(txHash);
-    }
-}

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

@@ -1,4 +0,0 @@
-export * from './tx_pool.js';
-export * from './memory_tx_pool.js';
-export * from './aztec_kv_tx_pool.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvdHhfcG9vbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsdUJBQXVCLENBQUMifQ==

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC"}

package/dest/mem_pools/tx_pool/index.js

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