@aztec/p2p 0.0.1-commit.fce3e4f → 0.0.1-commit.ff7989d6c

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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1 @@
+{"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"}

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

@@ -0,0 +1,112 @@
+import { findIndexInSortedArray, insertIntoSortedArray } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { EvictionEvent } from './eviction_strategy.js';
+export class EvictionManager {
+    txPool;
+    log;
+    rules;
+    /** Pre-add eviction rules (run inside addTxs transaction) */ preAddRules;
+    constructor(txPool, log = createLogger('p2p:mempool:tx_pool:eviction_manager')){
+        this.txPool = txPool;
+        this.log = log;
+        this.rules = [];
+        this.preAddRules = [];
+    }
+    async evictAfterNewTxs(newTxs, feePayers) {
+        const ctx = {
+            event: EvictionEvent.TXS_ADDED,
+            newTxs,
+            feePayers
+        };
+        await this.runEvictionRules(ctx);
+    }
+    async evictAfterNewBlock(block, newNullifiers, minedFeePayers) {
+        const ctx = {
+            event: EvictionEvent.BLOCK_MINED,
+            block,
+            newNullifiers,
+            feePayers: minedFeePayers
+        };
+        await this.runEvictionRules(ctx);
+    }
+    async evictAfterChainPrune(blockNumber) {
+        const ctx = {
+            event: EvictionEvent.CHAIN_PRUNED,
+            blockNumber
+        };
+        await this.runEvictionRules(ctx);
+    }
+    /**
+   * 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
+   */ async runPreAddRules(tx, poolAccess) {
+        const allTxHashesToEvict = [];
+        const cmpTxHash = (a, b)=>Fr.cmp(a.hash, b.hash);
+        for (const rule of this.preAddRules){
+            try {
+                const result = await rule.check(tx, poolAccess);
+                if (result.shouldReject) {
+                    return {
+                        shouldReject: true,
+                        txHashesToEvict: [],
+                        reason: result.reason
+                    };
+                }
+                for (const txHashToEvict of result.txHashesToEvict){
+                    // Only add if not already present (dedup)
+                    if (findIndexInSortedArray(allTxHashesToEvict, txHashToEvict, cmpTxHash) === -1) {
+                        insertIntoSortedArray(allTxHashesToEvict, txHashToEvict, cmpTxHash);
+                    }
+                }
+            } catch (err) {
+                this.log.warn(`Pre-add eviction rule ${rule.name} unexpected error: ${String(err)}`, {
+                    err,
+                    preAddRule: rule.name
+                });
+                // On error, reject the tx to be safe
+                return {
+                    shouldReject: true,
+                    txHashesToEvict: [],
+                    reason: `rule error: ${String(err)}`
+                };
+            }
+        }
+        return {
+            shouldReject: false,
+            txHashesToEvict: allTxHashesToEvict
+        };
+    }
+    registerRule(rule) {
+        this.rules.push(rule);
+    }
+    registerPreAddRule(rule) {
+        this.preAddRules.push(rule);
+    }
+    updateConfig(config) {
+        for (const rule of this.rules){
+            rule.updateConfig(config);
+        }
+        for (const rule of this.preAddRules){
+            rule.updateConfig?.(config);
+        }
+    }
+    async runEvictionRules(ctx) {
+        for (const rule of this.rules){
+            try {
+                await rule.evict(ctx, this.txPool);
+            } catch (err) {
+                this.log.warn(`Eviction rule ${rule.name} unexpected error: ${String(err)}`, {
+                    err,
+                    evictionRule: rule.name,
+                    evictionEvent: ctx.event
+                });
+            }
+        }
+    }
+}

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

@@ -0,0 +1,157 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type BlockHeader, type Tx, TxHash } from '@aztec/stdlib/tx';
+import type { TxPoolOptions } from '../tx_pool.js';
+export declare const EvictionEvent: {
+    readonly TXS_ADDED: "txs_added";
+    readonly BLOCK_MINED: "block_mined";
+    readonly CHAIN_PRUNED: "chain_pruned";
+};
+type EvictionEvent = (typeof EvictionEvent)[keyof typeof EvictionEvent];
+export type EvictionContext = {
+    event: typeof EvictionEvent.TXS_ADDED;
+    newTxs: TxHash[];
+    feePayers: AztecAddress[];
+} | {
+    event: typeof EvictionEvent.CHAIN_PRUNED;
+    blockNumber: BlockNumber;
+} | {
+    event: typeof EvictionEvent.BLOCK_MINED;
+    block: BlockHeader;
+    newNullifiers: Fr[];
+    feePayers: AztecAddress[];
+};
+/**
+ * Result of an eviction operation
+ */
+export interface EvictionResult {
+    readonly txsEvicted: TxHash[];
+    readonly reason: string;
+    readonly success: boolean;
+    readonly error?: Error;
+}
+/**
+ * Information about a pending transaction
+ */
+export interface PendingTxInfo {
+    txHash: TxHash;
+    blockHash: Fr;
+    isEvictable: boolean;
+}
+/**
+ * Information about a transaction that references a specific block
+ */
+export interface TxBlockReference {
+    txHash: TxHash;
+    blockHash: Fr;
+    isEvictable: boolean;
+}
+/**
+ * Operations that eviction strategies can perform on the pool
+ */
+export interface TxPoolOperations {
+    getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
+    getPendingTxInfos(): Promise<PendingTxInfo[]>;
+    getPendingTxsReferencingBlocks(blockHashes: Fr[]): Promise<TxBlockReference[]>;
+    getPendingFeePayers(): Promise<AztecAddress[]>;
+    getFeePayerTxInfos(feePayer: AztecAddress): AsyncIterable<FeePayerTxInfo>;
+    /** Cheap count of current pending transactions. */
+    getPendingTxCount(): Promise<number>;
+    /**
+     * Returns up to `limit` lowest-priority evictable pending tx hashes.
+     * Ordering should be from lowest priority upwards.
+     */
+    getLowestPriorityEvictable(limit: number): Promise<TxHash[]>;
+    deleteTxs(txHashes: TxHash[], opts?: {
+        permanently?: boolean;
+    }): Promise<void>;
+}
+/**
+ * Strategy interface for different eviction behaviors
+ */
+export interface EvictionRule {
+    readonly name: string;
+    /**
+     * Performs the eviction logic
+     */
+    evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult>;
+    /**
+     * Updates the configuration for this eviction rule.
+     * Rules should ignore config options that don't apply to them.
+     */
+    updateConfig(config: TxPoolOptions): void;
+}
+/**
+ * Balance-related information about a transaction for a fee payer.
+ */
+export declare class FeePayerTxInfo {
+    txHash: TxHash;
+    priority: bigint;
+    feeLimit: bigint;
+    claimAmount: bigint;
+    isEvictable: boolean;
+    constructor(fields: {
+        txHash: TxHash;
+        priority: bigint;
+        feeLimit: bigint;
+        claimAmount: bigint;
+        isEvictable: boolean;
+    });
+    static encode(tx: Tx, txHash: string | TxHash): Promise<Buffer>;
+    static decode(value: Buffer, isEvictable?: boolean): FeePayerTxInfo;
+}
+/**
+ * Read-only access to pool state for pre-add eviction checks.
+ * Passed to pre-add rules during the addTxs transaction.
+ */
+export interface PreAddPoolAccess {
+    /**
+     * Get the pending tx hash that uses a specific nullifier, if any.
+     * Returns undefined if no pending tx uses this nullifier.
+     */
+    getTxHashByNullifier(nullifier: Fr): Promise<TxHash | undefined>;
+    /**
+     * Get a pending transaction by its hash.
+     */
+    getPendingTxByHash(hash: TxHash): Promise<Tx | undefined>;
+    /**
+     * Get the priority string for a transaction (for fee comparison).
+     */
+    getTxPriority(tx: Tx): string;
+}
+/**
+ * Result of a pre-add eviction check for a single transaction.
+ */
+export interface PreAddEvictionResult {
+    /** Whether the incoming tx should be rejected */
+    readonly shouldReject: boolean;
+    /** Sorted array of existing tx hashes that should be evicted if this tx is added */
+    readonly txHashesToEvict: TxHash[];
+    /** Optional reason for rejection */
+    readonly reason?: string;
+}
+/**
+ * Strategy interface for pre-add eviction rules.
+ * These run inside the addTxs transaction before a tx is added,
+ * deciding whether to evict existing txs or reject the incoming tx.
+ */
+export interface PreAddEvictionRule {
+    readonly name: string;
+    /**
+     * Check if incoming tx should be added and which existing txs to evict.
+     * Called inside the addTxs database transaction for atomicity.
+     *
+     * @param tx - The incoming transaction to check
+     * @param poolAccess - Read-only access to current pool state
+     * @returns Result indicating whether to reject and what to evict
+     */
+    check(tx: Tx, poolAccess: PreAddPoolAccess): Promise<PreAddEvictionResult>;
+    /**
+     * Updates the configuration for this rule.
+     * Rules should ignore config options that don't apply to them.
+     */
+    updateConfig?(config: TxPoolOptions): void;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"eviction_strategy.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool/eviction/eviction_strategy.ts"],"names":[],"mappings":"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"}

package/dest/mem_pools/tx_pool/eviction/eviction_strategy.js

@@ -0,0 +1,52 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { TxHash } from '@aztec/stdlib/tx';
+import { getFeePayerBalanceDelta } from '../../../msg_validators/tx_validator/fee_payer_balance.js';
+import { getTxPriorityFee } from '../priority.js';
+export const EvictionEvent = {
+    TXS_ADDED: 'txs_added',
+    BLOCK_MINED: 'block_mined',
+    CHAIN_PRUNED: 'chain_pruned'
+};
+/**
+ * Balance-related information about a transaction for a fee payer.
+ */ export class FeePayerTxInfo {
+    txHash;
+    priority;
+    feeLimit;
+    claimAmount;
+    isEvictable;
+    constructor(fields){
+        this.txHash = fields.txHash;
+        this.priority = fields.priority;
+        this.feeLimit = fields.feeLimit;
+        this.claimAmount = fields.claimAmount;
+        this.isEvictable = fields.isEvictable;
+    }
+    static async encode(tx, txHash) {
+        const { feeLimit, claimAmount } = await getFeePayerBalanceDelta(tx, ProtocolContractAddress.FeeJuice);
+        const priority = Buffer32.fromBigInt(getTxPriorityFee(tx)).toBuffer();
+        const hashBuffer = (typeof txHash === 'string' ? TxHash.fromString(txHash) : txHash).toBuffer();
+        const feeLimitBuffer = Buffer32.fromBigInt(feeLimit).toBuffer();
+        const claimAmountBuffer = Buffer32.fromBigInt(claimAmount).toBuffer();
+        return Buffer.concat([
+            priority,
+            hashBuffer,
+            feeLimitBuffer,
+            claimAmountBuffer
+        ]);
+    }
+    static decode(value, isEvictable = true) {
+        const priority = Buffer32.fromBuffer(value.subarray(0, Buffer32.SIZE)).toBigInt();
+        const hashOffset = Buffer32.SIZE;
+        const feeLimitOffset = hashOffset + TxHash.SIZE;
+        const claimOffset = feeLimitOffset + Buffer32.SIZE;
+        return new FeePayerTxInfo({
+            txHash: TxHash.fromBuffer(value.subarray(hashOffset, feeLimitOffset)),
+            priority,
+            feeLimit: Buffer32.fromBuffer(value.subarray(feeLimitOffset, claimOffset)).toBigInt(),
+            claimAmount: Buffer32.fromBuffer(value.subarray(claimOffset, claimOffset + Buffer32.SIZE)).toBigInt(),
+            isEvictable
+        });
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { TxPoolOptions } from '../tx_pool.js';
+import { type EvictionContext, type EvictionResult, type EvictionRule, type TxPoolOperations } from './eviction_strategy.js';
+export declare class FeePayerBalanceEvictionRule implements EvictionRule {
+    private worldState;
+    readonly name = "FeePayerBalanceEviction";
+    readonly reason = "fee_payer_balance";
+    private log;
+    constructor(worldState: WorldStateSynchronizer);
+    evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult>;
+    updateConfig(_config: TxPoolOptions): void;
+    private evictForFeePayers;
+    private getEvictionsForFeePayer;
+    private createPublicStateSource;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmVlX3BheWVyX2JhbGFuY2VfZXZpY3Rpb25fcnVsZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21lbV9wb29scy90eF9wb29sL2V2aWN0aW9uL2ZlZV9wYXllcl9iYWxhbmNlX2V2aWN0aW9uX3J1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsT0FBTyxLQUFLLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUk5RSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDbkQsT0FBTyxFQUNMLEtBQUssZUFBZSxFQUVwQixLQUFLLGNBQWMsRUFDbkIsS0FBSyxZQUFZLEVBRWpCLEtBQUssZ0JBQWdCLEVBQ3RCLE1BQU0sd0JBQXdCLENBQUM7QUFFaEMscUJBQWEsMkJBQTRCLFlBQVcsWUFBWTtJQU1sRCxPQUFPLENBQUMsVUFBVTtJQUw5QixTQUFnQixJQUFJLDZCQUE2QjtJQUNqRCxTQUFnQixNQUFNLHVCQUF1QjtJQUU3QyxPQUFPLENBQUMsR0FBRyxDQUF1RTtJQUVsRixZQUFvQixVQUFVLEVBQUUsc0JBQXNCLEVBQUk7SUFFcEQsS0FBSyxDQUFDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxFQUFFLGdCQUFnQixHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0E4Q3ZGO0lBRUQsWUFBWSxDQUFDLE9BQU8sRUFBRSxhQUFhLEdBQUcsSUFBSSxDQUFHO1lBRS9CLGlCQUFpQjtZQXNCakIsdUJBQXVCO0lBNERyQyxPQUFPLENBQUMsdUJBQXVCO0NBR2hDIn0=

package/dest/mem_pools/tx_pool/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/eviction/fee_payer_balance_eviction_rule.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAI9E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,cAAc,EACnB,KAAK,YAAY,EAEjB,KAAK,gBAAgB,EACtB,MAAM,wBAAwB,CAAC;AAEhC,qBAAa,2BAA4B,YAAW,YAAY;IAMlD,OAAO,CAAC,UAAU;IAL9B,SAAgB,IAAI,6BAA6B;IACjD,SAAgB,MAAM,uBAAuB;IAE7C,OAAO,CAAC,GAAG,CAAuE;IAElF,YAAoB,UAAU,EAAE,sBAAsB,EAAI;IAEpD,KAAK,CAAC,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC,CA8CvF;IAED,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAAG;YAE/B,iBAAiB;YAsBjB,uBAAuB;IA4DrC,OAAO,CAAC,uBAAuB;CAGhC"}

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

@@ -0,0 +1,122 @@
+import { createLogger } from '@aztec/foundation/log';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
+import { DatabasePublicStateSource } from '@aztec/stdlib/trees';
+import { EvictionEvent } from './eviction_strategy.js';
+export class FeePayerBalanceEvictionRule {
+    worldState;
+    name;
+    reason;
+    log;
+    constructor(worldState){
+        this.worldState = worldState;
+        this.name = 'FeePayerBalanceEviction';
+        this.reason = 'fee_payer_balance';
+        this.log = createLogger('p2p:mempool:tx_pool:fee_payer_balance_eviction_rule');
+    }
+    async evict(context, txPool) {
+        try {
+            if (context.event === EvictionEvent.TXS_ADDED) {
+                return await this.evictForFeePayers(context.feePayers, this.worldState.getCommitted(), txPool);
+            }
+            if (context.event === EvictionEvent.BLOCK_MINED) {
+                const blockNumber = context.block.getBlockNumber();
+                // Ensure world state is synced to this block before accessing the snapshot.
+                // This handles the race where a block is added to the archiver
+                // but the world state hasn't synced it yet.
+                await this.worldState.syncImmediate(blockNumber);
+                return await this.evictForFeePayers(context.feePayers, this.worldState.getSnapshot(blockNumber), txPool);
+            }
+            // TODO: fix this edge-case
+            // This can lead to a race condition if we are catching up in the p2p client.
+            // Let's say we have 3 txs for the same fee payer, which get mined in blocks 1, 2, 3.
+            // Tx1 consumes fee juice, tx2 increases it, tx3 consumes it again. We see block1 with tx1 first, run this rule, and evict tx3.
+            // But tx3 was valid (due to tx2) and mined on block3. And we have just removed from the mempool a tx we needed for proving/reexec.
+            //
+            // NOTE: this will happen only in case of that lower-priority-fee tx entered in e.g. block 2, and we have higher-priority-fee tx in block 3
+            // (simply because that was the timing of these txs). But, in case of higher-priority-fee txs being in block 2, the tx3 won't be evicted
+            // -----
+            // Proposed fix: evict only if node is synched
+            if (context.event === EvictionEvent.CHAIN_PRUNED) {
+                // Ensure world state is synced to this block before accessing the snapshot.
+                await this.worldState.syncImmediate(context.blockNumber);
+                const feePayers = await txPool.getPendingFeePayers();
+                return await this.evictForFeePayers(feePayers, this.worldState.getSnapshot(context.blockNumber), txPool);
+            }
+            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
+                })
+            };
+        }
+    }
+    updateConfig(_config) {}
+    async evictForFeePayers(feePayers, db, txPool) {
+        const publicStateSource = this.createPublicStateSource(db);
+        const txsToEvict = (await Promise.all(feePayers.map((feePayer)=>this.getEvictionsForFeePayer(feePayer, publicStateSource, txPool)))).flat();
+        if (txsToEvict.length > 0) {
+            await txPool.deleteTxs(txsToEvict);
+        }
+        return {
+            reason: this.reason,
+            success: true,
+            txsEvicted: txsToEvict
+        };
+    }
+    async getEvictionsForFeePayer(feePayer, publicStateSource, txPool) {
+        const initialBalance = (await publicStateSource.storageRead(ProtocolContractAddress.FeeJuice, //TODO: cache this LRU-style
+        await computeFeePayerBalanceStorageSlot(feePayer))).toBigInt();
+        const txs = [];
+        for await (const entry of txPool.getFeePayerTxInfos(feePayer)){
+            txs.push(entry);
+        }
+        if (txs.length === 0) {
+            return [];
+        }
+        const txsToEvict = [];
+        let balance = initialBalance;
+        let hasNonEvictableOverBalance = false;
+        // Evaluate balance in priority order so later claims cannot fund earlier spends.
+        // This sorts so that higher priority txs come first.
+        txs.sort((a, b)=>{
+            if (a.priority === b.priority) {
+                return a.txHash.toBigInt() >= b.txHash.toBigInt() ? -1 : 1;
+            }
+            return a.priority > b.priority ? -1 : 1;
+        });
+        for (const tx of txs){
+            const available = balance + tx.claimAmount;
+            if (available >= tx.feeLimit) {
+                balance = available - tx.feeLimit;
+                continue;
+            }
+            if (tx.isEvictable) {
+                txsToEvict.push(tx.txHash);
+            } else {
+                hasNonEvictableOverBalance = true;
+            }
+        }
+        if (hasNonEvictableOverBalance) {
+            this.log.verbose('Fee payer balance cannot be satisfied due to non-evictable txs', {
+                feePayer: feePayer.toString(),
+                balance: initialBalance
+            });
+        }
+        return txsToEvict;
+    }
+    createPublicStateSource(db) {
+        return new DatabasePublicStateSource(db);
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { TxPoolOptions } from '../tx_pool.js';
+import { type EvictionContext, type EvictionResult, type EvictionRule, type TxPoolOperations } from './eviction_strategy.js';
+/**
+ * Eviction rule that removes invalid transactions after a block is mined.
+ * Only triggers on BLOCK_MINED events.
+ *
+ * Eviction criteria includes:
+ * - Transactions with nullifiers that are already included in the mined block
+ * - Transactions with an expiration timestamp less than or equal to the mined block timestamp
+ */
+export declare class InvalidTxsAfterMiningRule implements EvictionRule {
+    readonly name = "InvalidTxsAfterMining";
+    private log;
+    evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult>;
+    updateConfig(_config: TxPoolOptions): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW52YWxpZF90eHNfYWZ0ZXJfbWluaW5nX3J1bGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvdHhfcG9vbC9ldmljdGlvbi9pbnZhbGlkX3R4c19hZnRlcl9taW5pbmdfcnVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDbkQsT0FBTyxFQUNMLEtBQUssZUFBZSxFQUVwQixLQUFLLGNBQWMsRUFDbkIsS0FBSyxZQUFZLEVBQ2pCLEtBQUssZ0JBQWdCLEVBQ3RCLE1BQU0sd0JBQXdCLENBQUM7QUFFaEM7Ozs7Ozs7R0FPRztBQUNILHFCQUFhLHlCQUEwQixZQUFXLFlBQVk7SUFDNUQsU0FBZ0IsSUFBSSwyQkFBMkI7SUFFL0MsT0FBTyxDQUFDLEdBQUcsQ0FBcUU7SUFFMUUsS0FBSyxDQUFDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxFQUFFLGdCQUFnQixHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0EyRXZGO0lBRUQsWUFBWSxDQUFDLE9BQU8sRUFBRSxhQUFhLEdBQUcsSUFBSSxDQUFHO0NBQzlDIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"invalid_txs_after_mining_rule.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool/eviction/invalid_txs_after_mining_rule.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACtB,MAAM,wBAAwB,CAAC;AAEhC;;;;;;;GAOG;AACH,qBAAa,yBAA0B,YAAW,YAAY;IAC5D,SAAgB,IAAI,2BAA2B;IAE/C,OAAO,CAAC,GAAG,CAAqE;IAE1E,KAAK,CAAC,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC,CA2EvF;IAED,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAAG;CAC9C"}

package/dest/mem_pools/tx_pool/eviction/invalid_txs_after_mining_rule.js

@@ -0,0 +1,84 @@
+import { createLogger } from '@aztec/foundation/log';
+import { EvictionEvent } from './eviction_strategy.js';
+/**
+ * Eviction rule that removes invalid transactions after a block is mined.
+ * Only triggers on BLOCK_MINED events.
+ *
+ * Eviction criteria includes:
+ * - Transactions with nullifiers that are already included in the mined block
+ * - Transactions with an expiration timestamp less than or equal to the mined block timestamp
+ */ export class InvalidTxsAfterMiningRule {
+    name = 'InvalidTxsAfterMining';
+    log = createLogger('p2p:mempool:tx_pool:invalid_txs_after_mining_rule');
+    async evict(context, txPool) {
+        if (context.event !== EvictionEvent.BLOCK_MINED) {
+            return {
+                reason: 'block_mined_invalid_txs',
+                success: true,
+                txsEvicted: []
+            };
+        }
+        if (!context.block || !context.newNullifiers) {
+            this.log.warn('Invalid context for block mined eviction', {
+                context
+            });
+            return {
+                reason: 'block_mined_invalid_txs',
+                success: false,
+                txsEvicted: [],
+                error: new Error('Invalid block mined context')
+            };
+        }
+        try {
+            const { timestamp } = context.block.globalVariables;
+            const txsToEvict = [];
+            const pendingTxs = await txPool.getPendingTxInfos();
+            const minedNullifiers = new Set(context.newNullifiers.map((n)=>n.toString()));
+            for (const { txHash, isEvictable } of pendingTxs){
+                if (!isEvictable) {
+                    continue;
+                }
+                const tx = await txPool.getTxByHash(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);
+                    continue;
+                }
+                // Evict pending txs with an expiration timestamp less than or equal to the mined block timestamp
+                const expirationTimestamp = tx.data.expirationTimestamp;
+                if (expirationTimestamp <= timestamp) {
+                    this.log.verbose(`Evicting tx ${txHash} from pool due to the tx being expired (expirationTimestamp: ${expirationTimestamp}, mined block timestamp: ${timestamp})`);
+                    txsToEvict.push(txHash);
+                    continue;
+                }
+            }
+            if (txsToEvict.length > 0) {
+                await txPool.deleteTxs(txsToEvict);
+            }
+            this.log.debug(`Evicted ${txsToEvict.length} invalid txs after block mined`);
+            return {
+                reason: 'block_mined_invalid_txs',
+                success: true,
+                txsEvicted: txsToEvict
+            };
+        } catch (err) {
+            this.log.error('Failed to evict invalid transactions after mining', {
+                err
+            });
+            return {
+                reason: 'block_mined_invalid_txs',
+                success: false,
+                txsEvicted: [],
+                error: new Error('Failed to evict invalid txs after mining', {
+                    cause: err
+                })
+            };
+        }
+    }
+    updateConfig(_config) {}
+}

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

@@ -0,0 +1,19 @@
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { TxPoolOptions } from '../tx_pool.js';
+import { type EvictionContext, type EvictionResult, type EvictionRule, type TxPoolOperations } from './eviction_strategy.js';
+/**
+ * Eviction rule that removes invalid transactions after a blockchain reorganization.
+ * Only triggers on CHAIN_PRUNED events.
+ *
+ * Eviction criteria includes:
+ * - Transactions that reference pruned block hashes (invalid by definition)
+ */
+export declare class InvalidTxsAfterReorgRule implements EvictionRule {
+    private worldState;
+    readonly name = "InvalidTxsAfterReorg";
+    private log;
+    constructor(worldState: WorldStateSynchronizer);
+    evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult>;
+    updateConfig(_config: TxPoolOptions): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW52YWxpZF90eHNfYWZ0ZXJfcmVvcmdfcnVsZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21lbV9wb29scy90eF9wb29sL2V2aWN0aW9uL2ludmFsaWRfdHhzX2FmdGVyX3Jlb3JnX3J1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxLQUFLLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUk5RSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDbkQsT0FBTyxFQUNMLEtBQUssZUFBZSxFQUVwQixLQUFLLGNBQWMsRUFDbkIsS0FBSyxZQUFZLEVBQ2pCLEtBQUssZ0JBQWdCLEVBQ3RCLE1BQU0sd0JBQXdCLENBQUM7QUFFaEM7Ozs7OztHQU1HO0FBQ0gscUJBQWEsd0JBQXlCLFlBQVcsWUFBWTtJQUt4QyxPQUFPLENBQUMsVUFBVTtJQUpyQyxTQUFnQixJQUFJLDBCQUEwQjtJQUU5QyxPQUFPLENBQUMsR0FBRyxDQUFvRTtJQUUvRSxZQUEyQixVQUFVLEVBQUUsc0JBQXNCLEVBQUk7SUFFM0QsS0FBSyxDQUFDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxFQUFFLGdCQUFnQixHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0EyRHZGO0lBRUQsWUFBWSxDQUFDLE9BQU8sRUFBRSxhQUFhLEdBQUcsSUFBSSxDQUFHO0NBQzlDIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"invalid_txs_after_reorg_rule.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool/eviction/invalid_txs_after_reorg_rule.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAI9E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACtB,MAAM,wBAAwB,CAAC;AAEhC;;;;;;GAMG;AACH,qBAAa,wBAAyB,YAAW,YAAY;IAKxC,OAAO,CAAC,UAAU;IAJrC,SAAgB,IAAI,0BAA0B;IAE9C,OAAO,CAAC,GAAG,CAAoE;IAE/E,YAA2B,UAAU,EAAE,sBAAsB,EAAI;IAE3D,KAAK,CAAC,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC,CA2DvF;IAED,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAAG;CAC9C"}