@aztec/p2p 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5d02921e

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

@@ -5,4 +5,4 @@ export declare class DataTxValidator implements TxValidator<Tx> {
     constructor(bindings?: LoggerBindings);
     validateTx(tx: Tx): Promise<TxValidationResult>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YV92YWxpZGF0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tc2dfdmFsaWRhdG9ycy90eF92YWxpZGF0b3IvZGF0YV92YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFlLEtBQUssY0FBYyxFQUFnQixNQUFNLHVCQUF1QixDQUFDO0FBRXZGLE9BQU8sRUFTTCxFQUFFLEVBQ0YsS0FBSyxrQkFBa0IsRUFDdkIsS0FBSyxXQUFXLEVBQ2pCLE1BQU0sa0JBQWtCLENBQUM7QUFFMUIscUJBQWEsZUFBZ0IsWUFBVyxXQUFXLENBQUMsRUFBRSxDQUFDOztJQUdyRCxZQUFZLFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFFcEM7SUFFSyxVQUFVLENBQUMsRUFBRSxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsa0JBQWtCLENBQUMsQ0FNcEQ7Q0FtR0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YV92YWxpZGF0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tc2dfdmFsaWRhdG9ycy90eF92YWxpZGF0b3IvZGF0YV92YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFlLEtBQUssY0FBYyxFQUFnQixNQUFNLHVCQUF1QixDQUFDO0FBSXZGLE9BQU8sRUFXTCxFQUFFLEVBQ0YsS0FBSyxrQkFBa0IsRUFDdkIsS0FBSyxXQUFXLEVBQ2pCLE1BQU0sa0JBQWtCLENBQUM7QUFFMUIscUJBQWEsZUFBZ0IsWUFBVyxXQUFXLENBQUMsRUFBRSxDQUFDOztJQUdyRCxZQUFZLFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFFcEM7SUFFSyxVQUFVLENBQUMsRUFBRSxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsa0JBQWtCLENBQUMsQ0FPcEQ7Q0F1SUYifQ==

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":"AACA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAEvF,OAAO,EASL,EAAE,EACF,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAE1B,qBAAa,eAAgB,YAAW,WAAW,CAAC,EAAE,CAAC;;IAGrD,YAAY,QAAQ,CAAC,EAAE,cAAc,EAEpC;IAEK,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAMpD;CAmGF"}
+{"version":3,"file":"data_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/data_validator.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAIvF,OAAO,EAWL,EAAE,EACF,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAE1B,qBAAa,eAAgB,YAAW,WAAW,CAAC,EAAE,CAAC;;IAGrD,YAAY,QAAQ,CAAC,EAAE,cAAc,EAEpC;IAEK,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAOpD;CAuIF"}

package/dest/msg_validators/tx_validator/data_validator.js

@@ -1,14 +1,16 @@
 import { MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
+import { ContractClassPublishedEvent } from '@aztec/protocol-contracts/class-registry';
+import { computeContractClassId } from '@aztec/stdlib/contract';
 import { computeCalldataHash } from '@aztec/stdlib/hash';
-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_ERROR_INCORRECT_HASH, 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_ERROR_INCORRECT_CONTRACT_CLASS_ID, TX_ERROR_INCORRECT_HASH, TX_ERROR_MALFORMED_CONTRACT_CLASS_LOG, Tx } from '@aztec/stdlib/tx';
 export class DataTxValidator {
     #log;
     constructor(bindings){
         this.#log = createLogger('p2p:tx_validator:tx_data', bindings);
     }
     async validateTx(tx) {
-        const reason = await this.#hasCorrectHash(tx) ?? await this.#hasCorrectCalldata(tx) ?? await this.#hasCorrectContractClassLogs(tx);
+        const reason = await this.#hasCorrectHash(tx) ?? await this.#hasCorrectCalldata(tx) ?? await this.#hasCorrectContractClassLogs(tx) ?? await this.#hasCorrectContractClassIds(tx);
         return reason ? {
             result: 'invalid',
             reason: [
@@ -77,4 +79,35 @@ export class DataTxValidator {
         }
         return undefined;
     }
+    async #hasCorrectContractClassIds(tx) {
+        const contractClassLogs = tx.getContractClassLogs();
+        for (const log of contractClassLogs){
+            if (!ContractClassPublishedEvent.isContractClassPublishedEvent(log)) {
+                continue;
+            }
+            let event;
+            try {
+                event = ContractClassPublishedEvent.fromLog(log);
+            } catch (e) {
+                this.#log.warn(`Rejecting tx ${tx.getTxHash()}: failed to parse contract class event: ${e}`);
+                return TX_ERROR_MALFORMED_CONTRACT_CLASS_LOG;
+            }
+            try {
+                const { publicBytecodeCommitment } = await event.toContractClassPublicWithBytecodeCommitment();
+                const computedClassId = await computeContractClassId({
+                    artifactHash: event.artifactHash,
+                    privateFunctionsRoot: event.privateFunctionsRoot,
+                    publicBytecodeCommitment
+                });
+                if (!computedClassId.equals(event.contractClassId)) {
+                    this.#log.warn(`Rejecting tx ${tx.getTxHash()}: contract class id mismatch. Claimed ${event.contractClassId}, computed ${computedClassId}`);
+                    return TX_ERROR_INCORRECT_CONTRACT_CLASS_ID;
+                }
+            } catch (e) {
+                this.#log.warn(`Rejecting tx ${tx.getTxHash()}: failed to compute contract class id: ${e}`);
+                return TX_ERROR_MALFORMED_CONTRACT_CLASS_LOG;
+            }
+        }
+        return undefined;
+    }
 }

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

@@ -1,11 +1,21 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { type LoggerBindings } from '@aztec/foundation/log';
-import { type AnyTx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import { type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 export interface NullifierSource {
     nullifiersExist: (nullifiers: Buffer[]) => Promise<boolean[]>;
 }
-export declare class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
+/** Structural interface for double-spend validation. */
+export interface HasNullifierData {
+    txHash: {
+        toString(): string;
+    };
+    data: {
+        getNonEmptyNullifiers(): Fr[];
+    };
+}
+export declare class DoubleSpendTxValidator<T extends HasNullifierData> implements TxValidator<T> {
     #private;
     constructor(nullifierSource: NullifierSource, bindings?: LoggerBindings);
     validateTx(tx: T): Promise<TxValidationResult>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG91YmxlX3NwZW5kX3ZhbGlkYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21zZ192YWxpZGF0b3JzL3R4X3ZhbGlkYXRvci9kb3VibGVfc3BlbmRfdmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBZSxLQUFLLGNBQWMsRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUN2RixPQUFPLEVBQ0wsS0FBSyxLQUFLLEVBSVYsS0FBSyxrQkFBa0IsRUFDdkIsS0FBSyxXQUFXLEVBQ2pCLE1BQU0sa0JBQWtCLENBQUM7QUFFMUIsTUFBTSxXQUFXLGVBQWU7SUFDOUIsZUFBZSxFQUFFLENBQUMsVUFBVSxFQUFFLE1BQU0sRUFBRSxLQUFLLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO0NBQy9EO0FBRUQscUJBQWEsc0JBQXNCLENBQUMsQ0FBQyxTQUFTLEtBQUssQ0FBRSxZQUFXLFdBQVcsQ0FBQyxDQUFDLENBQUM7O0lBSTVFLFlBQVksZUFBZSxFQUFFLGVBQWUsRUFBRSxRQUFRLENBQUMsRUFBRSxjQUFjLEVBR3RFO0lBRUssVUFBVSxDQUFDLEVBQUUsRUFBRSxDQUFDLEdBQUcsT0FBTyxDQUFDLGtCQUFrQixDQUFDLENBZ0JuRDtDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG91YmxlX3NwZW5kX3ZhbGlkYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21zZ192YWxpZGF0b3JzL3R4X3ZhbGlkYXRvci9kb3VibGVfc3BlbmRfdmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3pELE9BQU8sRUFBZSxLQUFLLGNBQWMsRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUN2RixPQUFPLEVBR0wsS0FBSyxrQkFBa0IsRUFDdkIsS0FBSyxXQUFXLEVBQ2pCLE1BQU0sa0JBQWtCLENBQUM7QUFFMUIsTUFBTSxXQUFXLGVBQWU7SUFDOUIsZUFBZSxFQUFFLENBQUMsVUFBVSxFQUFFLE1BQU0sRUFBRSxLQUFLLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO0NBQy9EO0FBRUQsd0RBQXdEO0FBQ3hELE1BQU0sV0FBVyxnQkFBZ0I7SUFDL0IsTUFBTSxFQUFFO1FBQUUsUUFBUSxJQUFJLE1BQU0sQ0FBQTtLQUFFLENBQUM7SUFDL0IsSUFBSSxFQUFFO1FBQUUscUJBQXFCLElBQUksRUFBRSxFQUFFLENBQUE7S0FBRSxDQUFDO0NBQ3pDO0FBRUQscUJBQWEsc0JBQXNCLENBQUMsQ0FBQyxTQUFTLGdCQUFnQixDQUFFLFlBQVcsV0FBVyxDQUFDLENBQUMsQ0FBQzs7SUFJdkYsWUFBWSxlQUFlLEVBQUUsZUFBZSxFQUFFLFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFHdEU7SUFFSyxVQUFVLENBQUMsRUFBRSxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUMsa0JBQWtCLENBQUMsQ0FnQm5EO0NBQ0YifQ==

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":"AAAA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,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;;IAI5E,YAAY,eAAe,EAAE,eAAe,EAAE,QAAQ,CAAC,EAAE,cAAc,EAGtE;IAEK,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAgBnD;CACF"}
+{"version":3,"file":"double_spend_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/double_spend_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,EAGL,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,wDAAwD;AACxD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE;QAAE,QAAQ,IAAI,MAAM,CAAA;KAAE,CAAC;IAC/B,IAAI,EAAE;QAAE,qBAAqB,IAAI,EAAE,EAAE,CAAA;KAAE,CAAC;CACzC;AAED,qBAAa,sBAAsB,CAAC,CAAC,SAAS,gBAAgB,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;IAIvF,YAAY,eAAe,EAAE,eAAe,EAAE,QAAQ,CAAC,EAAE,cAAc,EAGtE;IAEK,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAgBnD;CACF"}

package/dest/msg_validators/tx_validator/double_spend_validator.js

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/foundation/log';
-import { TX_ERROR_DUPLICATE_NULLIFIER_IN_TX, TX_ERROR_EXISTING_NULLIFIER, Tx } from '@aztec/stdlib/tx';
+import { TX_ERROR_DUPLICATE_NULLIFIER_IN_TX, TX_ERROR_EXISTING_NULLIFIER } from '@aztec/stdlib/tx';
 export class DoubleSpendTxValidator {
     #log;
     #nullifierSource;
@@ -8,11 +8,11 @@ export class DoubleSpendTxValidator {
         this.#log = createLogger('p2p:tx_validator:tx_double_spend', bindings);
     }
     async validateTx(tx) {
-        const nullifiers = tx instanceof Tx ? tx.data.getNonEmptyNullifiers() : tx.txEffect.nullifiers;
+        const nullifiers = tx.data.getNonEmptyNullifiers();
         // Ditch this tx if it has repeated nullifiers
         const uniqueNullifiers = new Set(nullifiers.map((n)=>n.toBigInt()));
         if (uniqueNullifiers.size !== nullifiers.length) {
-            this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for emitting duplicate nullifiers`);
+            this.#log.verbose(`Rejecting tx ${tx.txHash} for emitting duplicate nullifiers`);
             return {
                 result: 'invalid',
                 reason: [
@@ -21,7 +21,7 @@ export class DoubleSpendTxValidator {
             };
         }
         if ((await this.#nullifierSource.nullifiersExist(nullifiers.map((n)=>n.toBuffer()))).some(Boolean)) {
-            this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for repeating a nullifier`);
+            this.#log.verbose(`Rejecting tx ${tx.txHash} for repeating a nullifier`);
             return {
                 result: 'invalid',
                 reason: [

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

@@ -1,21 +1,148 @@
+/**
+ * Transaction validator factories for each tx entry point.
+ *
+ * Unsolicited transactions (gossip and RPC) are fully validated before acceptance.
+ * Transactions received via req/resp or block proposals are only checked for
+ * well-formedness because we must include them for block re-execution — they may
+ * ultimately be invalid, which is caught during block building and reported as
+ * part of block validation/attestation. See the README in this directory for the
+ * full validation strategy.
+ *
+ * 1. **Gossip** — full validation in two stages with a pool pre-check in between.
+ *    Stage 1 (fast): metadata, data, timestamps, double-spend, gas, phases, block header.
+ *    Pool pre-check: `canAddPendingTx` — skips proof verification if pool would reject.
+ *    Stage 2 (slow): proof verification.
+ *    Orchestrated by `handleGossipedTx` in `libp2p_service.ts`.
+ *
+ * 2. **JSON-RPC** — full validation including all state-dependent checks.
+ *    Proof verification and fee enforcement are configurable for testing purposes.
+ *
+ * 3. **Req/resp & block proposals** — well-formedness checks only (metadata, size,
+ *    data, proof). Stored for re-execution; validity against state is not checked here.
+ *
+ * 4. **Block building** — re-validates against current state immediately before
+ *    sequencing. Catches invalid txs that entered via req/resp or block proposals.
+ *    Proof and data checks are skipped since they were verified on entry.
+ *
+ * 5. **Pending pool migration** — when unmined txs (e.g. from req/resp or block
+ *    proposals) are migrated to the pending pool, the pool runs the state-dependent
+ *    checks they missed: double-spend, block header, gas limits, and timestamps.
+ *    This runs on every tx potentially entering the pending pool.
+ */
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { LoggerBindings } from '@aztec/foundation/log';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { GasFees } from '@aztec/stdlib/gas';
-import type { AllowedElement, ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { AllowedElement, ClientProtocolCircuitVerifier, MerkleTreeReadOperations, PublicProcessorValidator, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
-import type { Tx, TxValidationResult, TxValidator } from '@aztec/stdlib/tx';
+import type { GlobalVariables, Tx, TxValidationResult, TxValidator } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
-export interface MessageValidator {
+import type { TxMetaData } from '../../mem_pools/tx_pool_v2/tx_metadata.js';
+/**
+ * A validator paired with a peer penalty severity.
+ * Used for gossip validation where each validator's failure triggers a peer penalization
+ * with the associated severity level.
+ */
+export interface TransactionValidator {
     validator: {
         validateTx(tx: Tx): Promise<TxValidationResult>;
     };
     severity: PeerErrorSeverity;
 }
-export declare function createTxMessageValidators(timestamp: UInt64, blockNumber: BlockNumber, worldStateSynchronizer: WorldStateSynchronizer, gasFees: GasFees, l1ChainId: number, rollupVersion: number, protocolContractsHash: Fr, contractDataSource: ContractDataSource, proofVerifier: ClientProtocolCircuitVerifier, txsPermitted: boolean, allowedInSetup?: AllowedElement[], bindings?: LoggerBindings): Record<string, MessageValidator>[];
-export declare function createTxReqRespValidator(verifier: ClientProtocolCircuitVerifier, { l1ChainId, rollupVersion }: {
+/**
+ * First stage of gossip validation — fast checks run before the pool pre-check.
+ *
+ * If any validator fails, the peer is penalized and the tx is rejected immediately,
+ * without consulting the pool or running proof verification.
+ *
+ * The `doubleSpendValidator` failure is special-cased by the caller (`handleGossipedTx`)
+ * to determine severity based on how recently the nullifier appeared.
+ */
+export declare function createFirstStageTxValidationsForGossipedTransactions(timestamp: UInt64, blockNumber: BlockNumber, worldStateSynchronizer: WorldStateSynchronizer, gasFees: GasFees, l1ChainId: number, rollupVersion: number, protocolContractsHash: Fr, contractDataSource: ContractDataSource, txsPermitted: boolean, allowedInSetup?: AllowedElement[], bindings?: LoggerBindings, gasLimitOpts?: {
+    rollupManaLimit?: number;
+    maxBlockL2Gas?: number;
+    maxBlockDAGas?: number;
+}): Record<string, TransactionValidator>;
+/**
+ * Second stage of gossip validation — expensive proof verification.
+ *
+ * Only runs after the first stage passes AND `canAddPendingTx` confirms the pool would
+ * accept the tx. This avoids wasting CPU on proof verification for txs the pool would reject
+ * (e.g., duplicates, insufficient balance, pool full).
+ */
+export declare function createSecondStageTxValidationsForGossipedTransactions(proofVerifier: ClientProtocolCircuitVerifier, bindings?: LoggerBindings): Record<string, TransactionValidator>;
+/**
+ * Validators for txs received via req/resp or filestores.
+ * Checks well-formedness only — we must accept these for re-execution even if they
+ * are invalid against current state. State-dependent checks happen when the tx
+ * enters the pending pool or during block building.
+ */
+export declare function createTxValidatorForReqResponseReceivedTxs(verifier: ClientProtocolCircuitVerifier, { l1ChainId, rollupVersion }: {
     l1ChainId: number;
     rollupVersion: number;
 }, bindings?: LoggerBindings): TxValidator;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yeS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21zZ192YWxpZGF0b3JzL3R4X3ZhbGlkYXRvci9mYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUM5RCxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFHNUQsT0FBTyxLQUFLLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSxPQUFPLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNqRCxPQUFPLEtBQUssRUFDVixjQUFjLEVBQ2QsNkJBQTZCLEVBQzdCLHNCQUFzQixFQUN2QixNQUFNLGlDQUFpQyxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRXRELE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxrQkFBa0IsRUFBRSxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUM1RSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQWVsRCxNQUFNLFdBQVcsZ0JBQWdCO0lBQy9CLFNBQVMsRUFBRTtRQUNULFVBQVUsQ0FBQyxFQUFFLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO0tBQ2pELENBQUM7SUFDRixRQUFRLEVBQUUsaUJBQWlCLENBQUM7Q0FDN0I7QUFFRCx3QkFBZ0IseUJBQXlCLENBQ3ZDLFNBQVMsRUFBRSxNQUFNLEVBQ2pCLFdBQVcsRUFBRSxXQUFXLEVBQ3hCLHNCQUFzQixFQUFFLHNCQUFzQixFQUM5QyxPQUFPLEVBQUUsT0FBTyxFQUNoQixTQUFTLEVBQUUsTUFBTSxFQUNqQixhQUFhLEVBQUUsTUFBTSxFQUNyQixxQkFBcUIsRUFBRSxFQUFFLEVBQ3pCLGtCQUFrQixFQUFFLGtCQUFrQixFQUN0QyxhQUFhLEVBQUUsNkJBQTZCLEVBQzVDLFlBQVksRUFBRSxPQUFPLEVBQ3JCLGNBQWMsR0FBRSxjQUFjLEVBQU8sRUFDckMsUUFBUSxDQUFDLEVBQUUsY0FBYyxHQUN4QixNQUFNLENBQUMsTUFBTSxFQUFFLGdCQUFnQixDQUFDLEVBQUUsQ0F5RXBDO0FBRUQsd0JBQWdCLHdCQUF3QixDQUN0QyxRQUFRLEVBQUUsNkJBQTZCLEVBQ3ZDLEVBQ0UsU0FBUyxFQUNULGFBQWEsRUFDZCxFQUFFO0lBQ0QsU0FBUyxFQUFFLE1BQU0sQ0FBQztJQUNsQixhQUFhLEVBQUUsTUFBTSxDQUFDO0NBQ3ZCLEVBQ0QsUUFBUSxDQUFDLEVBQUUsY0FBYyxHQUN4QixXQUFXLENBZWIifQ==
+/**
+ * Validators for txs received in block proposals.
+ * Same as req/resp — well-formedness only. We must store these for block
+ * re-execution; their validity against state is checked during block building.
+ */
+export declare function createTxValidatorForBlockProposalReceivedTxs(verifier: ClientProtocolCircuitVerifier, { l1ChainId, rollupVersion }: {
+    l1ChainId: number;
+    rollupVersion: number;
+}, bindings?: LoggerBindings): TxValidator;
+/**
+ * Validators for unsolicited txs received over JSON-RPC (from a local wallet/PXE).
+ * Full validation — all state-dependent checks are run. Proof verification is optional
+ * (can be skipped for testing purposes). Fee enforcement is also optional (skipped for testing/dev).
+ * Called from `AztecNodeService.isValidTx()`.
+ */
+export declare function createTxValidatorForAcceptingTxsOverRPC(db: MerkleTreeReadOperations, contractDataSource: ContractDataSource, verifier: ClientProtocolCircuitVerifier | undefined, { l1ChainId, rollupVersion, setupAllowList, gasFees, skipFeeEnforcement, timestamp, blockNumber, txsPermitted, rollupManaLimit, maxBlockL2Gas, maxBlockDAGas }: {
+    l1ChainId: number;
+    rollupVersion: number;
+    setupAllowList: AllowedElement[];
+    gasFees: GasFees;
+    skipFeeEnforcement?: boolean;
+    timestamp: UInt64;
+    blockNumber: BlockNumber;
+    txsPermitted: boolean;
+    rollupManaLimit: number;
+    maxBlockL2Gas?: number;
+    maxBlockDAGas?: number;
+}, bindings?: LoggerBindings): TxValidator<Tx>;
+/**
+ * Validators for txs about to be included in a block by the sequencer.
+ * Re-validates against current state. This is where invalid txs that entered via
+ * req/resp or block proposals are caught — their invalidity is reported as part
+ * of block validation/attestation. Proof and data checks are omitted since they
+ * were already verified on entry.
+ * Called from `CheckpointBuilder.makeBlockBuilderDeps()`.
+ */
+export declare function createTxValidatorForBlockBuilding(db: MerkleTreeReadOperations, contractDataSource: ContractDataSource, globalVariables: GlobalVariables, setupAllowList: AllowedElement[], bindings?: LoggerBindings): PublicProcessorValidator;
+/**
+ * Validators for txs migrating to the pending pool.
+ *
+ * Txs that arrived via req/resp or block proposals only had well-formedness checks
+ * on receipt. When they fail to be mined and are migrated to the pending pool, we
+ * run the state-dependent checks they missed: double-spend, block header, gas limits,
+ * and timestamp expiry. This is run on EVERY tx potentially entering the pending pool
+ * — called inside `TxPoolV2Impl` during `addPendingTxs`, `prepareForSlot` (unprotect),
+ * `handlePrunedBlocks` (unmine), and startup hydration.
+ *
+ * Operates on `TxMetaData` rather than full `Tx` since metadata is pre-built by the pool.
+ * Injected into `TxPoolV2` as the `createTxValidator` factory in `TxPoolV2Dependencies`.
+ */
+export declare function createTxValidatorForTransactionsEnteringPendingTxPool(worldStateSynchronizer: WorldStateSynchronizer, timestamp: bigint, blockNumber: BlockNumber, gasLimitOpts: {
+    rollupManaLimit?: number;
+    maxBlockL2Gas?: number;
+    maxBlockDAGas?: number;
+}, bindings?: LoggerBindings): Promise<TxValidator<TxMetaData>>;
+/**
+ * Creates a function that checks whether a tx's setup-phase calls are on the allow list.
+ *
+ * Uses the `PhasesTxValidator` on the full Tx. The result is stored as a boolean
+ * flag in `TxMetaData.allowedSetupCalls` at receipt time, so the pending pool
+ * migration validator can check it without needing the full Tx or its dependencies.
+ */
+export declare function createCheckAllowedSetupCalls(contractDataSource: ContractDataSource, setupAllowList: AllowedElement[], getTimestamp: () => UInt64): (tx: Tx) => Promise<boolean>;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAG5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EACV,cAAc,EACd,6BAA6B,EAC7B,sBAAsB,EACvB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,KAAK,EAAE,EAAE,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC5E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAelD,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE;QACT,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;KACjD,CAAC;IACF,QAAQ,EAAE,iBAAiB,CAAC;CAC7B;AAED,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,WAAW,EACxB,sBAAsB,EAAE,sBAAsB,EAC9C,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,qBAAqB,EAAE,EAAE,EACzB,kBAAkB,EAAE,kBAAkB,EACtC,aAAa,EAAE,6BAA6B,EAC5C,YAAY,EAAE,OAAO,EACrB,cAAc,GAAE,cAAc,EAAO,EACrC,QAAQ,CAAC,EAAE,cAAc,GACxB,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAAE,CAyEpC;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,6BAA6B,EACvC,EACE,SAAS,EACT,aAAa,EACd,EAAE;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;CACvB,EACD,QAAQ,CAAC,EAAE,cAAc,GACxB,WAAW,CAeb"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAI5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EACV,cAAc,EACd,6BAA6B,EAC7B,wBAAwB,EACxB,wBAAwB,EACxB,sBAAsB,EACvB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,KAAK,EAAE,eAAe,EAAE,EAAE,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC7F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2CAA2C,CAAC;AAgB5E;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE;QACT,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;KACjD,CAAC;IACF,QAAQ,EAAE,iBAAiB,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,wBAAgB,oDAAoD,CAClE,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,WAAW,EACxB,sBAAsB,EAAE,sBAAsB,EAC9C,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,qBAAqB,EAAE,EAAE,EACzB,kBAAkB,EAAE,kBAAkB,EACtC,YAAY,EAAE,OAAO,EACrB,cAAc,GAAE,cAAc,EAAO,EACrC,QAAQ,CAAC,EAAE,cAAc,EACzB,YAAY,CAAC,EAAE;IAAE,eAAe,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1F,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CA0EtC;AAED;;;;;;GAMG;AACH,wBAAgB,qDAAqD,CACnE,aAAa,EAAE,6BAA6B,EAC5C,QAAQ,CAAC,EAAE,cAAc,GACxB,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAOtC;AAoCD;;;;;GAKG;AACH,wBAAgB,0CAA0C,CACxD,QAAQ,EAAE,6BAA6B,EACvC,EACE,SAAS,EACT,aAAa,EACd,EAAE;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;CACvB,EACD,QAAQ,CAAC,EAAE,cAAc,GACxB,WAAW,CAEb;AAED;;;;GAIG;AACH,wBAAgB,4CAA4C,CAC1D,QAAQ,EAAE,6BAA6B,EACvC,EACE,SAAS,EACT,aAAa,EACd,EAAE;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;CACvB,EACD,QAAQ,CAAC,EAAE,cAAc,GACxB,WAAW,CAEb;AAED;;;;;GAKG;AACH,wBAAgB,uCAAuC,CACrD,EAAE,EAAE,wBAAwB,EAC5B,kBAAkB,EAAE,kBAAkB,EACtC,QAAQ,EAAE,6BAA6B,GAAG,SAAS,EACnD,EACE,SAAS,EACT,aAAa,EACb,cAAc,EACd,OAAO,EACP,kBAAkB,EAClB,SAAS,EACT,WAAW,EACX,YAAY,EACZ,eAAe,EACf,aAAa,EACb,aAAa,EACd,EAAE;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,cAAc,EAAE,CAAC;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,OAAO,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,EACD,QAAQ,CAAC,EAAE,cAAc,GACxB,WAAW,CAAC,EAAE,CAAC,CA0CjB;AAED;;;;;;;GAOG;AACH,wBAAgB,iCAAiC,CAC/C,EAAE,EAAE,wBAAwB,EAC5B,kBAAkB,EAAE,kBAAkB,EACtC,eAAe,EAAE,eAAe,EAChC,cAAc,EAAE,cAAc,EAAE,EAChC,QAAQ,CAAC,EAAE,cAAc,GACxB,wBAAwB,CAiB1B;AA2BD;;;;;;;;;;;;GAYG;AACH,wBAAsB,qDAAqD,CACzE,sBAAsB,EAAE,sBAAsB,EAC9C,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE;IAAE,eAAe,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,EAC1F,QAAQ,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAqBlC;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,kBAAkB,EAAE,kBAAkB,EACtC,cAAc,EAAE,cAAc,EAAE,EAChC,YAAY,EAAE,MAAM,MAAM,GACzB,CAAC,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAM9B"}

package/dest/msg_validators/tx_validator/factory.js

@@ -1,4 +1,34 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
+/**
+ * Transaction validator factories for each tx entry point.
+ *
+ * Unsolicited transactions (gossip and RPC) are fully validated before acceptance.
+ * Transactions received via req/resp or block proposals are only checked for
+ * well-formedness because we must include them for block re-execution — they may
+ * ultimately be invalid, which is caught during block building and reported as
+ * part of block validation/attestation. See the README in this directory for the
+ * full validation strategy.
+ *
+ * 1. **Gossip** — full validation in two stages with a pool pre-check in between.
+ *    Stage 1 (fast): metadata, data, timestamps, double-spend, gas, phases, block header.
+ *    Pool pre-check: `canAddPendingTx` — skips proof verification if pool would reject.
+ *    Stage 2 (slow): proof verification.
+ *    Orchestrated by `handleGossipedTx` in `libp2p_service.ts`.
+ *
+ * 2. **JSON-RPC** — full validation including all state-dependent checks.
+ *    Proof verification and fee enforcement are configurable for testing purposes.
+ *
+ * 3. **Req/resp & block proposals** — well-formedness checks only (metadata, size,
+ *    data, proof). Stored for re-execution; validity against state is not checked here.
+ *
+ * 4. **Block building** — re-validates against current state immediately before
+ *    sequencing. Catches invalid txs that entered via req/resp or block proposals.
+ *    Proof and data checks are skipped since they were verified on entry.
+ *
+ * 5. **Pending pool migration** — when unmined txs (e.g. from req/resp or block
+ *    proposals) are migrated to the pending pool, the pool runs the state-dependent
+ *    checks they missed: double-spend, block header, gas limits, and timestamps.
+ *    This runs on every tx potentially entering the pending pool.
+ */ import { Fr } from '@aztec/foundation/curves/bn254';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { ProtocolContractAddress, protocolContractsHash } from '@aztec/protocol-contracts';
 import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
@@ -6,79 +36,236 @@ import { DatabasePublicStateSource, MerkleTreeId } from '@aztec/stdlib/trees';
 import { AggregateTxValidator } from './aggregate_tx_validator.js';
 import { ArchiveCache } from './archive_cache.js';
 import { BlockHeaderTxValidator } from './block_header_validator.js';
+import { ContractInstanceTxValidator } from './contract_instance_validator.js';
 import { DataTxValidator } from './data_validator.js';
 import { DoubleSpendTxValidator } from './double_spend_validator.js';
-import { GasTxValidator } from './gas_validator.js';
+import { GasLimitsValidator, GasTxValidator } from './gas_validator.js';
 import { MetadataTxValidator } from './metadata_validator.js';
-import { PhasesTxValidator } from './phases_validator.js';
+import { NullifierCache } from './nullifier_cache.js';
+import { AllowedSetupCallsMetaValidator, PhasesTxValidator } from './phases_validator.js';
 import { SizeTxValidator } from './size_validator.js';
 import { TimestampTxValidator } from './timestamp_validator.js';
 import { TxPermittedValidator } from './tx_permitted_validator.js';
 import { TxProofValidator } from './tx_proof_validator.js';
-export function createTxMessageValidators(timestamp, blockNumber, worldStateSynchronizer, gasFees, l1ChainId, rollupVersion, protocolContractsHash, contractDataSource, proofVerifier, txsPermitted, allowedInSetup = [], bindings) {
+/**
+ * First stage of gossip validation — fast checks run before the pool pre-check.
+ *
+ * If any validator fails, the peer is penalized and the tx is rejected immediately,
+ * without consulting the pool or running proof verification.
+ *
+ * The `doubleSpendValidator` failure is special-cased by the caller (`handleGossipedTx`)
+ * to determine severity based on how recently the nullifier appeared.
+ */ export function createFirstStageTxValidationsForGossipedTransactions(timestamp, blockNumber, worldStateSynchronizer, gasFees, l1ChainId, rollupVersion, protocolContractsHash, contractDataSource, txsPermitted, allowedInSetup = [], bindings, gasLimitOpts) {
     const merkleTree = worldStateSynchronizer.getCommitted();
-    return [
-        {
-            txsPermittedValidator: {
-                validator: new TxPermittedValidator(txsPermitted, bindings),
-                severity: PeerErrorSeverity.MidToleranceError
-            },
-            dataValidator: {
-                validator: new DataTxValidator(bindings),
-                severity: PeerErrorSeverity.HighToleranceError
-            },
-            metadataValidator: {
-                validator: new MetadataTxValidator({
-                    l1ChainId: new Fr(l1ChainId),
-                    rollupVersion: new Fr(rollupVersion),
-                    protocolContractsHash,
-                    vkTreeRoot: getVKTreeRoot()
-                }, bindings),
-                severity: PeerErrorSeverity.HighToleranceError
-            },
-            timestampValidator: {
-                validator: new TimestampTxValidator({
-                    timestamp,
-                    blockNumber
-                }, bindings),
-                severity: PeerErrorSeverity.MidToleranceError
-            },
-            doubleSpendValidator: {
-                validator: new DoubleSpendTxValidator({
-                    nullifiersExist: async (nullifiers)=>{
-                        const merkleTree = worldStateSynchronizer.getCommitted();
-                        const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
-                        return indices.map((index)=>index !== undefined);
-                    }
-                }, bindings),
-                severity: PeerErrorSeverity.HighToleranceError
-            },
-            gasValidator: {
-                validator: new GasTxValidator(new DatabasePublicStateSource(merkleTree), ProtocolContractAddress.FeeJuice, gasFees, bindings),
-                severity: PeerErrorSeverity.HighToleranceError
-            },
-            phasesValidator: {
-                validator: new PhasesTxValidator(contractDataSource, allowedInSetup, timestamp, bindings),
-                severity: PeerErrorSeverity.MidToleranceError
-            },
-            blockHeaderValidator: {
-                validator: new BlockHeaderTxValidator(new ArchiveCache(merkleTree), bindings),
-                severity: PeerErrorSeverity.HighToleranceError
-            }
+    return {
+        timestampValidator: {
+            validator: new TimestampTxValidator({
+                timestamp,
+                blockNumber
+            }, bindings),
+            severity: PeerErrorSeverity.HighToleranceError
         },
-        {
-            proofValidator: {
-                validator: new TxProofValidator(proofVerifier, bindings),
-                severity: PeerErrorSeverity.MidToleranceError
-            }
+        txsPermittedValidator: {
+            validator: new TxPermittedValidator(txsPermitted, bindings),
+            severity: PeerErrorSeverity.MidToleranceError
+        },
+        txSizeValidator: {
+            validator: new SizeTxValidator(bindings),
+            severity: PeerErrorSeverity.MidToleranceError
+        },
+        metadataValidator: {
+            validator: new MetadataTxValidator({
+                l1ChainId: new Fr(l1ChainId),
+                rollupVersion: new Fr(rollupVersion),
+                protocolContractsHash,
+                vkTreeRoot: getVKTreeRoot()
+            }, bindings),
+            severity: PeerErrorSeverity.MidToleranceError
+        },
+        phasesValidator: {
+            validator: new PhasesTxValidator(contractDataSource, allowedInSetup, timestamp, bindings),
+            severity: PeerErrorSeverity.MidToleranceError
+        },
+        blockHeaderValidator: {
+            validator: new BlockHeaderTxValidator(new ArchiveCache(merkleTree), bindings),
+            severity: PeerErrorSeverity.HighToleranceError
+        },
+        doubleSpendValidator: {
+            validator: new DoubleSpendTxValidator({
+                nullifiersExist: async (nullifiers)=>{
+                    const merkleTree = worldStateSynchronizer.getCommitted();
+                    const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
+                    return indices.map((index)=>index !== undefined);
+                }
+            }, bindings),
+            severity: PeerErrorSeverity.MidToleranceError
+        },
+        gasValidator: {
+            validator: new GasTxValidator(new DatabasePublicStateSource(merkleTree), ProtocolContractAddress.FeeJuice, gasFees, bindings, gasLimitOpts),
+            severity: PeerErrorSeverity.MidToleranceError
+        },
+        dataValidator: {
+            validator: new DataTxValidator(bindings),
+            severity: PeerErrorSeverity.MidToleranceError
+        },
+        contractInstanceValidator: {
+            validator: new ContractInstanceTxValidator(bindings),
+            severity: PeerErrorSeverity.MidToleranceError
         }
-    ];
+    };
+}
+/**
+ * Second stage of gossip validation — expensive proof verification.
+ *
+ * Only runs after the first stage passes AND `canAddPendingTx` confirms the pool would
+ * accept the tx. This avoids wasting CPU on proof verification for txs the pool would reject
+ * (e.g., duplicates, insufficient balance, pool full).
+ */ export function createSecondStageTxValidationsForGossipedTransactions(proofVerifier, bindings) {
+    return {
+        proofValidator: {
+            validator: new TxProofValidator(proofVerifier, bindings),
+            severity: PeerErrorSeverity.LowToleranceError
+        }
+    };
 }
-export function createTxReqRespValidator(verifier, { l1ChainId, rollupVersion }, bindings) {
+/**
+ * Well-formedness checks only: metadata, size, data, and proof.
+ * Used for req/resp and block proposal txs. These txs must be accepted for block
+ * re-execution even though they may be invalid against current state — that is
+ * caught later by the block building validator.
+ */ function createTxValidatorForMinimumTxIntegrityChecks(verifier, { l1ChainId, rollupVersion }, bindings) {
     return new AggregateTxValidator(new MetadataTxValidator({
         l1ChainId: new Fr(l1ChainId),
         rollupVersion: new Fr(rollupVersion),
         protocolContractsHash,
         vkTreeRoot: getVKTreeRoot()
-    }, bindings), new SizeTxValidator(bindings), new DataTxValidator(bindings), new TxProofValidator(verifier, bindings));
+    }, bindings), new SizeTxValidator(bindings), new DataTxValidator(bindings), new ContractInstanceTxValidator(bindings), new TxProofValidator(verifier, bindings));
+}
+/**
+ * Validators for txs received via req/resp or filestores.
+ * Checks well-formedness only — we must accept these for re-execution even if they
+ * are invalid against current state. State-dependent checks happen when the tx
+ * enters the pending pool or during block building.
+ */ export function createTxValidatorForReqResponseReceivedTxs(verifier, { l1ChainId, rollupVersion }, bindings) {
+    return createTxValidatorForMinimumTxIntegrityChecks(verifier, {
+        l1ChainId,
+        rollupVersion
+    }, bindings);
+}
+/**
+ * Validators for txs received in block proposals.
+ * Same as req/resp — well-formedness only. We must store these for block
+ * re-execution; their validity against state is checked during block building.
+ */ export function createTxValidatorForBlockProposalReceivedTxs(verifier, { l1ChainId, rollupVersion }, bindings) {
+    return createTxValidatorForMinimumTxIntegrityChecks(verifier, {
+        l1ChainId,
+        rollupVersion
+    }, bindings);
+}
+/**
+ * Validators for unsolicited txs received over JSON-RPC (from a local wallet/PXE).
+ * Full validation — all state-dependent checks are run. Proof verification is optional
+ * (can be skipped for testing purposes). Fee enforcement is also optional (skipped for testing/dev).
+ * Called from `AztecNodeService.isValidTx()`.
+ */ export function createTxValidatorForAcceptingTxsOverRPC(db, contractDataSource, verifier, { l1ChainId, rollupVersion, setupAllowList, gasFees, skipFeeEnforcement, timestamp, blockNumber, txsPermitted, rollupManaLimit, maxBlockL2Gas, maxBlockDAGas }, bindings) {
+    const validators = [
+        new TxPermittedValidator(txsPermitted, bindings),
+        new TimestampTxValidator({
+            timestamp,
+            blockNumber
+        }, bindings),
+        new SizeTxValidator(bindings),
+        new MetadataTxValidator({
+            l1ChainId: new Fr(l1ChainId),
+            rollupVersion: new Fr(rollupVersion),
+            protocolContractsHash,
+            vkTreeRoot: getVKTreeRoot()
+        }, bindings),
+        new PhasesTxValidator(contractDataSource, setupAllowList, timestamp, bindings),
+        new BlockHeaderTxValidator(new ArchiveCache(db), bindings),
+        new DoubleSpendTxValidator(new NullifierCache(db), bindings),
+        new DataTxValidator(bindings),
+        new ContractInstanceTxValidator(bindings)
+    ];
+    if (!skipFeeEnforcement) {
+        validators.push(new GasTxValidator(new DatabasePublicStateSource(db), ProtocolContractAddress.FeeJuice, gasFees, bindings, {
+            rollupManaLimit,
+            maxBlockL2Gas,
+            maxBlockDAGas
+        }));
+    }
+    if (verifier) {
+        validators.push(new TxProofValidator(verifier, bindings));
+    }
+    return new AggregateTxValidator(...validators);
+}
+/**
+ * Validators for txs about to be included in a block by the sequencer.
+ * Re-validates against current state. This is where invalid txs that entered via
+ * req/resp or block proposals are caught — their invalidity is reported as part
+ * of block validation/attestation. Proof and data checks are omitted since they
+ * were already verified on entry.
+ * Called from `CheckpointBuilder.makeBlockBuilderDeps()`.
+ */ export function createTxValidatorForBlockBuilding(db, contractDataSource, globalVariables, setupAllowList, bindings) {
+    const nullifierCache = new NullifierCache(db);
+    const archiveCache = new ArchiveCache(db);
+    const publicStateSource = new DatabasePublicStateSource(db);
+    return {
+        preprocessValidator: createTxValidatorForValidatingAgainstCurrentState(nullifierCache, archiveCache, publicStateSource, contractDataSource, globalVariables, setupAllowList, bindings),
+        nullifierCache
+    };
+}
+function createTxValidatorForValidatingAgainstCurrentState(nullifierSource, archiveSource, publicStateSource, contractDataSource, globalVariables, setupAllowList, bindings) {
+    // We don't include the TxProofValidator nor the DataTxValidator here because they are already checked by the time we get to block building.
+    return new AggregateTxValidator(new TimestampTxValidator({
+        timestamp: globalVariables.timestamp,
+        blockNumber: globalVariables.blockNumber
+    }, bindings), new PhasesTxValidator(contractDataSource, setupAllowList, globalVariables.timestamp, bindings), new BlockHeaderTxValidator(archiveSource, bindings), new DoubleSpendTxValidator(nullifierSource, bindings), new GasTxValidator(publicStateSource, ProtocolContractAddress.FeeJuice, globalVariables.gasFees, bindings));
+}
+/**
+ * Validators for txs migrating to the pending pool.
+ *
+ * Txs that arrived via req/resp or block proposals only had well-formedness checks
+ * on receipt. When they fail to be mined and are migrated to the pending pool, we
+ * run the state-dependent checks they missed: double-spend, block header, gas limits,
+ * and timestamp expiry. This is run on EVERY tx potentially entering the pending pool
+ * — called inside `TxPoolV2Impl` during `addPendingTxs`, `prepareForSlot` (unprotect),
+ * `handlePrunedBlocks` (unmine), and startup hydration.
+ *
+ * Operates on `TxMetaData` rather than full `Tx` since metadata is pre-built by the pool.
+ * Injected into `TxPoolV2` as the `createTxValidator` factory in `TxPoolV2Dependencies`.
+ */ export async function createTxValidatorForTransactionsEnteringPendingTxPool(worldStateSynchronizer, timestamp, blockNumber, gasLimitOpts, bindings) {
+    await worldStateSynchronizer.syncImmediate();
+    const merkleTree = worldStateSynchronizer.getCommitted();
+    const nullifierSource = {
+        nullifiersExist: async (nullifiers)=>{
+            const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
+            return indices.map((index)=>index !== undefined);
+        }
+    };
+    const archiveSource = {
+        getArchiveIndices: (archives)=>{
+            return merkleTree.findLeafIndices(MerkleTreeId.ARCHIVE, archives);
+        }
+    };
+    return new AggregateTxValidator(new GasLimitsValidator({
+        ...gasLimitOpts,
+        bindings
+    }), new TimestampTxValidator({
+        timestamp,
+        blockNumber
+    }, bindings), new DoubleSpendTxValidator(nullifierSource, bindings), new BlockHeaderTxValidator(archiveSource, bindings), new AllowedSetupCallsMetaValidator(bindings));
+}
+/**
+ * Creates a function that checks whether a tx's setup-phase calls are on the allow list.
+ *
+ * Uses the `PhasesTxValidator` on the full Tx. The result is stored as a boolean
+ * flag in `TxMetaData.allowedSetupCalls` at receipt time, so the pending pool
+ * migration validator can check it without needing the full Tx or its dependencies.
+ */ export function createCheckAllowedSetupCalls(contractDataSource, setupAllowList, getTimestamp) {
+    return async (tx)=>{
+        const validator = new PhasesTxValidator(contractDataSource, setupAllowList, getTimestamp());
+        const result = await validator.validateTx(tx);
+        return result.result === 'valid';
+    };
 }