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

package/dest/mem_pools/tx_pool/aztec_kv_tx_pool.js

@@ -1,596 +0,0 @@
-import { insertIntoSortedArray } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { toArray } from '@aztec/foundation/iterable';
-import { createLogger } from '@aztec/foundation/log';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { ChonkProof } from '@aztec/stdlib/proofs';
-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 { PoolInstrumentation, PoolName } from '../instrumentation.js';
-import { EvictionManager } from './eviction/eviction_manager.js';
-import { FeePayerTxInfo } from './eviction/eviction_strategy.js';
-import { FeePayerBalanceEvictionRule } from './eviction/fee_payer_balance_eviction_rule.js';
-import { InvalidTxsAfterMiningRule } from './eviction/invalid_txs_after_mining_rule.js';
-import { InvalidTxsAfterReorgRule } from './eviction/invalid_txs_after_reorg_rule.js';
-import { LowPriorityEvictionRule } from './eviction/low_priority_eviction_rule.js';
-import { NullifierConflictPreAddRule } from './eviction/nullifier_conflict_pre_add_rule.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;
-    /** Holds the historical block for each tx */ #pendingTxHashToHistoricalBlockHeaderHash;
-    /** 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;
-    /** 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;
-    #historicalHeaderToTxHash;
-    #feePayerToBalanceEntry;
-    /** Index from nullifier to pending tx hash */ #pendingNullifierToTxHash;
-    /** 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;
-    #evictionManager;
-    #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, worldState, telemetry = getTelemetryClient(), config = {}, log = createLogger('p2p:tx_pool')){
-        super();
-        this.#log = log;
-        this.#evictionManager = new EvictionManager(this);
-        this.#evictionManager.registerRule(new InvalidTxsAfterMiningRule());
-        this.#evictionManager.registerRule(new InvalidTxsAfterReorgRule(worldState));
-        this.#evictionManager.registerRule(new FeePayerBalanceEvictionRule(worldState));
-        this.#evictionManager.registerRule(new LowPriorityEvictionRule({
-            //NOTE: 0 effectively disables low priority eviction
-            maxPoolSize: config.maxPendingTxCount ?? 0
-        }));
-        this.#evictionManager.registerPreAddRule(new NullifierConflictPreAddRule());
-        this.updateConfig(config);
-        this.#txs = store.openMap('txs');
-        this.#minedTxHashToBlock = store.openMap('txHashToBlockMined');
-        this.#pendingTxPriorityToHash = store.openMultiMap('pendingTxFeeToHash');
-        this.#deletedMinedTxHashes = store.openMap('deletedMinedTxHashes');
-        this.#blockToDeletedMinedTxHash = store.openMultiMap('blockToDeletedMinedTxHash');
-        this.#pendingTxHashToHistoricalBlockHeaderHash = store.openMap('txHistoricalBlock');
-        this.#historicalHeaderToTxHash = store.openMultiMap('historicalHeaderToPendingTxHash');
-        this.#feePayerToBalanceEntry = store.openMultiMap('feePayerToBalanceEntry');
-        this.#pendingNullifierToTxHash = store.openMap('pendingNullifierToTxHash');
-        this.#nonEvictableTxs = new Set();
-        this.#archivedTxs = archive.openMap('archivedTxs');
-        this.#archivedTxIndices = archive.openMap('archivedTxIndices');
-        this.#store = store;
-        this.#archive = archive;
-        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 uniqueMinedNullifiers = [];
-        const uniqueMinedFeePayers = [];
-        try {
-            await this.#store.transactionAsync(async ()=>{
-                for (const hash of txHashes){
-                    const key = hash.toString();
-                    await this.#minedTxHashToBlock.set(key, blockHeader.globalVariables.blockNumber);
-                    const tx = await this.getTxByHash(hash);
-                    if (tx) {
-                        const nullifiers = tx.data.getNonEmptyNullifiers();
-                        nullifiers.forEach((nullifier)=>insertIntoSortedArray(uniqueMinedNullifiers, nullifier, Fr.cmp, false));
-                        insertIntoSortedArray(uniqueMinedFeePayers, tx.data.feePayer, (a, b)=>a.toField().cmp(b.toField()), false);
-                        await this.removePendingTxIndicesInDbTx(tx, key);
-                    }
-                    // 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.#evictionManager.evictAfterNewBlock(blockHeader, uniqueMinedNullifiers, uniqueMinedFeePayers);
-            this.#metrics.transactionsRemoved(txHashes.map((hash)=>hash.toBigInt()));
-        } catch (err) {
-            this.#log.warn('Unexpected error when marking txs as mined', {
-                err
-            });
-        }
-    }
-    async markMinedAsPending(txHashes, latestBlock) {
-        if (txHashes.length === 0) {
-            return Promise.resolve();
-        }
-        try {
-            await this.#store.transactionAsync(async ()=>{
-                for (const hash of txHashes){
-                    const key = hash.toString();
-                    await this.#minedTxHashToBlock.delete(key);
-                    // Clear soft-delete metadata if this tx was previously soft-deleted,
-                    // so cleanupDeletedMinedTxs won't later hard-delete it while it's pending
-                    const deletedBlock = await this.#deletedMinedTxHashes.getAsync(key);
-                    if (deletedBlock !== undefined) {
-                        await this.#deletedMinedTxHashes.delete(key);
-                        await this.#blockToDeletedMinedTxHash.deleteValue(deletedBlock, key);
-                    }
-                    // Rehydrate the tx in the in-memory pending txs mapping
-                    const tx = await this.getTxByHash(hash);
-                    if (tx) {
-                        await this.addPendingTxIndicesInDbTx(tx, key);
-                    }
-                }
-            });
-            await this.#evictionManager.evictAfterChainPrune(latestBlock);
-        } catch (err) {
-            this.#log.warn('Unexpected error when marking mined txs as pending', {
-                err
-            });
-        }
-    }
-    async getPendingTxHashes() {
-        const vals = await toArray(this.#pendingTxPriorityToHash.valuesAsync({
-            reverse: true
-        }));
-        return vals.map(TxHash.fromString);
-    }
-    /**
-   * 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.
-   * Handles nullifier deduplication: if an incoming tx has a nullifier conflict with
-   * existing pending txs, it will either replace them (if higher fee) or be rejected.
-   * @param txs - An array of txs to be added to the pool.
-   * @returns count of added transactions
-   */ async addTxs(txs, opts = {}) {
-        if (txs.length === 0) {
-            return Promise.resolve(0);
-        }
-        const addedTxs = [];
-        const uniqueFeePayers = [];
-        const replacedTxHashes = [];
-        const hashesAndStats = txs.map((tx)=>({
-                txHash: tx.getTxHash(),
-                txStats: tx.getStats()
-            }));
-        try {
-            await this.#store.transactionAsync(async ()=>{
-                for(let i = 0; i < txs.length; i++){
-                    const tx = txs[i];
-                    const { txHash, txStats } = hashesAndStats[i];
-                    const key = txHash.toString();
-                    if (await this.#txs.hasAsync(key)) {
-                        this.#log.debug(`Tx ${key} already exists in the pool`);
-                        continue;
-                    }
-                    const poolAccess = this.getPreAddPoolAccess();
-                    const { shouldReject, txHashesToEvict } = await this.#evictionManager.runPreAddRules(tx, poolAccess);
-                    if (shouldReject) {
-                        continue;
-                    }
-                    for (const txHashToEvict of txHashesToEvict){
-                        const txToDelete = await this.getTxByHash(txHashToEvict);
-                        if (txToDelete) {
-                            const evictedKey = txHashToEvict.toString();
-                            await this.deletePendingTxInDbTx(txToDelete, evictedKey);
-                            replacedTxHashes.push(txHashToEvict);
-                            this.#log.verbose(`Evicted tx ${evictedKey} due to higher-fee tx ${key}`);
-                        }
-                    }
-                    this.#log.verbose(`Adding tx ${key} to pool`, {
-                        eventName: 'tx-added-to-pool',
-                        ...txStats
-                    });
-                    await this.#txs.set(key, tx.toBuffer());
-                    addedTxs.push(tx);
-                    insertIntoSortedArray(uniqueFeePayers, tx.data.feePayer, (a, b)=>a.toField().cmp(b.toField()), false);
-                    await this.#pendingTxHashToHistoricalBlockHeaderHash.set(key, (await tx.data.constants.anchorBlockHeader.hash()).toString());
-                    if (!await this.#minedTxHashToBlock.hasAsync(key)) {
-                        await this.addPendingTxIndicesInDbTx(tx, key);
-                        this.#metrics.recordSize(tx);
-                    }
-                }
-            });
-            await this.#evictionManager.evictAfterNewTxs(addedTxs.map(({ txHash })=>txHash), uniqueFeePayers);
-        } catch (err) {
-            this.#log.warn('Unexpected error when adding txs', {
-                err
-            });
-        }
-        if (replacedTxHashes.length > 0) {
-            this.#metrics.transactionsRemoved(replacedTxHashes.map((hash)=>hash.toBigInt()));
-        }
-        if (addedTxs.length > 0) {
-            this.#metrics.transactionsAdded(addedTxs);
-            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 ()=>{
-            for (const hash of txHashes){
-                const key = hash.toString();
-                const tx = await this.getTxByHash(hash);
-                if (!tx) {
-                    this.#log.trace(`Skipping deletion of missing tx ${key} from pool`);
-                    continue;
-                }
-                const minedBlockNumber = await this.#minedTxHashToBlock.getAsync(key);
-                const txIsPending = minedBlockNumber === undefined;
-                if (txIsPending) {
-                    await this.deletePendingTxInDbTx(tx, key);
-                } else {
-                    await this.deleteMinedTx(key, minedBlockNumber, opts?.permanently ?? false);
-                    const shouldArchiveTx = this.#archivedTxLimit && !opts?.permanently;
-                    if (shouldArchiveTx) {
-                        deletedTxs.push(tx);
-                    }
-                }
-            }
-        });
-        this.#metrics.transactionsRemoved(txHashes.map((hash)=>hash.toBigInt()));
-        this.#log.debug(`Deleted ${txHashes.length} txs from pool`, {
-            txHashes
-        });
-        return this.#archivedTxLimit ? poolDbTx.then(()=>this.archiveTxs(deletedTxs)) : poolDbTx;
-    }
-    async deleteMinedTx(txHash, minedBlockNumber, permanently) {
-        await this.#minedTxHashToBlock.delete(txHash);
-        if (permanently) {
-            this.#log.trace(`Deleting mined tx ${txHash} from pool`);
-            await this.#txs.delete(txHash);
-            return;
-        }
-        // Soft-delete mined transactions: remove from mined set but keep in storage
-        this.#log.trace(`Soft-deleting mined tx ${txHash} from pool`);
-        await this.#deletedMinedTxHashes.set(txHash, minedBlockNumber);
-        await this.#blockToDeletedMinedTxHash.set(minedBlockNumber, txHash);
-    }
-    // Assumes being called within a DB transaction
-    async deletePendingTxInDbTx(tx, txHash) {
-        // We always permanently delete pending transactions
-        this.#log.trace(`Deleting pending tx ${txHash} from pool`);
-        await this.removePendingTxIndicesInDbTx(tx, txHash);
-        await this.#txs.delete(txHash);
-        await this.#pendingTxHashToHistoricalBlockHeaderHash.delete(txHash);
-    }
-    /**
-   * 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));
-    }
-    async getPendingTxInfos() {
-        const vals = await toArray(this.#pendingTxPriorityToHash.valuesAsync());
-        const results = await Promise.all(vals.map((val)=>this.getPendingTxInfo(TxHash.fromString(val))));
-        return results.filter((info)=>info !== undefined);
-    }
-    async getPendingTxInfo(txHash) {
-        let historicalBlockHash = await this.#pendingTxHashToHistoricalBlockHeaderHash.getAsync(txHash.toString());
-        // Not all tx might have this index created.
-        if (!historicalBlockHash) {
-            const tx = await this.getTxByHash(txHash);
-            if (!tx) {
-                this.#log.warn(`PendingTxInfo:tx ${txHash} not found`);
-                return undefined;
-            }
-            historicalBlockHash = (await tx.data.constants.anchorBlockHeader.hash()).toString();
-            await this.#pendingTxHashToHistoricalBlockHeaderHash.set(txHash.toString(), historicalBlockHash);
-        }
-        return {
-            txHash,
-            blockHash: Fr.fromString(historicalBlockHash),
-            isEvictable: !this.#nonEvictableTxs.has(txHash.toString())
-        };
-    }
-    async getPendingTxsReferencingBlocks(blockHashes) {
-        const result = [];
-        for (const blockHash of blockHashes){
-            const chunk = await toArray(this.#historicalHeaderToTxHash.getValuesAsync(blockHash.toString()));
-            result.push(...chunk.map((txHash)=>({
-                    txHash: TxHash.fromString(txHash),
-                    blockHash,
-                    isEvictable: !this.#nonEvictableTxs.has(txHash)
-                })));
-        }
-        return result;
-    }
-    async getPendingFeePayers() {
-        const feePayers = [];
-        for await (const feePayer of this.#feePayerToBalanceEntry.keysAsync()){
-            const address = AztecAddress.fromString(feePayer);
-            insertIntoSortedArray(feePayers, address, (a, b)=>a.toField().cmp(b.toField()), false);
-        }
-        return feePayers;
-    }
-    async *getFeePayerTxInfos(feePayer) {
-        for await (const value of this.#feePayerToBalanceEntry.getValuesAsync(feePayer.toString())){
-            const info = FeePayerTxInfo.decode(value);
-            info.isEvictable = !this.#nonEvictableTxs.has(info.txHash.toString());
-            yield info;
-        }
-    }
-    async getMinedTxHashes() {
-        const vals = await toArray(this.#minedTxHashToBlock.entriesAsync());
-        return vals.map(([txHash, blockNumber])=>[
-                TxHash.fromString(txHash),
-                blockNumber
-            ]);
-    }
-    async getPendingTxCount() {
-        return await this.#pendingTxPriorityToHash.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;
-        }
-    }
-    updateConfig(cfg) {
-        if (typeof cfg.archivedTxLimit === 'number') {
-            assert(cfg.archivedTxLimit >= 0, 'archivedTxLimit must be greater or equal to 0');
-            this.#archivedTxLimit = cfg.archivedTxLimit;
-        }
-        if (this.#evictionManager) {
-            this.#evictionManager.updateConfig(cfg);
-        }
-    }
-    markTxsAsNonEvictable(txHashes) {
-        txHashes.forEach((txHash)=>this.#nonEvictableTxs.add(txHash.toString()));
-        return Promise.resolve();
-    }
-    clearNonEvictableTxs() {
-        // Clear the non-evictable set after completing the DB updates above.
-        // This ensures pinned (non-evictable) txs are protected while we mark mined txs,
-        // but they won't remain pinned indefinitely across blocks. Note that eviction rules
-        // (including post-mining invalidation) respect the non-evictable flag while it is set.
-        this.#nonEvictableTxs.clear();
-        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;
-        await this.#store.transactionAsync(async ()=>{
-            const txHashesToDelete = [];
-            const blocksToDelete = [];
-            // 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++;
-                }
-            }
-            this.#metrics.transactionsRemoved(txHashesToDelete);
-            // 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 an ArchiveCache instance.
-   * @param db - DB for the cache to use
-   * @returns An ArchiveCache instance
-   */ createArchiveCache(db) {
-        return new ArchiveCache(db);
-    }
-    /**
-   * Archives a list of txs for future reference. The number of archived txs is limited by the specified archivedTxLimit.
-   * Note: Pending txs should not be archived, only finalized txs
-   * @param txs - The list of transactions to archive.
-   * @returns Empty promise.
-   */ async archiveTxs(txs) {
-        if (txs.length === 0) {
-            return;
-        }
-        if (this.#archivedTxLimit === 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
-            });
-        }
-    }
-    // Assumes being called within a DB transaction
-    async addPendingTxIndicesInDbTx(tx, txHash) {
-        await this.#pendingTxPriorityToHash.set(getPendingTxPriority(tx), txHash);
-        await this.#historicalHeaderToTxHash.set((await tx.data.constants.anchorBlockHeader.hash()).toString(), txHash);
-        await this.#feePayerToBalanceEntry.set(tx.data.feePayer.toString(), await FeePayerTxInfo.encode(tx, txHash));
-        // Add nullifier entries for conflict detection
-        const nullifiers = tx.data.getNonEmptyNullifiers();
-        for (const nullifier of nullifiers){
-            await this.#pendingNullifierToTxHash.set(nullifier.toString(), txHash);
-        }
-    }
-    // Assumes being called within a DB transaction
-    async removePendingTxIndicesInDbTx(tx, txHash) {
-        await this.#pendingTxPriorityToHash.deleteValue(getPendingTxPriority(tx), txHash);
-        await this.#historicalHeaderToTxHash.deleteValue((await tx.data.constants.anchorBlockHeader.hash()).toString(), txHash);
-        await this.#feePayerToBalanceEntry.deleteValue(tx.data.feePayer.toString(), await FeePayerTxInfo.encode(tx, txHash));
-        // Remove nullifier entries
-        const nullifiers = tx.data.getNonEmptyNullifiers();
-        for (const nullifier of nullifiers){
-            await this.#pendingNullifierToTxHash.delete(nullifier.toString());
-        }
-    }
-    /**
-   * Returns up to `limit` lowest-priority evictable pending tx hashes without hydrating transactions.
-   * Iterates the priority index in ascending order and skips non-evictable txs.
-   */ async getLowestPriorityEvictable(limit) {
-        const txsToEvict = [];
-        if (limit <= 0) {
-            return txsToEvict;
-        }
-        for await (const txHashStr of this.#pendingTxPriorityToHash.valuesAsync()){
-            if (this.#nonEvictableTxs.has(txHashStr)) {
-                continue;
-            }
-            txsToEvict.push(TxHash.fromString(txHashStr));
-            if (txsToEvict.length >= limit) {
-                break;
-            }
-        }
-        return txsToEvict;
-    }
-    /**
-   * Creates a PreAddPoolAccess object for use by pre-add eviction rules.
-   * Provides read-only access to pool state during addTxs transaction.
-   */ getPreAddPoolAccess() {
-        return {
-            getTxHashByNullifier: async (nullifier)=>{
-                const hashStr = await this.#pendingNullifierToTxHash.getAsync(nullifier.toString());
-                return hashStr ? TxHash.fromString(hashStr) : undefined;
-            },
-            getPendingTxByHash: this.getTxByHash.bind(this),
-            getTxPriority: getPendingTxPriority
-        };
-    }
-}

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

@@ -1,32 +0,0 @@
-import type { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
-import type { TxPoolOptions } from '../tx_pool.js';
-import { type EvictionRule, type PreAddEvictionResult, type PreAddEvictionRule, type PreAddPoolAccess, type TxPoolOperations } from './eviction_strategy.js';
-export declare class EvictionManager {
-    private txPool;
-    private log;
-    private rules;
-    /** Pre-add eviction rules (run inside addTxs transaction) */
-    private preAddRules;
-    constructor(txPool: TxPoolOperations, log?: import("@aztec/foundation/log").Logger);
-    evictAfterNewTxs(newTxs: TxHash[], feePayers: AztecAddress[]): Promise<void>;
-    evictAfterNewBlock(block: BlockHeader, newNullifiers: Fr[], minedFeePayers: AztecAddress[]): Promise<void>;
-    evictAfterChainPrune(blockNumber: BlockNumber): Promise<void>;
-    /**
-     * Runs pre-add eviction rules to determine if an incoming tx should be added
-     * and which existing txs should be evicted.
-     * Called from inside the addTxs database transaction for atomicity.
-     *
-     * @param tx - The incoming transaction
-     * @param poolAccess - Read-only access to pool state
-     * @returns Combined result from all pre-add rules
-     */
-    runPreAddRules(tx: Tx, poolAccess: PreAddPoolAccess): Promise<PreAddEvictionResult>;
-    registerRule(rule: EvictionRule): void;
-    registerPreAddRule(rule: PreAddEvictionRule): void;
-    updateConfig(config: TxPoolOptions): void;
-    private runEvictionRules;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZpY3Rpb25fbWFuYWdlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21lbV9wb29scy90eF9wb29sL2V2aWN0aW9uL2V2aWN0aW9uX21hbmFnZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDbkUsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXBELE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ2hFLE9BQU8sRUFBRSxXQUFXLEVBQUUsRUFBRSxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRTNELE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRCxPQUFPLEVBR0wsS0FBSyxZQUFZLEVBQ2pCLEtBQUssb0JBQW9CLEVBQ3pCLEtBQUssa0JBQWtCLEVBQ3ZCLEtBQUssZ0JBQWdCLEVBQ3JCLEtBQUssZ0JBQWdCLEVBQ3RCLE1BQU0sd0JBQXdCLENBQUM7QUFFaEMscUJBQWEsZUFBZTtJQU94QixPQUFPLENBQUMsTUFBTTtJQUNkLE9BQU8sQ0FBQyxHQUFHO0lBUGIsT0FBTyxDQUFDLEtBQUssQ0FBc0I7SUFFbkMsNkRBQTZEO0lBQzdELE9BQU8sQ0FBQyxXQUFXLENBQTRCO0lBRS9DLFlBQ1UsTUFBTSxFQUFFLGdCQUFnQixFQUN4QixHQUFHLHlDQUF1RCxFQUNoRTtJQUVTLGdCQUFnQixDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQU94RjtJQUVZLGtCQUFrQixDQUM3QixLQUFLLEVBQUUsV0FBVyxFQUNsQixhQUFhLEVBQUUsRUFBRSxFQUFFLEVBQ25CLGNBQWMsRUFBRSxZQUFZLEVBQUUsR0FDN0IsT0FBTyxDQUFDLElBQUksQ0FBQyxDQVNmO0lBRVksb0JBQW9CLENBQUMsV0FBVyxFQUFFLFdBQVcsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBTXpFO0lBRUQ7Ozs7Ozs7O09BUUc7SUFDVSxjQUFjLENBQUMsRUFBRSxFQUFFLEVBQUUsRUFBRSxVQUFVLEVBQUUsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLG9CQUFvQixDQUFDLENBNkIvRjtJQUVNLFlBQVksQ0FBQyxJQUFJLEVBQUUsWUFBWSxRQUVyQztJQUVNLGtCQUFrQixDQUFDLElBQUksRUFBRSxrQkFBa0IsUUFFakQ7SUFFTSxZQUFZLENBQUMsTUFBTSxFQUFFLGFBQWEsR0FBRyxJQUFJLENBTy9DO1lBRWEsZ0JBQWdCO0NBYS9CIn0=

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

@@ -1 +0,0 @@
-{"version":3,"file":"eviction_manager.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool/eviction/eviction_manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACtB,MAAM,wBAAwB,CAAC;AAEhC,qBAAa,eAAe;IAOxB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,GAAG;IAPb,OAAO,CAAC,KAAK,CAAsB;IAEnC,6DAA6D;IAC7D,OAAO,CAAC,WAAW,CAA4B;IAE/C,YACU,MAAM,EAAE,gBAAgB,EACxB,GAAG,yCAAuD,EAChE;IAES,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAOxF;IAEY,kBAAkB,CAC7B,KAAK,EAAE,WAAW,EAClB,aAAa,EAAE,EAAE,EAAE,EACnB,cAAc,EAAE,YAAY,EAAE,GAC7B,OAAO,CAAC,IAAI,CAAC,CASf;IAEY,oBAAoB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAMzE;IAED;;;;;;;;OAQG;IACU,cAAc,CAAC,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA6B/F;IAEM,YAAY,CAAC,IAAI,EAAE,YAAY,QAErC;IAEM,kBAAkB,CAAC,IAAI,EAAE,kBAAkB,QAEjD;IAEM,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAO/C;YAEa,gBAAgB;CAa/B"}