@aztec/p2p 0.84.0 → 0.85.0

package/dest/mem_pools/tx_pool/aztec_kv_tx_pool.js

@@ -1,8 +1,14 @@
+import { Fr } from '@aztec/foundation/fields';
 import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { GasFees } from '@aztec/stdlib/gas';
 import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import { DatabasePublicStateSource } from '@aztec/stdlib/trees';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
 import { getTelemetryClient } from '@aztec/telemetry-client';
+import { ArchiveCache } from '../../msg_validators/tx_validator/archive_cache.js';
+import { GasTxValidator } from '../../msg_validators/tx_validator/gas_validator.js';
 import { PoolInstrumentation, PoolName } from '../instrumentation.js';
 import { getPendingTxPriority } from './priority.js';
 /**
@@ -10,12 +16,18 @@ import { getPendingTxPriority } from './priority.js';
  */ export class AztecKVTxPool {
     #store;
     /** Our tx pool, stored as a Map, with K: tx hash and V: the transaction. */ #txs;
+    /** The maximum cumulative tx size that the pending txs in the pool take up. */ #maxTxPoolSize;
     /** Index from tx hash to the block number in which they were mined, filtered by mined txs. */ #minedTxHashToBlock;
     /** Index from tx priority (stored as hex) to its tx hash, filtered by pending txs. */ #pendingTxPriorityToHash;
+    /** Index from tx hash to its tx size (in bytes), filtered by pending txs. */ #pendingTxHashToSize;
+    /** Index from tx hash to its header hash, filtered by pending txs. */ #pendingTxHashToHeaderHash;
+    /** The cumulative tx size in bytes that the pending txs in the pool take up. */ #pendingTxSize;
+    /** In-memory mapping of pending tx hashes to the hydrated pending tx in the pool. */ #pendingTxs;
     /** KV store for archived txs. */ #archive;
     /** Archived txs map for future lookup. */ #archivedTxs;
     /** Indexes of the archived txs by insertion order. */ #archivedTxIndices;
     /** Number of txs to archive. */ #archivedTxLimit;
+    /** The world state synchronizer used in the node. */ #worldStateSynchronizer;
     #log;
     #metrics;
     /**
@@ -25,15 +37,21 @@ import { getPendingTxPriority } from './priority.js';
    * @param telemetry - A telemetry client.
    * @param archivedTxLimit - The number of txs to archive.
    * @param log - A logger.
-   */ constructor(store, archive, telemetry = getTelemetryClient(), archivedTxLimit = 0, log = createLogger('p2p:tx_pool')){
+   */ constructor(store, archive, worldStateSynchronizer, telemetry = getTelemetryClient(), config = {}, log = createLogger('p2p:tx_pool')){
         this.#txs = store.openMap('txs');
         this.#minedTxHashToBlock = store.openMap('txHashToBlockMined');
         this.#pendingTxPriorityToHash = store.openMultiMap('pendingTxFeeToHash');
+        this.#pendingTxHashToSize = store.openMap('pendingTxHashToSize');
+        this.#pendingTxHashToHeaderHash = store.openMap('pendingTxHashToHeaderHash');
+        this.#pendingTxSize = store.openSingleton('pendingTxSize');
+        this.#maxTxPoolSize = config.maxTxPoolSize;
+        this.#pendingTxs = new Map();
         this.#archivedTxs = archive.openMap('archivedTxs');
         this.#archivedTxIndices = archive.openMap('archivedTxIndices');
-        this.#archivedTxLimit = archivedTxLimit;
+        this.#archivedTxLimit = config.archivedTxLimit ?? 0;
         this.#store = store;
         this.#archive = archive;
+        this.#worldStateSynchronizer = worldStateSynchronizer;
         this.#log = log;
         this.#metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL, ()=>store.estimateSize());
     }
@@ -42,19 +60,27 @@ import { getPendingTxPriority } from './priority.js';
             return Promise.resolve();
         }
         let deletedPending = 0;
+        const minedNullifiers = new Set();
+        const minedFeePayers = new Set();
         return this.#store.transactionAsync(async ()=>{
+            let pendingTxSize = await this.#pendingTxSize.getAsync() ?? 0;
             for (const hash of txHashes){
                 const key = hash.toString();
                 await this.#minedTxHashToBlock.set(key, blockNumber);
-                const tx = await this.getTxByHash(hash);
+                const tx = await this.getPendingTxByHash(hash);
                 if (tx) {
+                    const nullifiers = tx.data.getNonEmptyNullifiers();
+                    nullifiers.forEach((nullifier)=>minedNullifiers.add(nullifier.toString()));
+                    minedFeePayers.add(tx.data.feePayer.toString());
                     deletedPending++;
-                    const fee = getPendingTxPriority(tx);
-                    await this.#pendingTxPriorityToHash.deleteValue(fee, key);
+                    pendingTxSize -= tx.getSize();
+                    await this.removePendingTxIndices(tx, key);
                 }
             }
             this.#metrics.recordAddedObjects(txHashes.length, 'mined');
-            this.#metrics.recordRemovedObjects(deletedPending, 'pending');
+            await this.#pendingTxSize.set(pendingTxSize);
+            const numTxsEvicted = await this.evictInvalidTxsAfterMining(txHashes, blockNumber, minedNullifiers, minedFeePayers);
+            this.#metrics.recordRemovedObjects(deletedPending + numTxsEvicted, 'pending');
         });
     }
     markMinedAsPending(txHashes) {
@@ -63,16 +89,24 @@ import { getPendingTxPriority } from './priority.js';
         }
         let markedAsPending = 0;
         return this.#store.transactionAsync(async ()=>{
+            let pendingTxSize = await this.#pendingTxSize.getAsync() ?? 0;
             for (const hash of txHashes){
                 const key = hash.toString();
                 await this.#minedTxHashToBlock.delete(key);
-                const tx = await this.getTxByHash(hash);
+                // Rehydrate the tx in the in-memory pending txs mapping
+                const tx = await this.getPendingTxByHash(hash);
                 if (tx) {
-                    await this.#pendingTxPriorityToHash.set(getPendingTxPriority(tx), key);
+                    await this.addPendingTxIndices(tx, key);
+                    pendingTxSize += tx.getSize();
                     markedAsPending++;
                 }
             }
-            this.#metrics.recordAddedObjects(markedAsPending, 'pending');
+            await this.#pendingTxSize.set(pendingTxSize);
+        }).then(async ()=>{
+            const numInvalidTxsEvicted = await this.evictInvalidTxsAfterReorg(txHashes);
+            const { numLowPriorityTxsEvicted, numNewTxsEvicted } = await this.evictLowPriorityTxs(txHashes);
+            this.#metrics.recordAddedObjects(markedAsPending - numNewTxsEvicted, 'pending');
+            this.#metrics.recordRemovedObjects(numInvalidTxsEvicted + numLowPriorityTxsEvicted - numNewTxsEvicted, 'pending');
             this.#metrics.recordRemovedObjects(markedAsPending, 'mined');
         });
     }
@@ -140,6 +174,7 @@ import { getPendingTxPriority } from './priority.js';
             })));
         await this.#store.transactionAsync(async ()=>{
             let pendingCount = 0;
+            let pendingTxSize = await this.#pendingTxSize.getAsync() ?? 0;
             await Promise.all(txs.map(async (tx, i)=>{
                 const { txHash, txStats } = hashesAndStats[i];
                 this.#log.verbose(`Adding tx ${txHash.toString()} to pool`, {
@@ -150,42 +185,47 @@ import { getPendingTxPriority } from './priority.js';
                 await this.#txs.set(key, tx.toBuffer());
                 if (!await this.#minedTxHashToBlock.hasAsync(key)) {
                     pendingCount++;
-                    // REFACTOR: Use an lmdb conditional write to avoid race conditions with this write tx
-                    await this.#pendingTxPriorityToHash.set(getPendingTxPriority(tx), key);
+                    pendingTxSize += tx.getSize();
+                    await this.addPendingTxIndices(tx, key);
                     this.#metrics.recordSize(tx);
                 }
             }));
-            this.#metrics.recordAddedObjects(pendingCount, 'pending');
+            await this.#pendingTxSize.set(pendingTxSize);
+            const { numLowPriorityTxsEvicted, numNewTxsEvicted } = await this.evictLowPriorityTxs(hashesAndStats.map(({ txHash })=>txHash));
+            this.#metrics.recordAddedObjects(pendingCount - numNewTxsEvicted, 'pending');
+            this.#metrics.recordRemovedObjects(numLowPriorityTxsEvicted - numNewTxsEvicted, 'pending');
         });
     }
     /**
    * Deletes transactions from the pool. Tx hashes that are not present are ignored.
    * @param txHashes - An array of tx hashes to be removed from the tx pool.
    * @returns Empty promise.
-   */ deleteTxs(txHashes) {
+   */ deleteTxs(txHashes, eviction = false) {
         let pendingDeleted = 0;
         let minedDeleted = 0;
         const deletedTxs = [];
         const poolDbTx = this.#store.transactionAsync(async ()=>{
+            let pendingTxSize = await this.#pendingTxSize.getAsync() ?? 0;
             for (const hash of txHashes){
                 const key = hash.toString();
                 const tx = await this.getTxByHash(hash);
                 if (tx) {
-                    const fee = getPendingTxPriority(tx);
-                    await this.#pendingTxPriorityToHash.deleteValue(fee, key);
                     const isMined = await this.#minedTxHashToBlock.hasAsync(key);
                     if (isMined) {
                         minedDeleted++;
                     } else {
                         pendingDeleted++;
+                        pendingTxSize -= tx.getSize();
+                        await this.removePendingTxIndices(tx, key);
                     }
-                    if (this.#archivedTxLimit) {
+                    if (!eviction && this.#archivedTxLimit) {
                         deletedTxs.push(tx);
                     }
                     await this.#txs.delete(key);
                     await this.#minedTxHashToBlock.delete(key);
                 }
             }
+            await this.#pendingTxSize.set(pendingTxSize);
             this.#metrics.recordRemovedObjects(pendingDeleted, 'pending');
             this.#metrics.recordRemovedObjects(minedDeleted, 'mined');
         });
@@ -210,6 +250,43 @@ import { getPendingTxPriority } from './priority.js';
         return vals.map((x)=>TxHash.fromString(x));
     }
     /**
+   * Creates a GasTxValidator instance.
+   * @param db - DB for the validator to use
+   * @returns A GasTxValidator instance
+   */ createGasTxValidator(db) {
+        return new GasTxValidator(new DatabasePublicStateSource(db), ProtocolContractAddress.FeeJuice, GasFees.empty());
+    }
+    /**
+   * Creates an ArchiveCache instance.
+   * @param db - DB for the cache to use
+   * @returns An ArchiveCache instance
+   */ createArchiveCache(db) {
+        return new ArchiveCache(db);
+    }
+    /**
+   * Checks if a cached transaction exists in the in-memory pending tx pool and returns it.
+   * Otherwise, it checks the tx pool, updates the pending tx pool, and returns the tx.
+   * @param txHash - The generated tx hash.
+   * @returns The transaction, if found, 'undefined' otherwise.
+   */ async getPendingTxByHash(txHash) {
+        let key;
+        if (typeof txHash === 'string') {
+            key = txHash;
+            txHash = TxHash.fromString(txHash);
+        } else {
+            key = txHash.toString();
+        }
+        if (this.#pendingTxs.has(key)) {
+            return this.#pendingTxs.get(key);
+        }
+        const tx = await this.getTxByHash(txHash);
+        if (tx) {
+            this.#pendingTxs.set(key, tx);
+            return tx;
+        }
+        return undefined;
+    }
+    /**
    * Archives a list of txs for future reference. The number of archived txs is limited by the specified archivedTxLimit.
    * @param txs - The list of transactions to archive.
    * @returns Empty promise.
@@ -242,4 +319,140 @@ import { getPendingTxPriority } from './priority.js';
             }
         });
     }
+    /**
+   * Evicts pending txs with the lowest priority fees from the pool to accomodate the max tx count and cumulative max tx size
+   * after new txs are added.
+   *
+   * @param newTxHashes - The tx hashes of the new txs added to the pool.
+   * @returns The total number of txs evicted from the pool and the number of new txs that were evicted.
+   */ async evictLowPriorityTxs(newTxHashes) {
+        if (this.#maxTxPoolSize === undefined) {
+            return {
+                numLowPriorityTxsEvicted: 0,
+                numNewTxsEvicted: 0
+            };
+        }
+        let numNewTxsEvicted = 0;
+        const txsToEvict = [];
+        let pendingTxsSize = await this.#pendingTxSize.getAsync() ?? 0;
+        if (pendingTxsSize > this.#maxTxPoolSize) {
+            for await (const txHash of this.#pendingTxPriorityToHash.valuesAsync()){
+                this.#log.verbose(`Evicting tx ${txHash} from pool due to low priority to satisfy max tx size limit`);
+                txsToEvict.push(TxHash.fromString(txHash));
+                const txSize = await this.#pendingTxHashToSize.getAsync(txHash.toString()) ?? (await this.getPendingTxByHash(txHash))?.getSize();
+                if (txSize) {
+                    pendingTxsSize -= txSize;
+                    if (pendingTxsSize <= this.#maxTxPoolSize) {
+                        break;
+                    }
+                }
+            }
+            numNewTxsEvicted += newTxHashes.filter((txHash)=>txsToEvict.includes(txHash)).length;
+        }
+        if (txsToEvict.length > 0) {
+            await this.deleteTxs(txsToEvict, true);
+        }
+        return {
+            numLowPriorityTxsEvicted: txsToEvict.length,
+            numNewTxsEvicted
+        };
+    }
+    /**
+   * Evicts invalid pending txs from the pool after a txs from a block are mined.
+   * Eviction criteria includes:
+   *   - txs with nullifiers that are already included in the mined block
+   *   - txs with an insufficient fee payer balance
+   *   - txs with a max block number lower than the mined block
+   *
+   * @param minedTxHashes - The tx hashes of the txs mined in the block.
+   * @param blockNumber - The block number of the mined block.
+   * @returns The total number of txs evicted from the pool.
+   */ async evictInvalidTxsAfterMining(minedTxHashes, blockNumber, minedNullifiers, minedFeePayers) {
+        if (minedTxHashes.length === 0) {
+            return 0;
+        }
+        // Wait for world state to be synced to at least the mined block number
+        await this.#worldStateSynchronizer.syncImmediate(blockNumber);
+        const db = this.#worldStateSynchronizer.getCommitted();
+        const gasTxValidator = this.createGasTxValidator(db);
+        const txsToEvict = [];
+        for await (const txHash of this.#pendingTxPriorityToHash.valuesAsync()){
+            const tx = await this.getPendingTxByHash(txHash);
+            if (!tx) {
+                continue;
+            }
+            // Evict pending txs that share nullifiers with mined txs
+            const txNullifiers = tx.data.getNonEmptyNullifiers();
+            if (txNullifiers.some((nullifier)=>minedNullifiers.has(nullifier.toString()))) {
+                this.#log.verbose(`Evicting tx ${txHash} from pool due to a duplicate nullifier with a mined tx`);
+                txsToEvict.push(TxHash.fromString(txHash));
+                continue;
+            }
+            // Evict pending txs with an insufficient fee payer balance
+            if (minedFeePayers.has(tx.data.feePayer.toString()) && (await gasTxValidator.validateTxFee(tx)).result === 'invalid') {
+                this.#log.verbose(`Evicting tx ${txHash} from pool due to an insufficient fee payer balance`);
+                txsToEvict.push(TxHash.fromString(txHash));
+                continue;
+            }
+            // Evict pending txs with a max block number less than or equal to the mined block
+            const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
+            if (maxBlockNumber.isSome && maxBlockNumber.value.toNumber() <= blockNumber) {
+                this.#log.verbose(`Evicting tx ${txHash} from pool due to an invalid max block number`);
+                txsToEvict.push(TxHash.fromString(txHash));
+                continue;
+            }
+        }
+        if (txsToEvict.length > 0) {
+            await this.deleteTxs(txsToEvict, true);
+        }
+        return txsToEvict.length;
+    }
+    /**
+   * Evicts pending txs that no longer have valid archive roots or fee payer balances from the pool after a reorg.
+   *
+   * @param txHashes - The tx hashes of the txs that were moved from mined to pending.
+   * @returns The total number of txs evicted from the pool.
+   */ async evictInvalidTxsAfterReorg(txHashes) {
+        if (txHashes.length === 0) {
+            return 0;
+        }
+        await this.#worldStateSynchronizer.syncImmediate();
+        const db = this.#worldStateSynchronizer.getCommitted();
+        const archiveCache = this.createArchiveCache(db);
+        const gasTxValidator = this.createGasTxValidator(db);
+        const txsToEvict = [];
+        for await (const [txHash, headerHash] of this.#pendingTxHashToHeaderHash.entriesAsync()){
+            const tx = await this.getPendingTxByHash(txHash);
+            if (!tx) {
+                continue;
+            }
+            const [index] = await archiveCache.getArchiveIndices([
+                Fr.fromString(headerHash)
+            ]);
+            if (index === undefined) {
+                this.#log.verbose(`Evicting tx ${txHash} from pool due to an invalid archive root`);
+                txsToEvict.push(TxHash.fromString(txHash));
+                continue;
+            }
+            if ((await gasTxValidator.validateTxFee(tx)).result === 'invalid') {
+                this.#log.verbose(`Evicting tx ${txHash} from pool due to an insufficient fee payer balance`);
+                txsToEvict.push(TxHash.fromString(txHash));
+            }
+        }
+        if (txsToEvict.length > 0) {
+            await this.deleteTxs(txsToEvict, true);
+        }
+        return txsToEvict.length;
+    }
+    async addPendingTxIndices(tx, txHash) {
+        await this.#pendingTxPriorityToHash.set(getPendingTxPriority(tx), txHash);
+        await this.#pendingTxHashToSize.set(txHash, tx.getSize());
+        await this.#pendingTxHashToHeaderHash.set(txHash, (await tx.data.constants.historicalHeader.hash()).toString());
+    }
+    async removePendingTxIndices(tx, txHash) {
+        await this.#pendingTxPriorityToHash.deleteValue(getPendingTxPriority(tx), txHash);
+        await this.#pendingTxHashToSize.delete(txHash);
+        await this.#pendingTxHashToHeaderHash.delete(txHash);
+        this.#pendingTxs.delete(txHash);
+    }
 }

package/dest/msg_validators/tx_validator/archive_cache.d.ts

@@ -0,0 +1,14 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { ArchiveSource } from '@aztec/p2p';
+import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+/**
+ * Implements an archive source by checking a DB and an in-memory collection.
+ * Intended for validating transactions as they are added to a block.
+ */
+export declare class ArchiveCache implements ArchiveSource {
+    private db;
+    archives: Map<string, bigint>;
+    constructor(db: MerkleTreeReadOperations);
+    getArchiveIndices(archives: Fr[]): Promise<(bigint | undefined)[]>;
+}
+//# sourceMappingURL=archive_cache.d.ts.map

package/dest/msg_validators/tx_validator/archive_cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive_cache.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/archive_cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAGhF;;;GAGG;AACH,qBAAa,YAAa,YAAW,aAAa;IAGpC,OAAO,CAAC,EAAE;IAFtB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBAEV,EAAE,EAAE,wBAAwB;IAInC,iBAAiB,CAAC,QAAQ,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAAC;CAWhF"}

package/dest/msg_validators/tx_validator/archive_cache.js

@@ -0,0 +1,22 @@
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+/**
+ * Implements an archive source by checking a DB and an in-memory collection.
+ * Intended for validating transactions as they are added to a block.
+ */ export class ArchiveCache {
+    db;
+    archives;
+    constructor(db){
+        this.db = db;
+        this.archives = new Map();
+    }
+    async getArchiveIndices(archives) {
+        const toCheckDb = archives.filter((n)=>!this.archives.has(n.toString()));
+        const dbHits = await this.db.findLeafIndices(MerkleTreeId.ARCHIVE, toCheckDb);
+        dbHits.forEach((x, index)=>{
+            if (x !== undefined) {
+                this.archives.set(toCheckDb[index].toString(), x);
+            }
+        });
+        return archives.map((n)=>this.archives.get(n.toString()));
+    }
+}

package/dest/msg_validators/tx_validator/block_header_validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block_header_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/block_header_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,EAAE,KAAK,KAAK,EAAM,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE7F,MAAM,WAAW,aAAa;IAC5B,iBAAiB,EAAE,CAAC,QAAQ,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC;CACxE;AAED,qBAAa,sBAAsB,CAAC,CAAC,SAAS,KAAK,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;gBAIhE,aAAa,EAAE,aAAa;IAIlC,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAQrD"}
+{"version":3,"file":"block_header_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/block_header_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,EAAE,KAAK,KAAK,EAA6B,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpH,MAAM,WAAW,aAAa;IAC5B,iBAAiB,EAAE,CAAC,QAAQ,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC;CACxE;AAED,qBAAa,sBAAsB,CAAC,CAAC,SAAS,KAAK,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;gBAIhE,aAAa,EAAE,aAAa;IAIlC,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAQrD"}

package/dest/msg_validators/tx_validator/block_header_validator.js

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/foundation/log';
-import { Tx } from '@aztec/stdlib/tx';
+import { TX_ERROR_BLOCK_HEADER, Tx } from '@aztec/stdlib/tx';
 export class BlockHeaderTxValidator {
     #log = createLogger('p2p:tx_validator:tx_block_header');
     #archiveSource;
@@ -15,7 +15,7 @@ export class BlockHeaderTxValidator {
             return {
                 result: 'invalid',
                 reason: [
-                    'Block header not found'
+                    TX_ERROR_BLOCK_HEADER
                 ]
             };
         }

package/dest/msg_validators/tx_validator/data_validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/data_validator.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,EAAE,EAAE,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEjF,qBAAa,eAAgB,YAAW,WAAW,CAAC,EAAE,CAAC;;IAG/C,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAmFtD"}
+{"version":3,"file":"data_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/data_validator.ts"],"names":[],"mappings":"AAGA,OAAO,EAQL,EAAE,EACF,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAE1B,qBAAa,eAAgB,YAAW,WAAW,CAAC,EAAE,CAAC;;IAG/C,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAmFtD"}

package/dest/msg_validators/tx_validator/data_validator.js

@@ -1,7 +1,7 @@
 import { MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
 import { computeCalldataHash } from '@aztec/stdlib/hash';
-import { Tx } from '@aztec/stdlib/tx';
+import { TX_ERROR_CALLDATA_COUNT_MISMATCH, TX_ERROR_CALLDATA_COUNT_TOO_LARGE, TX_ERROR_CONTRACT_CLASS_LOGS, TX_ERROR_CONTRACT_CLASS_LOG_COUNT, TX_ERROR_CONTRACT_CLASS_LOG_LENGTH, TX_ERROR_CONTRACT_CLASS_LOG_SORTING, TX_ERROR_INCORRECT_CALLDATA, Tx } from '@aztec/stdlib/tx';
 export class DataTxValidator {
     #log = createLogger('p2p:tx_validator:tx_data');
     async validateTx(tx) {
@@ -11,7 +11,7 @@ export class DataTxValidator {
     }
     async #hasCorrectCalldata(tx) {
         if (tx.publicFunctionCalldata.length !== tx.numberOfPublicCalls()) {
-            const reason = 'Wrong number of calldata for public calls';
+            const reason = TX_ERROR_CALLDATA_COUNT_MISMATCH;
             this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)}. Reason: ${reason}. Expected ${tx.numberOfPublicCalls()}. Got ${tx.publicFunctionCalldata.length}.`);
             return {
                 result: 'invalid',
@@ -21,7 +21,7 @@ export class DataTxValidator {
             };
         }
         if (tx.getTotalPublicCalldataCount() > MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS) {
-            const reason = 'Total calldata too large for enqueued public calls';
+            const reason = TX_ERROR_CALLDATA_COUNT_TOO_LARGE;
             this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)}. Reason: ${reason}. Expected no greater than ${MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS} fields. Got ${tx.getTotalPublicCalldataCount()}.`);
             return {
                 result: 'invalid',
@@ -35,7 +35,7 @@ export class DataTxValidator {
             const { request, calldata } = callRequests[i];
             const hash = await computeCalldataHash(calldata);
             if (!hash.equals(request.calldataHash)) {
-                const reason = 'Incorrect calldata for public call';
+                const reason = TX_ERROR_INCORRECT_CALLDATA;
                 this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)}. Reason: ${reason}. Call request index: ${i}.`);
                 return {
                     result: 'invalid',
@@ -57,7 +57,7 @@ export class DataTxValidator {
             return {
                 result: 'invalid',
                 reason: [
-                    'Mismatched number of contract class logs'
+                    TX_ERROR_CONTRACT_CLASS_LOG_COUNT
                 ]
             };
         }
@@ -70,7 +70,7 @@ export class DataTxValidator {
                     return {
                         result: 'invalid',
                         reason: [
-                            'Incorrectly sorted contract class logs'
+                            TX_ERROR_CONTRACT_CLASS_LOG_SORTING
                         ]
                     };
                 } else {
@@ -78,7 +78,7 @@ export class DataTxValidator {
                     return {
                         result: 'invalid',
                         reason: [
-                            'Mismatched contract class logs'
+                            TX_ERROR_CONTRACT_CLASS_LOGS
                         ]
                     };
                 }
@@ -88,7 +88,7 @@ export class DataTxValidator {
                 return {
                     result: 'invalid',
                     reason: [
-                        'Mismatched contract class logs length'
+                        TX_ERROR_CONTRACT_CLASS_LOG_LENGTH
                     ]
                 };
             }

package/dest/msg_validators/tx_validator/double_spend_validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"double_spend_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/double_spend_validator.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,KAAK,KAAK,EAAM,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE7F,MAAM,WAAW,eAAe;IAC9B,eAAe,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;CAC/D;AAED,qBAAa,sBAAsB,CAAC,CAAC,SAAS,KAAK,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;gBAIhE,eAAe,EAAE,eAAe;IAItC,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAiBrD"}
+{"version":3,"file":"double_spend_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/double_spend_validator.ts"],"names":[],"mappings":";;AACA,OAAO,EACL,KAAK,KAAK,EAIV,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,eAAe,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;CAC/D;AAED,qBAAa,sBAAsB,CAAC,CAAC,SAAS,KAAK,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;gBAIhE,eAAe,EAAE,eAAe;IAItC,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAiBrD"}

package/dest/msg_validators/tx_validator/double_spend_validator.js

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/foundation/log';
-import { Tx } from '@aztec/stdlib/tx';
+import { TX_ERROR_DUPLICATE_NULLIFIER_IN_TX, TX_ERROR_EXISTING_NULLIFIER, Tx } from '@aztec/stdlib/tx';
 export class DoubleSpendTxValidator {
     #log = createLogger('p2p:tx_validator:tx_double_spend');
     #nullifierSource;
@@ -15,7 +15,7 @@ export class DoubleSpendTxValidator {
             return {
                 result: 'invalid',
                 reason: [
-                    'Duplicate nullifier in tx'
+                    TX_ERROR_DUPLICATE_NULLIFIER_IN_TX
                 ]
             };
         }
@@ -24,7 +24,7 @@ export class DoubleSpendTxValidator {
             return {
                 result: 'invalid',
                 reason: [
-                    'Existing nullifier'
+                    TX_ERROR_EXISTING_NULLIFIER
                 ]
             };
         }

package/dest/msg_validators/tx_validator/gas_validator.d.ts

@@ -1,10 +1,11 @@
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { GasFees } from '@aztec/stdlib/gas';
+import { GasFees } from '@aztec/stdlib/gas';
 import type { PublicStateSource } from '@aztec/stdlib/trees';
 import { type Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 export declare class GasTxValidator implements TxValidator<Tx> {
     #private;
     constructor(publicDataSource: PublicStateSource, feeJuiceAddress: AztecAddress, gasFees: GasFees);
     validateTx(tx: Tx): Promise<TxValidationResult>;
+    validateTxFee(tx: Tx): Promise<TxValidationResult>;
 }
 //# sourceMappingURL=gas_validator.d.ts.map

package/dest/msg_validators/tx_validator/gas_validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gas_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/gas_validator.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,KAAK,EAAE,EAAoB,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAExG,qBAAa,cAAe,YAAW,WAAW,CAAC,EAAE,CAAC;;gBAMxC,gBAAgB,EAAE,iBAAiB,EAAE,eAAe,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO;IAM1F,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAyEtD"}
+{"version":3,"file":"gas_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/gas_validator.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAO,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAIL,KAAK,EAAE,EAEP,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAE1B,qBAAa,cAAe,YAAW,WAAW,CAAC,EAAE,CAAC;;gBAMxC,gBAAgB,EAAE,iBAAiB,EAAE,eAAe,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO;IAM1F,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAoDxC,aAAa,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;CA0ChE"}

package/dest/msg_validators/tx_validator/gas_validator.js

@@ -1,8 +1,10 @@
+import { FIXED_DA_GAS, FIXED_L2_GAS } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
 import { getCallRequestsWithCalldataByPhase } from '@aztec/simulator/server';
 import { FunctionSelector } from '@aztec/stdlib/abi';
-import { TxExecutionPhase } from '@aztec/stdlib/tx';
+import { Gas } from '@aztec/stdlib/gas';
+import { TX_ERROR_INSUFFICIENT_FEE_PAYER_BALANCE, TX_ERROR_INSUFFICIENT_FEE_PER_GAS, TX_ERROR_INSUFFICIENT_GAS_LIMIT, TxExecutionPhase } from '@aztec/stdlib/tx';
 export class GasTxValidator {
     #log = createLogger('sequencer:tx_validator:tx_gas');
     #publicDataSource;
@@ -14,15 +16,19 @@ export class GasTxValidator {
         this.#gasFees = gasFees;
     }
     async validateTx(tx) {
+        const gasLimitValidation = this.#validateMinGasLimit(tx);
+        if (gasLimitValidation.result === 'invalid') {
+            return Promise.resolve(gasLimitValidation);
+        }
         if (await this.#shouldSkip(tx)) {
             return Promise.resolve({
                 result: 'skipped',
                 reason: [
-                    'Insufficient fee per gas'
+                    TX_ERROR_INSUFFICIENT_FEE_PER_GAS
                 ]
             });
         }
-        return this.#validateTxFee(tx);
+        return this.validateTxFee(tx);
     }
     /**
    * Check whether the tx's max fees are valid for the current block, and skip if not.
@@ -42,7 +48,28 @@ export class GasTxValidator {
         }
         return notEnoughMaxFees;
     }
-    async #validateTxFee(tx) {
+    /**
+   * Check whether the tx's gas limit is above the minimum amount.
+   */ #validateMinGasLimit(tx) {
+        const gasLimits = tx.data.constants.txContext.gasSettings.gasLimits;
+        const minGasLimits = new Gas(FIXED_DA_GAS, FIXED_L2_GAS);
+        if (minGasLimits.gtAny(gasLimits)) {
+            this.#log.warn(`Rejecting transaction due to the gas limit(s) not being above the minimum gas limit`, {
+                gasLimits,
+                minGasLimits
+            });
+            return {
+                result: 'invalid',
+                reason: [
+                    TX_ERROR_INSUFFICIENT_GAS_LIMIT
+                ]
+            };
+        }
+        return {
+            result: 'valid'
+        };
+    }
+    async validateTxFee(tx) {
         const feePayer = tx.data.feePayer;
         // Compute the maximum fee that this tx may pay, based on its gasLimits and maxFeePerGas
         const feeLimit = tx.data.constants.txContext.gasSettings.getFeeLimit();
@@ -65,7 +92,7 @@ export class GasTxValidator {
             return {
                 result: 'invalid',
                 reason: [
-                    'Insufficient fee payer balance'
+                    TX_ERROR_INSUFFICIENT_FEE_PAYER_BALANCE
                 ]
             };
         }

package/dest/msg_validators/tx_validator/index.d.ts

@@ -8,4 +8,5 @@ export * from './gas_validator.js';
 export * from './phases_validator.js';
 export * from './test_utils.js';
 export * from './allowed_public_setup.js';
+export * from './archive_cache.js';
 //# sourceMappingURL=index.d.ts.map

package/dest/msg_validators/tx_validator/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC"}

package/dest/msg_validators/tx_validator/index.js

@@ -8,3 +8,4 @@ export * from './gas_validator.js';
 export * from './phases_validator.js';
 export * from './test_utils.js';
 export * from './allowed_public_setup.js';
+export * from './archive_cache.js';