@aztec/p2p 0.0.1-commit.e3c1de76 → 0.0.1-commit.e558bd1c

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

@@ -1 +1 @@
-{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../src/mem_pools/interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAC;AAC9E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,eAAe,CAAC;CAClC,CAAC"}
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../src/mem_pools/interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AACjF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,kBAAkB,CAAC;CACrC,CAAC"}

package/dest/mem_pools/tx_pool_v2/archive/index.d.ts

@@ -0,0 +1,2 @@
+export { TxArchive } from './tx_archive.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvdHhfcG9vbF92Mi9hcmNoaXZlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQyJ9

package/dest/mem_pools/tx_pool_v2/archive/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/archive/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC"}

package/dest/mem_pools/tx_pool_v2/archive/index.js

@@ -0,0 +1 @@
+export { TxArchive } from './tx_archive.js';

package/dest/mem_pools/tx_pool_v2/archive/tx_archive.d.ts

@@ -0,0 +1,43 @@
+import { type Logger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
+/**
+ * Manages archived transactions with FIFO eviction.
+ * Archived transactions have their proofs stripped to save space.
+ */
+export declare class TxArchive {
+    #private;
+    constructor(store: AztecAsyncKVStore, limit: number, log?: Logger);
+    /**
+     * Updates the maximum number of archived transactions.
+     */
+    updateLimit(limit: number): void;
+    /**
+     * Gets the current archive limit.
+     */
+    getLimit(): number;
+    /**
+     * Checks if archiving is enabled.
+     */
+    isEnabled(): boolean;
+    /**
+     * Archives transactions, stripping their proofs.
+     * Evicts oldest transactions if the limit is exceeded.
+     */
+    archiveTxs(txs: Tx[]): Promise<void>;
+    /**
+     * Retrieves an archived transaction by its hash.
+     */
+    getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
+    /**
+     * Gets the current count of archived transactions.
+     */
+    getCount(): Promise<number>;
+    /**
+     * Strips the proof from a transaction for archival.
+     */
+    private stripProof;
+    private getHeadIndex;
+    private getTailIndex;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfYXJjaGl2ZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21lbV9wb29scy90eF9wb29sX3YyL2FyY2hpdmUvdHhfYXJjaGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFDbEUsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQWlCLE1BQU0saUJBQWlCLENBQUM7QUFFeEUsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUU5Qzs7O0dBR0c7QUFDSCxxQkFBYSxTQUFTOztJQU9wQixZQUFZLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLEdBQUcsQ0FBQyxFQUFFLE1BQU0sRUFNaEU7SUFFRDs7T0FFRztJQUNILFdBQVcsQ0FBQyxLQUFLLEVBQUUsTUFBTSxHQUFHLElBQUksQ0FFL0I7SUFFRDs7T0FFRztJQUNILFFBQVEsSUFBSSxNQUFNLENBRWpCO0lBRUQ7O09BRUc7SUFDSCxTQUFTLElBQUksT0FBTyxDQUVuQjtJQUVEOzs7T0FHRztJQUNHLFVBQVUsQ0FBQyxHQUFHLEVBQUUsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQW1DekM7SUFFRDs7T0FFRztJQUNHLFdBQVcsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxFQUFFLEdBQUcsU0FBUyxDQUFDLENBR3pEO0lBRUQ7O09BRUc7SUFDRyxRQUFRLElBQUksT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUloQztJQUVEOztPQUVHO0lBQ0gsT0FBTyxDQUFDLFVBQVU7WUFJSixZQUFZO1lBS1osWUFBWTtDQUkzQiJ9

package/dest/mem_pools/tx_pool_v2/archive/tx_archive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx_archive.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/archive/tx_archive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AAExE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;;GAGG;AACH,qBAAa,SAAS;;IAOpB,YAAY,KAAK,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAMhE;IAED;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE/B;IAED;;OAEG;IACH,QAAQ,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,SAAS,IAAI,OAAO,CAEnB;IAED;;;OAGG;IACG,UAAU,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAmCzC;IAED;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC,CAGzD;IAED;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAIhC;IAED;;OAEG;IACH,OAAO,CAAC,UAAU;YAIJ,YAAY;YAKZ,YAAY;CAI3B"}

package/dest/mem_pools/tx_pool_v2/archive/tx_archive.js

@@ -0,0 +1,103 @@
+import { createLogger } from '@aztec/foundation/log';
+import { ChonkProof } from '@aztec/stdlib/proofs';
+import { Tx } from '@aztec/stdlib/tx';
+/**
+ * Manages archived transactions with FIFO eviction.
+ * Archived transactions have their proofs stripped to save space.
+ */ export class TxArchive {
+    #store;
+    #txs;
+    #indices;
+    #limit;
+    #log;
+    constructor(store, limit, log){
+        this.#store = store;
+        this.#txs = store.openMap('archivedTxs');
+        this.#indices = store.openMap('archivedTxIndices');
+        this.#limit = limit;
+        this.#log = log ?? createLogger('p2p:tx_pool_v2:archive');
+    }
+    /**
+   * Updates the maximum number of archived transactions.
+   */ updateLimit(limit) {
+        this.#limit = limit;
+    }
+    /**
+   * Gets the current archive limit.
+   */ getLimit() {
+        return this.#limit;
+    }
+    /**
+   * Checks if archiving is enabled.
+   */ isEnabled() {
+        return this.#limit > 0;
+    }
+    /**
+   * Archives transactions, stripping their proofs.
+   * Evicts oldest transactions if the limit is exceeded.
+   */ async archiveTxs(txs) {
+        if (!this.isEnabled() || txs.length === 0) {
+            return;
+        }
+        try {
+            await this.#store.transactionAsync(async ()=>{
+                // Get current head and tail indices
+                let headIdx = await this.getHeadIndex();
+                let tailIdx = await this.getTailIndex();
+                for (const tx of txs){
+                    // Evict oldest entries if at capacity
+                    while(headIdx - tailIdx >= this.#limit){
+                        const txHashToEvict = await this.#indices.getAsync(tailIdx);
+                        if (txHashToEvict) {
+                            await this.#txs.delete(txHashToEvict);
+                            await this.#indices.delete(tailIdx);
+                        }
+                        tailIdx++;
+                    }
+                    // Archive the transaction with stripped proof
+                    const archivedTx = this.stripProof(tx);
+                    const txHash = tx.getTxHash().toString();
+                    await this.#txs.set(txHash, archivedTx.toBuffer());
+                    await this.#indices.set(headIdx, txHash);
+                    headIdx++;
+                }
+                this.#log.debug(`Archived ${txs.length} txs, total: ${headIdx - tailIdx}`);
+            });
+        } catch (error) {
+            this.#log.error('Error archiving transactions', {
+                error
+            });
+        }
+    }
+    /**
+   * Retrieves an archived transaction by its hash.
+   */ async getTxByHash(txHash) {
+        const buffer = await this.#txs.getAsync(txHash.toString());
+        return buffer ? Tx.fromBuffer(buffer) : undefined;
+    }
+    /**
+   * Gets the current count of archived transactions.
+   */ async getCount() {
+        const head = await this.getHeadIndex();
+        const tail = await this.getTailIndex();
+        return head - tail;
+    }
+    /**
+   * Strips the proof from a transaction for archival.
+   */ stripProof(tx) {
+        return new Tx(tx.txHash, tx.data, ChonkProof.empty(), tx.contractClassLogFields, tx.publicFunctionCalldata);
+    }
+    async getHeadIndex() {
+        const entry = await this.#indices.entriesAsync({
+            limit: 1,
+            reverse: true
+        }).next();
+        return (entry.value?.[0] ?? -1) + 1;
+    }
+    async getTailIndex() {
+        const entry = await this.#indices.entriesAsync({
+            limit: 1
+        }).next();
+        return entry.value?.[0] ?? 0;
+    }
+}

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

@@ -0,0 +1,47 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { Logger } from '@aztec/foundation/log';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+import type { TxMetaData } from '../tx_metadata.js';
+import { type EvictionConfig, type EvictionRule, type PoolOperations, type PreAddPoolAccess, type PreAddResult, type PreAddRule } from './interfaces.js';
+/**
+ * Manages eviction rules for the transaction pool.
+ * Coordinates pre-add rules (run during addPendingTxs) and post-event rules (run after events).
+ */
+export declare class EvictionManager {
+    private pool;
+    private log;
+    private preAddRules;
+    private postEventRules;
+    constructor(pool: PoolOperations, log: Logger);
+    /**
+     * Registers a pre-add rule that runs during transaction addition.
+     */
+    registerPreAddRule(rule: PreAddRule): void;
+    /**
+     * Registers a post-event eviction rule that runs after events.
+     */
+    registerRule(rule: EvictionRule): void;
+    /**
+     * Runs all pre-add rules for an incoming transaction.
+     * Returns combined result of all rules.
+     */
+    runPreAddRules(incomingMeta: TxMetaData, poolAccess: PreAddPoolAccess): Promise<PreAddResult>;
+    /**
+     * Runs post-event eviction after new transactions are added.
+     */
+    evictAfterNewTxs(newTxHashes: string[], feePayers: string[]): Promise<void>;
+    /**
+     * Runs post-event eviction after a block is mined.
+     */
+    evictAfterNewBlock(block: BlockHeader, newNullifiers: string[], feePayers: string[]): Promise<void>;
+    /**
+     * Runs post-event eviction after a chain prune (reorg).
+     */
+    evictAfterChainPrune(blockNumber: BlockNumber): Promise<void>;
+    /**
+     * Updates configuration for all rules.
+     */
+    updateConfig(config: EvictionConfig): void;
+    private runPostEventRules;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZpY3Rpb25fbWFuYWdlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21lbV9wb29scy90eF9wb29sX3YyL2V2aWN0aW9uL2V2aWN0aW9uX21hbmFnZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDbkUsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDcEQsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFcEQsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDcEQsT0FBTyxFQUNMLEtBQUssY0FBYyxFQUduQixLQUFLLFlBQVksRUFDakIsS0FBSyxjQUFjLEVBQ25CLEtBQUssZ0JBQWdCLEVBQ3JCLEtBQUssWUFBWSxFQUNqQixLQUFLLFVBQVUsRUFDaEIsTUFBTSxpQkFBaUIsQ0FBQztBQUV6Qjs7O0dBR0c7QUFDSCxxQkFBYSxlQUFlO0lBS3hCLE9BQU8sQ0FBQyxJQUFJO0lBQ1osT0FBTyxDQUFDLEdBQUc7SUFMYixPQUFPLENBQUMsV0FBVyxDQUFvQjtJQUN2QyxPQUFPLENBQUMsY0FBYyxDQUFzQjtJQUU1QyxZQUNVLElBQUksRUFBRSxjQUFjLEVBQ3BCLEdBQUcsRUFBRSxNQUFNLEVBQ2pCO0lBRUo7O09BRUc7SUFDSCxrQkFBa0IsQ0FBQyxJQUFJLEVBQUUsVUFBVSxHQUFHLElBQUksQ0FHekM7SUFFRDs7T0FFRztJQUNILFlBQVksQ0FBQyxJQUFJLEVBQUUsWUFBWSxHQUFHLElBQUksQ0FHckM7SUFFRDs7O09BR0c7SUFDRyxjQUFjLENBQUMsWUFBWSxFQUFFLFVBQVUsRUFBRSxVQUFVLEVBQUUsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQWdDbEc7SUFFRDs7T0FFRztJQUNHLGdCQUFnQixDQUFDLFdBQVcsRUFBRSxNQUFNLEVBQUUsRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQVFoRjtJQUVEOztPQUVHO0lBQ0csa0JBQWtCLENBQUMsS0FBSyxFQUFFLFdBQVcsRUFBRSxhQUFhLEVBQUUsTUFBTSxFQUFFLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FTeEc7SUFFRDs7T0FFRztJQUNHLG9CQUFvQixDQUFDLFdBQVcsRUFBRSxXQUFXLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQU9sRTtJQUVEOztPQUVHO0lBQ0gsWUFBWSxDQUFDLE1BQU0sRUFBRSxjQUFjLEdBQUcsSUFBSSxDQU96QztZQUVhLGlCQUFpQjtDQVloQyJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"eviction_manager.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/eviction/eviction_manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EACL,KAAK,cAAc,EAGnB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,UAAU,EAChB,MAAM,iBAAiB,CAAC;AAEzB;;;GAGG;AACH,qBAAa,eAAe;IAKxB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,GAAG;IALb,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,cAAc,CAAsB;IAE5C,YACU,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,MAAM,EACjB;IAEJ;;OAEG;IACH,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAGzC;IAED;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAGrC;IAED;;;OAGG;IACG,cAAc,CAAC,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CAgClG;IAED;;OAEG;IACG,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAQhF;IAED;;OAEG;IACG,kBAAkB,CAAC,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CASxG;IAED;;OAEG;IACG,oBAAoB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAOlE;IAED;;OAEG;IACH,YAAY,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAOzC;YAEa,iBAAiB;CAYhC"}

package/dest/mem_pools/tx_pool_v2/eviction/eviction_manager.js

@@ -0,0 +1,119 @@
+import { EvictionEvent } from './interfaces.js';
+/**
+ * Manages eviction rules for the transaction pool.
+ * Coordinates pre-add rules (run during addPendingTxs) and post-event rules (run after events).
+ */ export class EvictionManager {
+    pool;
+    log;
+    preAddRules;
+    postEventRules;
+    constructor(pool, log){
+        this.pool = pool;
+        this.log = log;
+        this.preAddRules = [];
+        this.postEventRules = [];
+    }
+    /**
+   * Registers a pre-add rule that runs during transaction addition.
+   */ registerPreAddRule(rule) {
+        this.preAddRules.push(rule);
+        this.log.debug(`Registered pre-add rule: ${rule.name}`);
+    }
+    /**
+   * Registers a post-event eviction rule that runs after events.
+   */ registerRule(rule) {
+        this.postEventRules.push(rule);
+        this.log.debug(`Registered eviction rule: ${rule.name}`);
+    }
+    /**
+   * Runs all pre-add rules for an incoming transaction.
+   * Returns combined result of all rules.
+   */ async runPreAddRules(incomingMeta, poolAccess) {
+        const allTxHashesToEvict = [];
+        for (const rule of this.preAddRules){
+            try {
+                const result = await rule.check(incomingMeta, poolAccess);
+                if (result.shouldIgnore) {
+                    return result;
+                }
+                // Collect txs to evict from all rules
+                for (const txHash of result.txHashesToEvict){
+                    if (!allTxHashesToEvict.includes(txHash)) {
+                        allTxHashesToEvict.push(txHash);
+                    }
+                }
+            } catch (err) {
+                this.log.error(`Error running pre-add rule ${rule.name}`, {
+                    err,
+                    txHash: incomingMeta.txHash
+                });
+                // On error, ignore the transaction to be safe
+                return {
+                    shouldIgnore: true,
+                    txHashesToEvict: [],
+                    reason: `pre-add rule ${rule.name} error: ${err}`
+                };
+            }
+        }
+        return {
+            shouldIgnore: false,
+            txHashesToEvict: allTxHashesToEvict
+        };
+    }
+    /**
+   * Runs post-event eviction after new transactions are added.
+   */ async evictAfterNewTxs(newTxHashes, feePayers) {
+        const context = {
+            event: EvictionEvent.TXS_ADDED,
+            newTxHashes,
+            feePayers
+        };
+        await this.runPostEventRules(context);
+    }
+    /**
+   * Runs post-event eviction after a block is mined.
+   */ async evictAfterNewBlock(block, newNullifiers, feePayers) {
+        const context = {
+            event: EvictionEvent.BLOCK_MINED,
+            block,
+            newNullifiers,
+            feePayers
+        };
+        await this.runPostEventRules(context);
+    }
+    /**
+   * Runs post-event eviction after a chain prune (reorg).
+   */ async evictAfterChainPrune(blockNumber) {
+        const context = {
+            event: EvictionEvent.CHAIN_PRUNED,
+            blockNumber
+        };
+        await this.runPostEventRules(context);
+    }
+    /**
+   * Updates configuration for all rules.
+   */ updateConfig(config) {
+        for (const rule of this.preAddRules){
+            rule.updateConfig?.(config);
+        }
+        for (const rule of this.postEventRules){
+            rule.updateConfig?.(config);
+        }
+    }
+    async runPostEventRules(context) {
+        for (const rule of this.postEventRules){
+            try {
+                const result = await rule.evict(context, this.pool);
+                if (!result.success) {
+                    this.log.warn(`Eviction rule ${rule.name} failed`, {
+                        error: result.error
+                    });
+                }
+            } catch (err) {
+                this.log.error(`Error running eviction rule ${rule.name}`, {
+                    err
+                });
+            }
+        }
+    }
+}

package/dest/mem_pools/tx_pool_v2/eviction/fee_payer_balance_eviction_rule.d.ts

@@ -0,0 +1,17 @@
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { EvictionContext, EvictionResult, EvictionRule, PoolOperations } from './interfaces.js';
+/**
+ * Eviction rule that removes transactions when fee payers have insufficient balance.
+ * Triggers on TXS_ADDED, BLOCK_MINED, and CHAIN_PRUNED events.
+ */
+export declare class FeePayerBalanceEvictionRule implements EvictionRule {
+    private worldState;
+    readonly name = "FeePayerBalanceEviction";
+    readonly reason = "fee_payer_balance";
+    private log;
+    constructor(worldState: WorldStateSynchronizer);
+    evict(context: EvictionContext, pool: PoolOperations): Promise<EvictionResult>;
+    private evictForFeePayers;
+    private getEvictionsForFeePayer;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmVlX3BheWVyX2JhbGFuY2VfZXZpY3Rpb25fcnVsZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21lbV9wb29scy90eF9wb29sX3YyL2V2aWN0aW9uL2ZlZV9wYXllcl9iYWxhbmNlX2V2aWN0aW9uX3J1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsT0FBTyxLQUFLLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUk5RSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsY0FBYyxFQUFFLFlBQVksRUFBRSxjQUFjLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUdyRzs7O0dBR0c7QUFDSCxxQkFBYSwyQkFBNEIsWUFBVyxZQUFZO0lBTWxELE9BQU8sQ0FBQyxVQUFVO0lBTDlCLFNBQWdCLElBQUksNkJBQTZCO0lBQ2pELFNBQWdCLE1BQU0sdUJBQXVCO0lBRTdDLE9BQU8sQ0FBQyxHQUFHLENBQWtFO0lBRTdFLFlBQW9CLFVBQVUsRUFBRSxzQkFBc0IsRUFBSTtJQUVwRCxLQUFLLENBQUMsT0FBTyxFQUFFLGVBQWUsRUFBRSxJQUFJLEVBQUUsY0FBYyxHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FnQ25GO1lBRWEsaUJBQWlCO1lBc0JqQix1QkFBdUI7Q0FzQ3RDIn0=

package/dest/mem_pools/tx_pool_v2/eviction/fee_payer_balance_eviction_rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fee_payer_balance_eviction_rule.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/eviction/fee_payer_balance_eviction_rule.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAI9E,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGrG;;;GAGG;AACH,qBAAa,2BAA4B,YAAW,YAAY;IAMlD,OAAO,CAAC,UAAU;IAL9B,SAAgB,IAAI,6BAA6B;IACjD,SAAgB,MAAM,uBAAuB;IAE7C,OAAO,CAAC,GAAG,CAAkE;IAE7E,YAAoB,UAAU,EAAE,sBAAsB,EAAI;IAEpD,KAAK,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAgCnF;YAEa,iBAAiB;YAsBjB,uBAAuB;CAsCtC"}

package/dest/mem_pools/tx_pool_v2/eviction/fee_payer_balance_eviction_rule.js

@@ -0,0 +1,90 @@
+import { createLogger } from '@aztec/foundation/log';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { DatabasePublicStateSource } from '@aztec/stdlib/trees';
+import { comparePriority } from '../tx_metadata.js';
+import { EvictionEvent } from './interfaces.js';
+/**
+ * Eviction rule that removes transactions when fee payers have insufficient balance.
+ * Triggers on TXS_ADDED, BLOCK_MINED, and CHAIN_PRUNED events.
+ */ export class FeePayerBalanceEvictionRule {
+    worldState;
+    name;
+    reason;
+    log;
+    constructor(worldState){
+        this.worldState = worldState;
+        this.name = 'FeePayerBalanceEviction';
+        this.reason = 'fee_payer_balance';
+        this.log = createLogger('p2p:tx_pool_v2:fee_payer_balance_eviction_rule');
+    }
+    async evict(context, pool) {
+        try {
+            if (context.event === EvictionEvent.TXS_ADDED) {
+                return await this.evictForFeePayers(context.feePayers, this.worldState.getCommitted(), pool);
+            }
+            if (context.event === EvictionEvent.BLOCK_MINED) {
+                const blockNumber = context.block.getBlockNumber();
+                await this.worldState.syncImmediate(blockNumber);
+                return await this.evictForFeePayers(context.feePayers, this.worldState.getSnapshot(blockNumber), pool);
+            }
+            if (context.event === EvictionEvent.CHAIN_PRUNED) {
+                await this.worldState.syncImmediate(context.blockNumber);
+                const feePayers = pool.getPendingFeePayers();
+                return await this.evictForFeePayers(feePayers, this.worldState.getSnapshot(context.blockNumber), pool);
+            }
+            return {
+                reason: this.reason,
+                success: true,
+                txsEvicted: []
+            };
+        } catch (err) {
+            this.log.error('Failed to evict txs due to fee payer balance', {
+                err
+            });
+            return {
+                reason: this.reason,
+                success: false,
+                txsEvicted: [],
+                error: new Error('Failed to evict txs due to fee payer balance', {
+                    cause: err
+                })
+            };
+        }
+    }
+    async evictForFeePayers(feePayers, db, pool) {
+        const publicStateSource = new DatabasePublicStateSource(db);
+        const txsToEvict = (await Promise.all(feePayers.map((feePayer)=>this.getEvictionsForFeePayer(feePayer, publicStateSource, pool)))).flat();
+        if (txsToEvict.length > 0) {
+            await pool.deleteTxs(txsToEvict);
+        }
+        return {
+            reason: this.reason,
+            success: true,
+            txsEvicted: txsToEvict
+        };
+    }
+    async getEvictionsForFeePayer(feePayerStr, publicStateSource, pool) {
+        const feePayer = AztecAddress.fromString(feePayerStr);
+        const initialBalance = (await publicStateSource.storageRead(ProtocolContractAddress.FeeJuice, await computeFeePayerBalanceStorageSlot(feePayer))).toBigInt();
+        const txs = pool.getFeePayerPendingTxs(feePayerStr);
+        if (txs.length === 0) {
+            return [];
+        }
+        const txsToEvict = [];
+        let balance = initialBalance;
+        // Sort by priority descending (highest first), with hash as tiebreaker
+        txs.sort((a, b)=>comparePriority(b, a));
+        for (const tx of txs){
+            const available = balance + tx.claimAmount;
+            if (available >= tx.feeLimit) {
+                balance = available - tx.feeLimit;
+                continue;
+            }
+            // This tx cannot be covered - mark for eviction
+            txsToEvict.push(tx.txHash);
+        }
+        return txsToEvict;
+    }
+}

package/dest/mem_pools/tx_pool_v2/eviction/fee_payer_balance_pre_add_rule.d.ts

@@ -0,0 +1,19 @@
+import { type TxMetaData } from '../tx_metadata.js';
+import type { PreAddPoolAccess, PreAddResult, PreAddRule } from './interfaces.js';
+/**
+ * Pre-add rule that checks if a fee payer has sufficient balance to cover the incoming transaction.
+ *
+ * When an incoming tx is added:
+ * - Get the fee payer's on-chain balance
+ * - Get all existing pending txs for this fee payer
+ * - Insert incoming tx in priority order
+ * - Walk through in priority order, tracking running balance
+ * - If incoming tx can be covered: accept, mark lower-priority txs for eviction if needed
+ * - If incoming tx cannot be covered: ignore it
+ */
+export declare class FeePayerBalancePreAddRule implements PreAddRule {
+    readonly name = "FeePayerBalancePreAdd";
+    private log;
+    check(incomingMeta: TxMetaData, poolAccess: PreAddPoolAccess): Promise<PreAddResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmVlX3BheWVyX2JhbGFuY2VfcHJlX2FkZF9ydWxlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbWVtX3Bvb2xzL3R4X3Bvb2xfdjIvZXZpY3Rpb24vZmVlX3BheWVyX2JhbGFuY2VfcHJlX2FkZF9ydWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxLQUFLLFVBQVUsRUFBbUIsTUFBTSxtQkFBbUIsQ0FBQztBQUNyRSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxZQUFZLEVBQUUsVUFBVSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFbEY7Ozs7Ozs7Ozs7R0FVRztBQUNILHFCQUFhLHlCQUEwQixZQUFXLFVBQVU7SUFDMUQsU0FBZ0IsSUFBSSwyQkFBMkI7SUFFL0MsT0FBTyxDQUFDLEdBQUcsQ0FBaUU7SUFFdEUsS0FBSyxDQUFDLFlBQVksRUFBRSxVQUFVLEVBQUUsVUFBVSxFQUFFLGdCQUFnQixHQUFHLE9BQU8sQ0FBQyxZQUFZLENBQUMsQ0F3RnpGO0NBQ0YifQ==

package/dest/mem_pools/tx_pool_v2/eviction/fee_payer_balance_pre_add_rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fee_payer_balance_pre_add_rule.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/eviction/fee_payer_balance_pre_add_rule.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,UAAU,EAAmB,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElF;;;;;;;;;;GAUG;AACH,qBAAa,yBAA0B,YAAW,UAAU;IAC1D,SAAgB,IAAI,2BAA2B;IAE/C,OAAO,CAAC,GAAG,CAAiE;IAEtE,KAAK,CAAC,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CAwFzF;CACF"}

package/dest/mem_pools/tx_pool_v2/eviction/fee_payer_balance_pre_add_rule.js

@@ -0,0 +1,89 @@
+import { createLogger } from '@aztec/foundation/log';
+import { comparePriority } from '../tx_metadata.js';
+/**
+ * Pre-add rule that checks if a fee payer has sufficient balance to cover the incoming transaction.
+ *
+ * When an incoming tx is added:
+ * - Get the fee payer's on-chain balance
+ * - Get all existing pending txs for this fee payer
+ * - Insert incoming tx in priority order
+ * - Walk through in priority order, tracking running balance
+ * - If incoming tx can be covered: accept, mark lower-priority txs for eviction if needed
+ * - If incoming tx cannot be covered: ignore it
+ */ export class FeePayerBalancePreAddRule {
+    name = 'FeePayerBalancePreAdd';
+    log = createLogger('p2p:tx_pool_v2:fee_payer_balance_pre_add_rule');
+    async check(incomingMeta, poolAccess) {
+        // Get fee payer's on-chain balance
+        const initialBalance = await poolAccess.getFeePayerBalance(incomingMeta.feePayer);
+        // Get existing pending txs for this fee payer
+        const existingTxs = poolAccess.getFeePayerPendingTxs(incomingMeta.feePayer);
+        // Create combined list with incoming tx
+        const allTxs = [
+            ...existingTxs.map((t)=>({
+                    txHash: t.txHash,
+                    priorityFee: t.priorityFee,
+                    feeLimit: t.feeLimit,
+                    claimAmount: t.claimAmount,
+                    isIncoming: false
+                })),
+            {
+                txHash: incomingMeta.txHash,
+                priorityFee: incomingMeta.priorityFee,
+                feeLimit: incomingMeta.feeLimit,
+                claimAmount: incomingMeta.claimAmount,
+                isIncoming: true
+            }
+        ];
+        // Sort by priority descending (highest first), with hash as tiebreaker
+        allTxs.sort((a, b)=>comparePriority(b, a));
+        // Walk through in priority order, tracking balance
+        let balance = initialBalance;
+        let incomingTxCovered = false;
+        const txsToEvict = [];
+        for (const txInfo of allTxs){
+            const available = balance + txInfo.claimAmount;
+            if (available >= txInfo.feeLimit) {
+                // This tx can be covered
+                balance = available - txInfo.feeLimit;
+                if (txInfo.isIncoming) {
+                    incomingTxCovered = true;
+                }
+            } else {
+                // This tx cannot be covered
+                if (txInfo.isIncoming) {
+                    // Incoming tx cannot be covered - ignore it
+                    this.log.debug(`Ignoring tx ${incomingMeta.txHash}: fee payer ${incomingMeta.feePayer} has insufficient balance`, {
+                        balance: initialBalance,
+                        feeLimit: incomingMeta.feeLimit,
+                        claimAmount: incomingMeta.claimAmount
+                    });
+                    return {
+                        shouldIgnore: true,
+                        txHashesToEvict: [],
+                        reason: `fee payer ${incomingMeta.feePayer} has insufficient balance`
+                    };
+                } else {
+                    // Existing tx cannot be covered after adding incoming - mark for eviction
+                    txsToEvict.push(txInfo.txHash);
+                }
+            }
+        }
+        if (!incomingTxCovered) {
+            // This shouldn't happen if the logic above is correct, but just in case
+            this.log.warn(`Incoming tx ${incomingMeta.txHash} was not covered but also not ignored - this is a bug`);
+            return {
+                shouldIgnore: true,
+                txHashesToEvict: [],
+                reason: 'internal error: tx coverage not determined'
+            };
+        }
+        if (txsToEvict.length > 0) {
+            this.log.debug(`Accepting tx ${incomingMeta.txHash}, evicting ${txsToEvict.length} lower-priority txs due to fee payer balance`);
+        }
+        return {
+            shouldIgnore: false,
+            txHashesToEvict: txsToEvict
+        };
+    }
+}

package/dest/mem_pools/tx_pool_v2/eviction/index.d.ts

@@ -0,0 +1,10 @@
+export { EvictionManager } from './eviction_manager.js';
+export { type EvictionConfig, type EvictionContext, EvictionEvent, type EvictionResult, type EvictionRule, type PoolOperations, type PreAddPoolAccess, type PreAddResult, type PreAddRule, } from './interfaces.js';
+export { NullifierConflictRule } from './nullifier_conflict_rule.js';
+export { FeePayerBalancePreAddRule } from './fee_payer_balance_pre_add_rule.js';
+export { LowPriorityPreAddRule } from './low_priority_pre_add_rule.js';
+export { InvalidTxsAfterMiningRule } from './invalid_txs_after_mining_rule.js';
+export { InvalidTxsAfterReorgRule } from './invalid_txs_after_reorg_rule.js';
+export { FeePayerBalanceEvictionRule } from './fee_payer_balance_eviction_rule.js';
+export { LowPriorityEvictionRule } from './low_priority_eviction_rule.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvdHhfcG9vbF92Mi9ldmljdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDeEQsT0FBTyxFQUNMLEtBQUssY0FBYyxFQUNuQixLQUFLLGVBQWUsRUFDcEIsYUFBYSxFQUNiLEtBQUssY0FBYyxFQUNuQixLQUFLLFlBQVksRUFDakIsS0FBSyxjQUFjLEVBQ25CLEtBQUssZ0JBQWdCLEVBQ3JCLEtBQUssWUFBWSxFQUNqQixLQUFLLFVBQVUsR0FDaEIsTUFBTSxpQkFBaUIsQ0FBQztBQUd6QixPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUNyRSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUNoRixPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUd2RSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUMvRSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUM3RSxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUNuRixPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQyJ9

package/dest/mem_pools/tx_pool_v2/eviction/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/eviction/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,aAAa,EACb,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,UAAU,GAChB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAChF,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAGvE,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC"}

package/dest/mem_pools/tx_pool_v2/eviction/index.js

@@ -0,0 +1,11 @@
+export { EvictionManager } from './eviction_manager.js';
+export { EvictionEvent } from './interfaces.js';
+// Pre-add rules
+export { NullifierConflictRule } from './nullifier_conflict_rule.js';
+export { FeePayerBalancePreAddRule } from './fee_payer_balance_pre_add_rule.js';
+export { LowPriorityPreAddRule } from './low_priority_pre_add_rule.js';
+// Post-event eviction rules
+export { InvalidTxsAfterMiningRule } from './invalid_txs_after_mining_rule.js';
+export { InvalidTxsAfterReorgRule } from './invalid_txs_after_reorg_rule.js';
+export { FeePayerBalanceEvictionRule } from './fee_payer_balance_eviction_rule.js';
+export { LowPriorityEvictionRule } from './low_priority_eviction_rule.js';