@aztec/p2p 3.0.0-rc.5 → 4.0.0-nightly.20260107

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

@@ -0,0 +1,18 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { BlockHeader, TxHash } from '@aztec/stdlib/tx';
+import type { TxPoolOptions } from '../tx_pool.js';
+import { type EvictionRule, type TxPoolOperations } from './eviction_strategy.js';
+export declare class EvictionManager {
+    private txPool;
+    private log;
+    private rules;
+    constructor(txPool: TxPoolOperations, log?: import("@aztec/foundation/log").Logger);
+    evictAfterNewTxs(newTxs: TxHash[]): Promise<void>;
+    evictAfterNewBlock(block: BlockHeader, newNullifiers: Fr[], minedFeePayers: AztecAddress[]): Promise<void>;
+    evictAfterChainPrune(blockNumber: number): Promise<void>;
+    registerRule(rule: EvictionRule): void;
+    updateConfig(config: TxPoolOptions): void;
+    private runEvictionRules;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZpY3Rpb25fbWFuYWdlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21lbV9wb29scy90eF9wb29sL2V2aWN0aW9uL2V2aWN0aW9uX21hbmFnZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXBELE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ2hFLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFdkQsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ25ELE9BQU8sRUFBdUMsS0FBSyxZQUFZLEVBQUUsS0FBSyxnQkFBZ0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRXZILHFCQUFhLGVBQWU7SUFJeEIsT0FBTyxDQUFDLE1BQU07SUFDZCxPQUFPLENBQUMsR0FBRztJQUpiLE9BQU8sQ0FBQyxLQUFLLENBQXNCO0lBRW5DLFlBQ1UsTUFBTSxFQUFFLGdCQUFnQixFQUN4QixHQUFHLHlDQUF1RCxFQUNoRTtJQUVTLGdCQUFnQixDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBTTdEO0lBRVksa0JBQWtCLENBQzdCLEtBQUssRUFBRSxXQUFXLEVBQ2xCLGFBQWEsRUFBRSxFQUFFLEVBQUUsRUFDbkIsY0FBYyxFQUFFLFlBQVksRUFBRSxHQUM3QixPQUFPLENBQUMsSUFBSSxDQUFDLENBU2Y7SUFFWSxvQkFBb0IsQ0FBQyxXQUFXLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FNcEU7SUFFTSxZQUFZLENBQUMsSUFBSSxFQUFFLFlBQVksUUFFckM7SUFFTSxZQUFZLENBQUMsTUFBTSxFQUFFLGFBQWEsR0FBRyxJQUFJLENBSS9DO1lBRWEsZ0JBQWdCO0NBYS9CIn0=

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":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAuC,KAAK,YAAY,EAAE,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAEvH,qBAAa,eAAe;IAIxB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,GAAG;IAJb,OAAO,CAAC,KAAK,CAAsB;IAEnC,YACU,MAAM,EAAE,gBAAgB,EACxB,GAAG,yCAAuD,EAChE;IAES,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAM7D;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,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAMpE;IAEM,YAAY,CAAC,IAAI,EAAE,YAAY,QAErC;IAEM,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAI/C;YAEa,gBAAgB;CAa/B"}

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

@@ -0,0 +1,56 @@
+import { createLogger } from '@aztec/foundation/log';
+import { EvictionEvent } from './eviction_strategy.js';
+export class EvictionManager {
+    txPool;
+    log;
+    rules;
+    constructor(txPool, log = createLogger('p2p:mempool:tx_pool:eviction_manager')){
+        this.txPool = txPool;
+        this.log = log;
+        this.rules = [];
+    }
+    async evictAfterNewTxs(newTxs) {
+        const ctx = {
+            event: EvictionEvent.TXS_ADDED,
+            newTxs
+        };
+        await this.runEvictionRules(ctx);
+    }
+    async evictAfterNewBlock(block, newNullifiers, minedFeePayers) {
+        const ctx = {
+            event: EvictionEvent.BLOCK_MINED,
+            block,
+            newNullifiers,
+            minedFeePayers
+        };
+        await this.runEvictionRules(ctx);
+    }
+    async evictAfterChainPrune(blockNumber) {
+        const ctx = {
+            event: EvictionEvent.CHAIN_PRUNED,
+            blockNumber
+        };
+        await this.runEvictionRules(ctx);
+    }
+    registerRule(rule) {
+        this.rules.push(rule);
+    }
+    updateConfig(config) {
+        for (const rule of this.rules){
+            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,83 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHeader, 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[];
+} | {
+    event: typeof EvictionEvent.CHAIN_PRUNED;
+    blockNumber: number;
+} | {
+    event: typeof EvictionEvent.BLOCK_MINED;
+    block: BlockHeader;
+    newNullifiers: Fr[];
+    minedFeePayers: 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[]>;
+    getPendingTxsWithFeePayer(feePayer: AztecAddress[]): Promise<PendingTxInfo[]>;
+    /** 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;
+}
+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":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAEhE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,eAAO,MAAM,aAAa;;;;CAIhB,CAAC;AAEX,KAAK,aAAa,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAExE,MAAM,MAAM,eAAe,GACvB;IACE,KAAK,EAAE,OAAO,aAAa,CAAC,SAAS,CAAC;IACtC,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,GACD;IACE,KAAK,EAAE,OAAO,aAAa,CAAC,YAAY,CAAC;IACzC,WAAW,EAAE,MAAM,CAAC;CACrB,GACD;IACE,KAAK,EAAE,OAAO,aAAa,CAAC,WAAW,CAAC;IACxC,KAAK,EAAE,WAAW,CAAC;IACnB,aAAa,EAAE,EAAE,EAAE,CAAC;IACpB,cAAc,EAAE,YAAY,EAAE,CAAC;CAChC,CAAC;AAEN;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,EAAE,CAAC;IACd,WAAW,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,EAAE,CAAC;IACd,WAAW,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC;IACrD,iBAAiB,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;IAC9C,8BAA8B,CAAC,WAAW,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAC/E,yBAAyB,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;IAC9E,mDAAmD;IACnD,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACrC;;;OAGG;IACH,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC7D,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAChF;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAEnF;;;OAGG;IACH,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAAC;CAC3C"}

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

@@ -0,0 +1,5 @@
+export const EvictionEvent = {
+    TXS_ADDED: 'txs_added',
+    BLOCK_MINED: 'block_mined',
+    CHAIN_PRUNED: 'chain_pruned'
+};

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

@@ -0,0 +1,15 @@
+import type { ReadonlyWorldStateAccess } 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 InsufficientFeePayerBalanceRule implements EvictionRule {
+    private worldState;
+    readonly name: string;
+    readonly reason: string;
+    constructor(worldState: ReadonlyWorldStateAccess);
+    private log;
+    evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult>;
+    private evictTxs;
+    private createGasTxValidator;
+    updateConfig(_config: TxPoolOptions): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zdWZmaWNpZW50X2ZlZV9wYXllcl9iYWxhbmNlX3J1bGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvdHhfcG9vbC9ldmljdGlvbi9pbnN1ZmZpY2llbnRfZmVlX3BheWVyX2JhbGFuY2VfcnVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEtBQUssRUFBRSx3QkFBd0IsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBS2hGLE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRCxPQUFPLEVBQ0wsS0FBSyxlQUFlLEVBRXBCLEtBQUssY0FBYyxFQUNuQixLQUFLLFlBQVksRUFFakIsS0FBSyxnQkFBZ0IsRUFDdEIsTUFBTSx3QkFBd0IsQ0FBQztBQUVoQyxxQkFBYSwrQkFBZ0MsWUFBVyxZQUFZO0lBSS9DLE9BQU8sQ0FBQyxVQUFVO0lBSHJDLFNBQWdCLElBQUksU0FBaUM7SUFDckQsU0FBZ0IsTUFBTSxTQUE0QjtJQUVsRCxZQUEyQixVQUFVLEVBQUUsd0JBQXdCLEVBQUk7SUFFbkUsT0FBTyxDQUFDLEdBQUcsQ0FBMkU7SUFFaEYsS0FBSyxDQUFDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxFQUFFLGdCQUFnQixHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FrQ3ZGO1lBRWEsUUFBUTtJQXdDdEIsT0FBTyxDQUFDLG9CQUFvQjtJQUk1QixZQUFZLENBQUMsT0FBTyxFQUFFLGFBQWEsR0FBRyxJQUFJLENBQUc7Q0FDOUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"insufficient_fee_payer_balance_rule.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool/eviction/insufficient_fee_payer_balance_rule.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAKhF,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,+BAAgC,YAAW,YAAY;IAI/C,OAAO,CAAC,UAAU;IAHrC,SAAgB,IAAI,SAAiC;IACrD,SAAgB,MAAM,SAA4B;IAElD,YAA2B,UAAU,EAAE,wBAAwB,EAAI;IAEnE,OAAO,CAAC,GAAG,CAA2E;IAEhF,KAAK,CAAC,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC,CAkCvF;YAEa,QAAQ;IAwCtB,OAAO,CAAC,oBAAoB;IAI5B,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAAG;CAC9C"}

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

@@ -0,0 +1,88 @@
+import { createLogger } from '@aztec/foundation/log';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { GasFees } from '@aztec/stdlib/gas';
+import { DatabasePublicStateSource } from '@aztec/stdlib/trees';
+import { GasTxValidator } from '../../../msg_validators/index.js';
+import { EvictionEvent } from './eviction_strategy.js';
+export class InsufficientFeePayerBalanceRule {
+    worldState;
+    name;
+    reason;
+    constructor(worldState){
+        this.worldState = worldState;
+        this.name = 'InsufficientFeePayerBalance';
+        this.reason = 'insufficient_fee_juice';
+        this.log = createLogger('p2p:mempool:tx_pool:insufficient_fee_payer_balance_rule');
+    }
+    log;
+    async evict(context, txPool) {
+        try {
+            if (context.event === EvictionEvent.CHAIN_PRUNED) {
+                const affectedTxs = await txPool.getPendingTxInfos();
+                return this.evictTxs(affectedTxs, context.blockNumber, txPool);
+            }
+            if (context.event === EvictionEvent.BLOCK_MINED) {
+                const affectedTxs = await txPool.getPendingTxsWithFeePayer(context.minedFeePayers);
+                // 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.
+                // -----
+                // Proposed fix: evict only if node is synched
+                return this.evictTxs(affectedTxs, context.block.getBlockNumber(), txPool);
+            }
+            return {
+                reason: this.reason,
+                success: true,
+                txsEvicted: []
+            };
+        } catch (err) {
+            this.log.error('Failed to evict invalid transactions after mining', {
+                err
+            });
+            return {
+                reason: this.reason,
+                success: false,
+                txsEvicted: [],
+                error: new Error('Failed to evict invalid txs after mining', {
+                    cause: err
+                })
+            };
+        }
+    }
+    async evictTxs(candidateTxs, blockNumber, txPool) {
+        const txsToEvict = [];
+        const gasValidator = this.createGasTxValidator(this.worldState.getSnapshot(blockNumber));
+        for (const { txHash, isEvictable } of candidateTxs){
+            if (!isEvictable) {
+                continue;
+            }
+            const tx = await txPool.getTxByHash(txHash);
+            if (!tx) {
+                continue;
+            }
+            this.log.debug(`Validating tx balance ${txHash}`);
+            if ((await gasValidator.validateTxFee(tx)).result === 'invalid') {
+                this.log.verbose(`Evicting tx ${txHash} from pool due to an insufficient fee payer balance`);
+                txsToEvict.push(txHash);
+                continue;
+            }
+        }
+        if (txsToEvict.length > 0) {
+            await txPool.deleteTxs(txsToEvict);
+        }
+        this.log.verbose(`Evicted ${txsToEvict.length} invalid txs after block mined`, {
+            txsToEvict
+        });
+        return {
+            reason: this.reason,
+            success: true,
+            txsEvicted: txsToEvict
+        };
+    }
+    createGasTxValidator(db) {
+        return new GasTxValidator(new DatabasePublicStateSource(db), ProtocolContractAddress.FeeJuice, GasFees.empty());
+    }
+    updateConfig(_config) {}
+}

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: string;
+    private log;
+    evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult>;
+    updateConfig(_config: TxPoolOptions): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW52YWxpZF90eHNfYWZ0ZXJfbWluaW5nX3J1bGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvdHhfcG9vbC9ldmljdGlvbi9pbnZhbGlkX3R4c19hZnRlcl9taW5pbmdfcnVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDbkQsT0FBTyxFQUNMLEtBQUssZUFBZSxFQUVwQixLQUFLLGNBQWMsRUFDbkIsS0FBSyxZQUFZLEVBQ2pCLEtBQUssZ0JBQWdCLEVBQ3RCLE1BQU0sd0JBQXdCLENBQUM7QUFFaEM7Ozs7Ozs7R0FPRztBQUNILHFCQUFhLHlCQUEwQixZQUFXLFlBQVk7SUFDNUQsU0FBZ0IsSUFBSSxTQUEyQjtJQUUvQyxPQUFPLENBQUMsR0FBRyxDQUFxRTtJQUUxRSxLQUFLLENBQUMsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLEVBQUUsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLGNBQWMsQ0FBQyxDQTJFdkY7SUFFRCxZQUFZLENBQUMsT0FBTyxFQUFFLGFBQWEsR0FBRyxJQUFJLENBQUc7Q0FDOUMifQ==

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,SAA2B;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 includeByTimestamp = tx.data.includeByTimestamp;
+                if (includeByTimestamp <= timestamp) {
+                    this.log.verbose(`Evicting tx ${txHash} from pool due to the tx being expired (includeByTimestamp: ${includeByTimestamp}, mined block timestamp: ${timestamp})`);
+                    txsToEvict.push(txHash);
+                    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 { ReadonlyWorldStateAccess } 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: string;
+    private log;
+    constructor(worldState: ReadonlyWorldStateAccess);
+    evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult>;
+    updateConfig(_config: TxPoolOptions): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW52YWxpZF90eHNfYWZ0ZXJfcmVvcmdfcnVsZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21lbV9wb29scy90eF9wb29sL2V2aWN0aW9uL2ludmFsaWRfdHhzX2FmdGVyX3Jlb3JnX3J1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxLQUFLLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUloRixPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDbkQsT0FBTyxFQUNMLEtBQUssZUFBZSxFQUVwQixLQUFLLGNBQWMsRUFDbkIsS0FBSyxZQUFZLEVBQ2pCLEtBQUssZ0JBQWdCLEVBQ3RCLE1BQU0sd0JBQXdCLENBQUM7QUFFaEM7Ozs7OztHQU1HO0FBQ0gscUJBQWEsd0JBQXlCLFlBQVcsWUFBWTtJQUt4QyxPQUFPLENBQUMsVUFBVTtJQUpyQyxTQUFnQixJQUFJLFNBQTBCO0lBRTlDLE9BQU8sQ0FBQyxHQUFHLENBQW9FO0lBRS9FLFlBQTJCLFVBQVUsRUFBRSx3QkFBd0IsRUFBSTtJQUU3RCxLQUFLLENBQUMsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLEVBQUUsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLGNBQWMsQ0FBQyxDQXlEdkY7SUFFRCxZQUFZLENBQUMsT0FBTyxFQUFFLGFBQWEsR0FBRyxJQUFJLENBQUc7Q0FDOUMifQ==

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,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAIhF,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,SAA0B;IAE9C,OAAO,CAAC,GAAG,CAAoE;IAE/E,YAA2B,UAAU,EAAE,wBAAwB,EAAI;IAE7D,KAAK,CAAC,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC,CAyDvF;IAED,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAAG;CAC9C"}

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

@@ -0,0 +1,76 @@
+import { findIndexInSortedArray, insertIntoSortedArray } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { EvictionEvent } 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 class InvalidTxsAfterReorgRule {
+    worldState;
+    name;
+    log;
+    constructor(worldState){
+        this.worldState = worldState;
+        this.name = 'InvalidTxsAfterReorg';
+        this.log = createLogger('p2p:mempool:tx_pool:invalid_txs_after_reorg_rule');
+    }
+    async evict(context, txPool) {
+        if (context.event !== EvictionEvent.CHAIN_PRUNED) {
+            return {
+                reason: 'reorg_invalid_txs',
+                success: true,
+                txsEvicted: []
+            };
+        }
+        try {
+            const candidateTxs = (await txPool.getPendingTxInfos()).filter(({ isEvictable })=>isEvictable);
+            // Deduplicate block hashes to reduce redundant DB lookups (many txs may share the same blockHash).
+            const uniqueBlockHashes = [];
+            candidateTxs.forEach(({ blockHash })=>{
+                insertIntoSortedArray(uniqueBlockHashes, blockHash, Fr.cmp, false);
+            });
+            const db = this.worldState.getSnapshot(context.blockNumber);
+            const blocksFromDb = await db.findLeafIndices(MerkleTreeId.ARCHIVE, uniqueBlockHashes);
+            // Identify txs whose blockHash is not found in the archive (pruned)
+            const txsToEvict = [];
+            for (const tx of candidateTxs){
+                const idx = findIndexInSortedArray(uniqueBlockHashes, tx.blockHash, Fr.cmp);
+                const blockPruned = idx === -1 || blocksFromDb[idx] === undefined;
+                if (blockPruned) {
+                    txsToEvict.push(tx.txHash);
+                }
+            }
+            if (txsToEvict.length > 0) {
+                this.log.verbose(`Evicting ${txsToEvict.length} txs from pool due to referencing pruned blocks`);
+                await txPool.deleteTxs(txsToEvict);
+            }
+            const keptCount = candidateTxs.length - txsToEvict.length;
+            if (keptCount > 0) {
+                this.log.verbose(`Kept ${keptCount} txs that did not reference pruned blocks`);
+            }
+            this.log.debug(`Evicted ${txsToEvict.length} invalid txs after reorg`);
+            return {
+                reason: 'reorg_invalid_txs',
+                success: true,
+                txsEvicted: txsToEvict
+            };
+        } catch (err) {
+            this.log.error('Failed to evict invalid transactions after reorg', {
+                err
+            });
+            return {
+                reason: 'reorg_invalid_txs',
+                success: false,
+                txsEvicted: [],
+                error: new Error('Failed to evict invalid txs after reorg', {
+                    cause: err
+                })
+            };
+        }
+    }
+    updateConfig(_config) {}
+}

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

@@ -0,0 +1,26 @@
+import type { TxPoolOptions } from '../tx_pool.js';
+import { type EvictionContext, type EvictionResult, type EvictionRule, type TxPoolOperations } from './eviction_strategy.js';
+export interface LowPriorityEvictionConfig {
+    /** Maximum number of pending transactions before eviction kicks in */
+    maxPoolSize: number;
+}
+/**
+ * Eviction rule that removes low-priority transactions when the number of pending transactions exceeds configured limits.
+ * Only triggers on TXS_ADDED events and respects non-evictable transactions.
+ */
+export declare class LowPriorityEvictionRule implements EvictionRule {
+    private config;
+    readonly name: string;
+    private log;
+    constructor(config: LowPriorityEvictionConfig);
+    evict(context: EvictionContext, txPool: TxPoolOperations): Promise<EvictionResult>;
+    /**
+     * Updates the configuration for this eviction rule
+     */
+    updateConfig(config: TxPoolOptions): void;
+    /**
+     * Gets the current configuration
+     */
+    getConfig(): LowPriorityEvictionConfig;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG93X3ByaW9yaXR5X2V2aWN0aW9uX3J1bGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvdHhfcG9vbC9ldmljdGlvbi9sb3dfcHJpb3JpdHlfZXZpY3Rpb25fcnVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDbkQsT0FBTyxFQUNMLEtBQUssZUFBZSxFQUVwQixLQUFLLGNBQWMsRUFDbkIsS0FBSyxZQUFZLEVBQ2pCLEtBQUssZ0JBQWdCLEVBQ3RCLE1BQU0sd0JBQXdCLENBQUM7QUFFaEMsTUFBTSxXQUFXLHlCQUF5QjtJQUN4QyxzRUFBc0U7SUFDdEUsV0FBVyxFQUFFLE1BQU0sQ0FBQztDQUNyQjtBQUVEOzs7R0FHRztBQUNILHFCQUFhLHVCQUF3QixZQUFXLFlBQVk7SUFLOUMsT0FBTyxDQUFDLE1BQU07SUFKMUIsU0FBZ0IsSUFBSSxTQUF5QjtJQUU3QyxPQUFPLENBQUMsR0FBRyxDQUFrRTtJQUU3RSxZQUFvQixNQUFNLEVBQUUseUJBQXlCLEVBQUk7SUFFNUMsS0FBSyxDQUFDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxFQUFFLGdCQUFnQixHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0E0RDlGO0lBRUQ7O09BRUc7SUFDSCxZQUFZLENBQUMsTUFBTSxFQUFFLGFBQWEsR0FBRyxJQUFJLENBSXhDO0lBRUQ7O09BRUc7SUFDSCxTQUFTLElBQUkseUJBQXlCLENBRXJDO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"low_priority_eviction_rule.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool/eviction/low_priority_eviction_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,MAAM,WAAW,yBAAyB;IACxC,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,qBAAa,uBAAwB,YAAW,YAAY;IAK9C,OAAO,CAAC,MAAM;IAJ1B,SAAgB,IAAI,SAAyB;IAE7C,OAAO,CAAC,GAAG,CAAkE;IAE7E,YAAoB,MAAM,EAAE,yBAAyB,EAAI;IAE5C,KAAK,CAAC,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC,CA4D9F;IAED;;OAEG;IACH,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAIxC;IAED;;OAEG;IACH,SAAS,IAAI,yBAAyB,CAErC;CACF"}

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

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

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

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

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

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

package/dest/mem_pools/tx_pool/index.js

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

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

@@ -5,4 +5,8 @@ import type { Tx } from '@aztec/stdlib/tx';
  * We currently use the sum of the priority fees for the tx for this value, represented as hex.
  */
 export declare function getPendingTxPriority(tx: Tx): string;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpb3JpdHkuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvdHhfcG9vbC9wcmlvcml0eS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUUzQzs7OztHQUlHO0FBQ0gsd0JBQWdCLG9CQUFvQixDQUFDLEVBQUUsRUFBRSxFQUFFLEdBQUcsTUFBTSxDQUluRCJ9
+/**
+ * Returns the priority of a tx.
+ */
+export declare function getTxPriorityFee(tx: Tx): bigint;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpb3JpdHkuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvdHhfcG9vbC9wcmlvcml0eS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUUzQzs7OztHQUlHO0FBQ0gsd0JBQWdCLG9CQUFvQixDQUFDLEVBQUUsRUFBRSxFQUFFLEdBQUcsTUFBTSxDQUVuRDtBQUVEOztHQUVHO0FBQ0gsd0JBQWdCLGdCQUFnQixDQUFDLEVBQUUsRUFBRSxFQUFFLEdBQUcsTUFBTSxDQUkvQyJ9