@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.017a351

package/dest/msg_validators/tx_validator/index.js

@@ -4,3 +4,15 @@ export * from './double_spend_validator.js';
 export * from './metadata_validator.js';
 export * from './tx_proof_validator.js';
 export * from './block_header_validator.js';
+export * from './gas_validator.js';
+export * from './phases_validator.js';
+export * from './test_utils.js';
+export * from './allowed_public_setup.js';
+export * from './allowed_setup_helpers.js';
+export * from './archive_cache.js';
+export * from './tx_permitted_validator.js';
+export * from './timestamp_validator.js';
+export * from './size_validator.js';
+export * from './factory.js';
+export * from './tx_validation_cache.js';
+export * from './cached_tx_validator.js';

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

@@ -1,10 +1,15 @@
-import type { Fr } from '@aztec/foundation/fields';
+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';
 export declare class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     #private;
-    private chainId;
-    private blockNumber;
-    constructor(chainId: Fr, blockNumber: Fr);
+    private values;
+    constructor(values: {
+        l1ChainId: Fr;
+        rollupVersion: Fr;
+        vkTreeRoot: Fr;
+        protocolContractsHash: Fr;
+    }, bindings?: LoggerBindings);
     validateTx(tx: T): Promise<TxValidationResult>;
 }
-//# sourceMappingURL=metadata_validator.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0YWRhdGFfdmFsaWRhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbXNnX3ZhbGlkYXRvcnMvdHhfdmFsaWRhdG9yL21ldGFkYXRhX3ZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN6RCxPQUFPLEVBQWUsS0FBSyxjQUFjLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFDdkYsT0FBTyxFQUNMLEtBQUssS0FBSyxFQUtWLEtBQUssa0JBQWtCLEVBQ3ZCLEtBQUssV0FBVyxFQUNqQixNQUFNLGtCQUFrQixDQUFDO0FBRTFCLHFCQUFhLG1CQUFtQixDQUFDLENBQUMsU0FBUyxLQUFLLENBQUUsWUFBVyxXQUFXLENBQUMsQ0FBQyxDQUFDOztJQUl2RSxPQUFPLENBQUMsTUFBTTtJQURoQixZQUNVLE1BQU0sRUFBRTtRQUNkLFNBQVMsRUFBRSxFQUFFLENBQUM7UUFDZCxhQUFhLEVBQUUsRUFBRSxDQUFDO1FBQ2xCLFVBQVUsRUFBRSxFQUFFLENBQUM7UUFDZixxQkFBcUIsRUFBRSxFQUFFLENBQUM7S0FDM0IsRUFDRCxRQUFRLENBQUMsRUFBRSxjQUFjLEVBRzFCO0lBRUQsVUFBVSxDQUFDLEVBQUUsRUFBRSxDQUFDLEdBQUcsT0FBTyxDQUFDLGtCQUFrQixDQUFDLENBdUI3QztDQXFERiJ9

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

@@ -1 +1 @@
-{"version":3,"file":"metadata_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/metadata_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,qBAAa,mBAAmB,CAAC,CAAC,SAAS,KAAK,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;IAG7D,OAAO,CAAC,OAAO;IAAM,OAAO,CAAC,WAAW;gBAAhC,OAAO,EAAE,EAAE,EAAU,WAAW,EAAE,EAAE;IAElD,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAsCrD"}
+{"version":3,"file":"metadata_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/metadata_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,EACL,KAAK,KAAK,EAKV,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAE1B,qBAAa,mBAAmB,CAAC,CAAC,SAAS,KAAK,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;IAIvE,OAAO,CAAC,MAAM;IADhB,YACU,MAAM,EAAE;QACd,SAAS,EAAE,EAAE,CAAC;QACd,aAAa,EAAE,EAAE,CAAC;QAClB,UAAU,EAAE,EAAE,CAAC;QACf,qBAAqB,EAAE,EAAE,CAAC;KAC3B,EACD,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAED,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAuB7C;CAqDF"}

package/dest/msg_validators/tx_validator/metadata_validator.js

@@ -1,41 +1,60 @@
 import { createLogger } from '@aztec/foundation/log';
-import { Tx } from '@aztec/stdlib/tx';
+import { TX_ERROR_INCORRECT_L1_CHAIN_ID, TX_ERROR_INCORRECT_PROTOCOL_CONTRACTS_HASH, TX_ERROR_INCORRECT_ROLLUP_VERSION, TX_ERROR_INCORRECT_VK_TREE_ROOT } from '@aztec/stdlib/tx';
 export class MetadataTxValidator {
-    chainId;
-    blockNumber;
+    values;
     #log;
-    constructor(chainId, blockNumber){
-        this.chainId = chainId;
-        this.blockNumber = blockNumber;
-        this.#log = createLogger('p2p:tx_validator:tx_metadata');
+    constructor(values, bindings){
+        this.values = values;
+        this.#log = createLogger('p2p:tx_validator:tx_metadata', bindings);
     }
-    async validateTx(tx) {
+    validateTx(tx) {
         const errors = [];
-        if (!await this.#hasCorrectChainId(tx)) {
-            errors.push('Incorrect chain id');
+        if (!this.#hasCorrectL1ChainId(tx)) {
+            errors.push(`${TX_ERROR_INCORRECT_L1_CHAIN_ID} (tx: ${tx.data.constants.txContext.chainId.toNumber()}, expected: ${this.values.l1ChainId.toNumber()})`);
         }
-        if (!await this.#isValidForBlockNumber(tx)) {
-            errors.push('Invalid block number');
+        if (!this.#hasCorrectRollupVersion(tx)) {
+            errors.push(`${TX_ERROR_INCORRECT_ROLLUP_VERSION} (tx: ${tx.data.constants.txContext.version.toNumber()}, expected: ${this.values.rollupVersion.toNumber()})`);
         }
-        return errors.length > 0 ? {
+        if (!this.#hasCorrectVkTreeRoot(tx)) {
+            errors.push(`${TX_ERROR_INCORRECT_VK_TREE_ROOT} (tx: ${tx.data.constants.vkTreeRoot.toString()}, expected: ${this.values.vkTreeRoot.toString()})`);
+        }
+        if (!this.#hasCorrectprotocolContractsHash(tx)) {
+            errors.push(`${TX_ERROR_INCORRECT_PROTOCOL_CONTRACTS_HASH} (tx: ${tx.data.constants.protocolContractsHash.toString()}, expected: ${this.values.protocolContractsHash.toString()})`);
+        }
+        return Promise.resolve(errors.length > 0 ? {
             result: 'invalid',
             reason: errors
         } : {
             result: 'valid'
-        };
+        });
+    }
+    #hasCorrectVkTreeRoot(tx) {
+        // This gets implicitly tested in the proof validator, but we can get a much cheaper check here by looking early at the vk.
+        if (!tx.data.constants.vkTreeRoot.equals(this.values.vkTreeRoot)) {
+            this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect vk tree root ${tx.data.constants.vkTreeRoot.toString()} != ${this.values.vkTreeRoot.toString()}`);
+            return false;
+        } else {
+            return true;
+        }
+    }
+    #hasCorrectprotocolContractsHash(tx) {
+        if (!tx.data.constants.protocolContractsHash.equals(this.values.protocolContractsHash)) {
+            this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect protocol contracts hash ${tx.data.constants.protocolContractsHash.toString()} != ${this.values.protocolContractsHash.toString()}`);
+            return false;
+        }
+        return true;
     }
-    async #hasCorrectChainId(tx) {
-        if (!tx.data.constants.txContext.chainId.equals(this.chainId)) {
-            this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} because of incorrect chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.chainId.toNumber()}`);
+    #hasCorrectL1ChainId(tx) {
+        if (!tx.data.constants.txContext.chainId.equals(this.values.l1ChainId)) {
+            this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect L1 chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.values.l1ChainId.toNumber()}`);
             return false;
         } else {
             return true;
         }
     }
-    async #isValidForBlockNumber(tx) {
-        const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
-        if (maxBlockNumber.isSome && maxBlockNumber.value < this.blockNumber) {
-            this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for low max block number. Tx max block number: ${maxBlockNumber.value}, current block number: ${this.blockNumber}.`);
+    #hasCorrectRollupVersion(tx) {
+        if (!tx.data.constants.txContext.version.equals(this.values.rollupVersion)) {
+            this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect rollup version ${tx.data.constants.txContext.version.toNumber()} != ${this.values.rollupVersion.toNumber()}`);
             return false;
         } else {
             return true;

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

@@ -0,0 +1,14 @@
+import type { NullifierSource } from '@aztec/p2p';
+import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+/**
+ * Implements a nullifier source by checking a DB and an in-memory collection.
+ * Intended for validating transactions as they are added to a block.
+ */
+export declare class NullifierCache implements NullifierSource {
+    private db;
+    nullifiers: Set<string>;
+    constructor(db: MerkleTreeReadOperations);
+    nullifiersExist(nullifiers: Buffer[]): Promise<boolean[]>;
+    addNullifiers(nullifiers: Buffer[]): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVsbGlmaWVyX2NhY2hlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbXNnX3ZhbGlkYXRvcnMvdHhfdmFsaWRhdG9yL251bGxpZmllcl9jYWNoZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFDbEQsT0FBTyxLQUFLLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUdoRjs7O0dBR0c7QUFDSCxxQkFBYSxjQUFlLFlBQVcsZUFBZTtJQUd4QyxPQUFPLENBQUMsRUFBRTtJQUZ0QixVQUFVLEVBQUUsR0FBRyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBRXhCLFlBQW9CLEVBQUUsRUFBRSx3QkFBd0IsRUFFL0M7SUFFWSxlQUFlLENBQUMsVUFBVSxFQUFFLE1BQU0sRUFBRSxHQUFHLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQU9yRTtJQUVNLGFBQWEsQ0FBQyxVQUFVLEVBQUUsTUFBTSxFQUFFLFFBSXhDO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"nullifier_cache.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/nullifier_cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAGhF;;;GAGG;AACH,qBAAa,cAAe,YAAW,eAAe;IAGxC,OAAO,CAAC,EAAE;IAFtB,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAExB,YAAoB,EAAE,EAAE,wBAAwB,EAE/C;IAEY,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAOrE;IAEM,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,QAIxC;CACF"}

package/dest/msg_validators/tx_validator/nullifier_cache.js

@@ -0,0 +1,24 @@
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+/**
+ * Implements a nullifier source by checking a DB and an in-memory collection.
+ * Intended for validating transactions as they are added to a block.
+ */ export class NullifierCache {
+    db;
+    nullifiers;
+    constructor(db){
+        this.db = db;
+        this.nullifiers = new Set();
+    }
+    async nullifiersExist(nullifiers) {
+        const cacheResults = nullifiers.map((n)=>this.nullifiers.has(n.toString()));
+        const toCheckDb = nullifiers.filter((_n, index)=>!cacheResults[index]);
+        const dbHits = await this.db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, toCheckDb);
+        let dbIndex = 0;
+        return nullifiers.map((_n, index)=>cacheResults[index] || dbHits[dbIndex++] !== undefined);
+    }
+    addNullifiers(nullifiers) {
+        for (const nullifier of nullifiers){
+            this.nullifiers.add(nullifier.toString());
+        }
+    }
+}

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

@@ -0,0 +1,35 @@
+import { type LoggerBindings } from '@aztec/foundation/log';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
+import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+export declare class PhasesTxValidator implements TxValidator<Tx> {
+    #private;
+    private setupAllowList;
+    private timestamp;
+    private contractsDB;
+    constructor(contracts: ContractDataSource, setupAllowList: AllowedElement[], timestamp: UInt64, bindings?: LoggerBindings);
+    validateTx(tx: Tx): Promise<TxValidationResult>;
+    private checkAllowList;
+}
+/** Structural interface for the allowed-setup-calls flag check. */
+export interface HasAllowedSetupCallsData {
+    txHash: {
+        toString(): string;
+    };
+    allowedSetupCalls: boolean;
+}
+/**
+ * Validates that a transaction's setup-phase calls were allowed at receipt time.
+ *
+ * Checks the precomputed `allowedSetupCalls` flag on TxMetaData. The flag is
+ * computed by running the PhasesTxValidator on the full Tx when it first enters
+ * the pool. This lightweight validator is used during pending pool migration to
+ * reject txs whose setup calls are not on the allow list.
+ */
+export declare class AllowedSetupCallsMetaValidator<T extends HasAllowedSetupCallsData> implements TxValidator<T> {
+    #private;
+    constructor(bindings?: LoggerBindings);
+    validateTx(tx: T): Promise<TxValidationResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGhhc2VzX3ZhbGlkYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21zZ192YWxpZGF0b3JzL3R4X3ZhbGlkYXRvci9waGFzZXNfdmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBZSxLQUFLLGNBQWMsRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUd2RixPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ2pFLE9BQU8sS0FBSyxFQUFFLGNBQWMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ3RFLE9BQU8sRUFRTCxFQUFFLEVBRUYsS0FBSyxrQkFBa0IsRUFDdkIsS0FBSyxXQUFXLEVBQ2pCLE1BQU0sa0JBQWtCLENBQUM7QUFDMUIsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFbEQscUJBQWEsaUJBQWtCLFlBQVcsV0FBVyxDQUFDLEVBQUUsQ0FBQzs7SUFNckQsT0FBTyxDQUFDLGNBQWM7SUFDdEIsT0FBTyxDQUFDLFNBQVM7SUFMbkIsT0FBTyxDQUFDLFdBQVcsQ0FBb0I7SUFFdkMsWUFDRSxTQUFTLEVBQUUsa0JBQWtCLEVBQ3JCLGNBQWMsRUFBRSxjQUFjLEVBQUUsRUFDaEMsU0FBUyxFQUFFLE1BQU0sRUFDekIsUUFBUSxDQUFDLEVBQUUsY0FBYyxFQUkxQjtJQUVLLFVBQVUsQ0FBQyxFQUFFLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQyxrQkFBa0IsQ0FBQyxDQXNDcEQ7WUFHYSxjQUFjO0NBa0U3QjtBQUVELG1FQUFtRTtBQUNuRSxNQUFNLFdBQVcsd0JBQXdCO0lBQ3ZDLE1BQU0sRUFBRTtRQUFFLFFBQVEsSUFBSSxNQUFNLENBQUE7S0FBRSxDQUFDO0lBQy9CLGlCQUFpQixFQUFFLE9BQU8sQ0FBQztDQUM1QjtBQUVEOzs7Ozs7O0dBT0c7QUFDSCxxQkFBYSw4QkFBOEIsQ0FBQyxDQUFDLFNBQVMsd0JBQXdCLENBQUUsWUFBVyxXQUFXLENBQUMsQ0FBQyxDQUFDOztJQUd2RyxZQUFZLFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFFcEM7SUFFRCxVQUFVLENBQUMsRUFBRSxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUMsa0JBQWtCLENBQUMsQ0FNN0M7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"phases_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/phases_validator.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAGvF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAQL,EAAE,EAEF,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,qBAAa,iBAAkB,YAAW,WAAW,CAAC,EAAE,CAAC;;IAMrD,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,SAAS;IALnB,OAAO,CAAC,WAAW,CAAoB;IAEvC,YACE,SAAS,EAAE,kBAAkB,EACrB,cAAc,EAAE,cAAc,EAAE,EAChC,SAAS,EAAE,MAAM,EACzB,QAAQ,CAAC,EAAE,cAAc,EAI1B;IAEK,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAsCpD;YAGa,cAAc;CAkE7B;AAED,mEAAmE;AACnE,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE;QAAE,QAAQ,IAAI,MAAM,CAAA;KAAE,CAAC;IAC/B,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,qBAAa,8BAA8B,CAAC,CAAC,SAAS,wBAAwB,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;IAGvG,YAAY,QAAQ,CAAC,EAAE,cAAc,EAEpC;IAED,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAM7C;CACF"}

package/dest/msg_validators/tx_validator/phases_validator.js

@@ -0,0 +1,141 @@
+import { NULL_MSG_SENDER_CONTRACT_ADDRESS } from '@aztec/constants';
+import { createLogger } from '@aztec/foundation/log';
+import { PublicContractsDB, getCallRequestsWithCalldataByPhase } from '@aztec/simulator/server';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { TX_ERROR_DURING_VALIDATION, TX_ERROR_SETUP_FUNCTION_NOT_ALLOWED, TX_ERROR_SETUP_FUNCTION_UNKNOWN_CONTRACT, TX_ERROR_SETUP_NULL_MSG_SENDER, TX_ERROR_SETUP_ONLY_SELF_WRONG_SENDER, TX_ERROR_SETUP_WRONG_CALLDATA_LENGTH, TxExecutionPhase } from '@aztec/stdlib/tx';
+export class PhasesTxValidator {
+    setupAllowList;
+    timestamp;
+    #log;
+    contractsDB;
+    constructor(contracts, setupAllowList, timestamp, bindings){
+        this.setupAllowList = setupAllowList;
+        this.timestamp = timestamp;
+        this.#log = createLogger('sequencer:tx_validator:tx_phases', bindings);
+        this.contractsDB = new PublicContractsDB(contracts, bindings);
+    }
+    async validateTx(tx) {
+        this.contractsDB.createCheckpoint();
+        try {
+            // TODO(@spalladino): We add this just to handle public authwit-check calls during setup
+            // which are needed for public FPC flows, but fail if the account contract hasnt been deployed yet,
+            // which is what we're trying to do as part of the current txs.
+            // We only need to create/revert checkpoint here because of this addNewContracts call.
+            this.contractsDB.addNewContracts(tx);
+            if (!tx.data.forPublic) {
+                this.#log.debug(`Tx ${tx.getTxHash().toString()} does not contain enqueued public functions. Skipping phases validation.`);
+                return {
+                    result: 'valid'
+                };
+            }
+            const setupFns = getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP);
+            for (const setupFn of setupFns){
+                const rejectionReason = await this.checkAllowList(setupFn, this.setupAllowList);
+                if (rejectionReason) {
+                    this.#log.verbose(`Rejecting tx ${tx.getTxHash().toString()} because it calls setup function not on allow list: ${setupFn.request.contractAddress}:${setupFn.functionSelector}`, {
+                        allowList: this.setupAllowList
+                    });
+                    return {
+                        result: 'invalid',
+                        reason: [
+                            rejectionReason
+                        ]
+                    };
+                }
+            }
+            return {
+                result: 'valid'
+            };
+        } catch (err) {
+            this.#log.error(`Error validating phases for tx`, err);
+            return {
+                result: 'invalid',
+                reason: [
+                    TX_ERROR_DURING_VALIDATION
+                ]
+            };
+        } finally{
+            this.contractsDB.revertCheckpoint();
+        }
+    }
+    /** Returns a rejection reason if the call is not on the allow list, or undefined if it is allowed. */ async checkAllowList(publicCall, allowList) {
+        if (publicCall.isEmpty()) {
+            return undefined;
+        }
+        const contractAddress = publicCall.request.contractAddress;
+        const functionSelector = publicCall.functionSelector;
+        // Check address-based entries first since they don't require the contract class.
+        for (const entry of allowList){
+            if ('address' in entry) {
+                if (contractAddress.equals(entry.address) && entry.selector.equals(functionSelector)) {
+                    if (entry.calldataLength !== undefined && publicCall.calldata.length !== entry.calldataLength) {
+                        return TX_ERROR_SETUP_WRONG_CALLDATA_LENGTH;
+                    }
+                    if (entry.onlySelf && !publicCall.request.msgSender.equals(contractAddress)) {
+                        return TX_ERROR_SETUP_ONLY_SELF_WRONG_SENDER;
+                    }
+                    if (entry.rejectNullMsgSender && publicCall.request.msgSender.equals(AztecAddress.fromBigInt(NULL_MSG_SENDER_CONTRACT_ADDRESS))) {
+                        return TX_ERROR_SETUP_NULL_MSG_SENDER;
+                    }
+                    return undefined;
+                }
+            }
+        }
+        // Check class-based entries. Fetch the contract instance lazily (only once).
+        let contractClassId;
+        for (const entry of allowList){
+            if (!('classId' in entry)) {
+                continue;
+            }
+            if (contractClassId === undefined) {
+                const instance = await this.contractsDB.getContractInstance(contractAddress, this.timestamp);
+                contractClassId = {
+                    value: instance?.currentContractClassId.toString()
+                };
+                if (!contractClassId.value) {
+                    return TX_ERROR_SETUP_FUNCTION_UNKNOWN_CONTRACT;
+                }
+            }
+            if (contractClassId.value === entry.classId.toString() && entry.selector.equals(functionSelector)) {
+                if (entry.calldataLength !== undefined && publicCall.calldata.length !== entry.calldataLength) {
+                    return TX_ERROR_SETUP_WRONG_CALLDATA_LENGTH;
+                }
+                if (entry.onlySelf && !publicCall.request.msgSender.equals(contractAddress)) {
+                    return TX_ERROR_SETUP_ONLY_SELF_WRONG_SENDER;
+                }
+                if (entry.rejectNullMsgSender && publicCall.request.msgSender.equals(AztecAddress.fromBigInt(NULL_MSG_SENDER_CONTRACT_ADDRESS))) {
+                    return TX_ERROR_SETUP_NULL_MSG_SENDER;
+                }
+                return undefined;
+            }
+        }
+        return TX_ERROR_SETUP_FUNCTION_NOT_ALLOWED;
+    }
+}
+/**
+ * Validates that a transaction's setup-phase calls were allowed at receipt time.
+ *
+ * Checks the precomputed `allowedSetupCalls` flag on TxMetaData. The flag is
+ * computed by running the PhasesTxValidator on the full Tx when it first enters
+ * the pool. This lightweight validator is used during pending pool migration to
+ * reject txs whose setup calls are not on the allow list.
+ */ export class AllowedSetupCallsMetaValidator {
+    #log;
+    constructor(bindings){
+        this.#log = createLogger('sequencer:tx_validator:tx_phases_meta', bindings);
+    }
+    validateTx(tx) {
+        if (!tx.allowedSetupCalls) {
+            this.#log.verbose(`Rejecting tx ${tx.txHash} because its setup calls are not on the allow list`);
+            return Promise.resolve({
+                result: 'invalid',
+                reason: [
+                    TX_ERROR_SETUP_FUNCTION_NOT_ALLOWED
+                ]
+            });
+        }
+        return Promise.resolve({
+            result: 'valid'
+        });
+    }
+}

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

@@ -0,0 +1,8 @@
+import { type LoggerBindings } from '@aztec/foundation/log';
+import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+export declare class SizeTxValidator implements TxValidator<Tx> {
+    #private;
+    constructor(bindings?: LoggerBindings);
+    validateTx(tx: Tx): Promise<TxValidationResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2l6ZV92YWxpZGF0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tc2dfdmFsaWRhdG9ycy90eF92YWxpZGF0b3Ivc2l6ZV92YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFlLEtBQUssY0FBYyxFQUFnQixNQUFNLHVCQUF1QixDQUFDO0FBRXZGLE9BQU8sRUFBRSxFQUFFLEVBQUUsS0FBSyxrQkFBa0IsRUFBRSxLQUFLLFdBQVcsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRWpGLHFCQUFhLGVBQWdCLFlBQVcsV0FBVyxDQUFDLEVBQUUsQ0FBQzs7SUFHckQsWUFBWSxRQUFRLENBQUMsRUFBRSxjQUFjLEVBRXBDO0lBRUQsVUFBVSxDQUFDLEVBQUUsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLGtCQUFrQixDQUFDLENBUzlDO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"size_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/size_validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAEvF,OAAO,EAAE,EAAE,EAAE,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEjF,qBAAa,eAAgB,YAAW,WAAW,CAAC,EAAE,CAAC;;IAGrD,YAAY,QAAQ,CAAC,EAAE,cAAc,EAEpC;IAED,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAS9C;CACF"}

package/dest/msg_validators/tx_validator/size_validator.js

@@ -0,0 +1,23 @@
+import { createLogger } from '@aztec/foundation/log';
+import { MAX_TX_SIZE_KB } from '@aztec/stdlib/p2p';
+export class SizeTxValidator {
+    #log;
+    constructor(bindings){
+        this.#log = createLogger('p2p:tx_validator:tx_size', bindings);
+    }
+    validateTx(tx) {
+        const txSize = tx.getSize();
+        if (txSize > MAX_TX_SIZE_KB * 1024) {
+            this.#log.verbose(`Rejecting transaction ${tx.getTxHash().toString()}. Reason: size above size limit. ${txSize}bytes > ${MAX_TX_SIZE_KB}Kb`);
+            return Promise.resolve({
+                result: 'invalid',
+                reason: [
+                    'Transaction size above size limit'
+                ]
+            });
+        }
+        return Promise.resolve({
+            result: 'valid'
+        });
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type Tx } from '@aztec/stdlib/tx';
+export declare function patchNonRevertibleFn(tx: Tx, index: number, overrides: {
+    address?: AztecAddress;
+    selector: FunctionSelector;
+    args?: Fr[];
+    msgSender?: AztecAddress;
+}): Promise<AztecAddress>;
+export declare function patchRevertibleFn(tx: Tx, index: number, overrides: {
+    address?: AztecAddress;
+    selector: FunctionSelector;
+    args?: Fr[];
+    msgSender?: AztecAddress;
+}): Promise<AztecAddress>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdF91dGlscy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21zZ192YWxpZGF0b3JzL3R4X3ZhbGlkYXRvci90ZXN0X3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3pELE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDMUQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDaEUsT0FBTyxFQUFnQixLQUFLLEVBQUUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXpELHdCQUFnQixvQkFBb0IsQ0FDbEMsRUFBRSxFQUFFLEVBQUUsRUFDTixLQUFLLEVBQUUsTUFBTSxFQUNiLFNBQVMsRUFBRTtJQUFFLE9BQU8sQ0FBQyxFQUFFLFlBQVksQ0FBQztJQUFDLFFBQVEsRUFBRSxnQkFBZ0IsQ0FBQztJQUFDLElBQUksQ0FBQyxFQUFFLEVBQUUsRUFBRSxDQUFDO0lBQUMsU0FBUyxDQUFDLEVBQUUsWUFBWSxDQUFBO0NBQUUsR0FDdkcsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQUV2QjtBQUVELHdCQUFnQixpQkFBaUIsQ0FDL0IsRUFBRSxFQUFFLEVBQUUsRUFDTixLQUFLLEVBQUUsTUFBTSxFQUNiLFNBQVMsRUFBRTtJQUFFLE9BQU8sQ0FBQyxFQUFFLFlBQVksQ0FBQztJQUFDLFFBQVEsRUFBRSxnQkFBZ0IsQ0FBQztJQUFDLElBQUksQ0FBQyxFQUFFLEVBQUUsRUFBRSxDQUFDO0lBQUMsU0FBUyxDQUFDLEVBQUUsWUFBWSxDQUFBO0NBQUUsR0FDdkcsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQUV2QiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"test_utils.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/test_utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAgB,KAAK,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAEzD,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,EAAE,EACN,KAAK,EAAE,MAAM,EACb,SAAS,EAAE;IAAE,OAAO,CAAC,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,gBAAgB,CAAC;IAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC;IAAC,SAAS,CAAC,EAAE,YAAY,CAAA;CAAE,GACvG,OAAO,CAAC,YAAY,CAAC,CAEvB;AAED,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,EAAE,EACN,KAAK,EAAE,MAAM,EACb,SAAS,EAAE;IAAE,OAAO,CAAC,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,gBAAgB,CAAC;IAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC;IAAC,SAAS,CAAC,EAAE,YAAY,CAAA;CAAE,GACvG,OAAO,CAAC,YAAY,CAAC,CAEvB"}

package/dest/msg_validators/tx_validator/test_utils.js

@@ -0,0 +1,22 @@
+import { HashedValues } from '@aztec/stdlib/tx';
+export function patchNonRevertibleFn(tx, index, overrides) {
+    return patchFn('nonRevertibleAccumulatedData', tx, index, overrides);
+}
+export function patchRevertibleFn(tx, index, overrides) {
+    return patchFn('revertibleAccumulatedData', tx, index, overrides);
+}
+async function patchFn(where, tx, index, overrides) {
+    const calldataIndex = where === 'nonRevertibleAccumulatedData' ? index : index + tx.data.forPublic.nonRevertibleAccumulatedData.publicCallRequests.length;
+    const calldata = [
+        overrides.selector.toField(),
+        ...overrides.args ?? []
+    ];
+    const hashedCalldata = await HashedValues.fromCalldata(calldata);
+    tx.publicFunctionCalldata[calldataIndex] = hashedCalldata;
+    const request = tx.data.forPublic[where].publicCallRequests[index];
+    request.contractAddress = overrides.address ?? request.contractAddress;
+    request.msgSender = overrides.msgSender ?? request.msgSender;
+    request.calldataHash = hashedCalldata.hash;
+    tx.data.forPublic[where].publicCallRequests[index] = request;
+    return request.contractAddress;
+}

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

@@ -0,0 +1,30 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import { type LoggerBindings } from '@aztec/foundation/log';
+import { type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+/** Structural interface for timestamp validation. */
+export interface HasTimestampData {
+    txHash: {
+        toString(): string;
+    };
+    data: {
+        expirationTimestamp: bigint;
+        constants: {
+            anchorBlockHeader: {
+                globalVariables: {
+                    blockNumber: BlockNumber;
+                };
+            };
+        };
+    };
+}
+export declare class TimestampTxValidator<T extends HasTimestampData> implements TxValidator<T> {
+    #private;
+    private values;
+    constructor(values: {
+        timestamp: UInt64;
+        blockNumber: BlockNumber;
+    }, bindings?: LoggerBindings);
+    validateTx(tx: T): Promise<TxValidationResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZXN0YW1wX3ZhbGlkYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21zZ192YWxpZGF0b3JzL3R4X3ZhbGlkYXRvci90aW1lc3RhbXBfdmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ25FLE9BQU8sRUFBZSxLQUFLLGNBQWMsRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUN2RixPQUFPLEVBQXlDLEtBQUssa0JBQWtCLEVBQUUsS0FBSyxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNwSCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVsRCxxREFBcUQ7QUFDckQsTUFBTSxXQUFXLGdCQUFnQjtJQUMvQixNQUFNLEVBQUU7UUFBRSxRQUFRLElBQUksTUFBTSxDQUFBO0tBQUUsQ0FBQztJQUMvQixJQUFJLEVBQUU7UUFDSixtQkFBbUIsRUFBRSxNQUFNLENBQUM7UUFDNUIsU0FBUyxFQUFFO1lBQ1QsaUJBQWlCLEVBQUU7Z0JBQ2pCLGVBQWUsRUFBRTtvQkFDZixXQUFXLEVBQUUsV0FBVyxDQUFDO2lCQUMxQixDQUFDO2FBQ0gsQ0FBQztTQUNILENBQUM7S0FDSCxDQUFDO0NBQ0g7QUFFRCxxQkFBYSxvQkFBb0IsQ0FBQyxDQUFDLFNBQVMsZ0JBQWdCLENBQUUsWUFBVyxXQUFXLENBQUMsQ0FBQyxDQUFDOztJQUluRixPQUFPLENBQUMsTUFBTTtJQURoQixZQUNVLE1BQU0sRUFBRTtRQUdkLFNBQVMsRUFBRSxNQUFNLENBQUM7UUFFbEIsV0FBVyxFQUFFLFdBQVcsQ0FBQztLQUMxQixFQUNELFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFHMUI7SUFFRCxVQUFVLENBQUMsRUFBRSxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUMsa0JBQWtCLENBQUMsQ0FtQjdDO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/timestamp_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,EAAyC,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,qDAAqD;AACrD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE;QAAE,QAAQ,IAAI,MAAM,CAAA;KAAE,CAAC;IAC/B,IAAI,EAAE;QACJ,mBAAmB,EAAE,MAAM,CAAC;QAC5B,SAAS,EAAE;YACT,iBAAiB,EAAE;gBACjB,eAAe,EAAE;oBACf,WAAW,EAAE,WAAW,CAAC;iBAC1B,CAAC;aACH,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,qBAAa,oBAAoB,CAAC,CAAC,SAAS,gBAAgB,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;;IAInF,OAAO,CAAC,MAAM;IADhB,YACU,MAAM,EAAE;QAGd,SAAS,EAAE,MAAM,CAAC;QAElB,WAAW,EAAE,WAAW,CAAC;KAC1B,EACD,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAED,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAmB7C;CACF"}

package/dest/msg_validators/tx_validator/timestamp_validator.js

@@ -0,0 +1,32 @@
+import { createLogger } from '@aztec/foundation/log';
+import { TX_ERROR_INVALID_EXPIRATION_TIMESTAMP } from '@aztec/stdlib/tx';
+export class TimestampTxValidator {
+    values;
+    #log;
+    constructor(values, bindings){
+        this.values = values;
+        this.#log = createLogger('p2p:tx_validator:timestamp', bindings);
+    }
+    validateTx(tx) {
+        const expirationTimestamp = tx.data.expirationTimestamp;
+        // If building block 1, we skip the expiration check. For details on why see the `validate_expiration_timestamp`
+        // function in `noir-projects/noir-protocol-circuits/crates/rollup-lib/src/base/components/validation_requests.nr`.
+        const buildingBlock1 = this.values.blockNumber === 1;
+        if (!buildingBlock1 && expirationTimestamp < this.values.timestamp) {
+            if (tx.data.constants.anchorBlockHeader.globalVariables.blockNumber === 0) {
+                this.#log.warn(`A tx built against a genesis block failed to be included in block 1 which is the only block in which txs built against a genesis block are allowed to be included.`);
+            }
+            this.#log.verbose(`Rejecting tx ${tx.txHash} for low expiration timestamp. Tx expiration timestamp: ${expirationTimestamp}, timestamp: ${this.values.timestamp}.`);
+            return Promise.resolve({
+                result: 'invalid',
+                reason: [
+                    TX_ERROR_INVALID_EXPIRATION_TIMESTAMP
+                ]
+            });
+        } else {
+            return Promise.resolve({
+                result: 'valid'
+            });
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { type LoggerBindings } from '@aztec/foundation/log';
+import type { Tx, TxValidationResult, TxValidator } from '@aztec/stdlib/tx';
+export declare class TxPermittedValidator implements TxValidator<Tx> {
+    #private;
+    private permitted;
+    constructor(permitted: boolean, bindings?: LoggerBindings);
+    validateTx(tx: Tx): Promise<TxValidationResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfcGVybWl0dGVkX3ZhbGlkYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21zZ192YWxpZGF0b3JzL3R4X3ZhbGlkYXRvci90eF9wZXJtaXR0ZWRfdmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBZSxLQUFLLGNBQWMsRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUN2RixPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsa0JBQWtCLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFNUUscUJBQWEsb0JBQXFCLFlBQVcsV0FBVyxDQUFDLEVBQUUsQ0FBQzs7SUFJeEQsT0FBTyxDQUFDLFNBQVM7SUFEbkIsWUFDVSxTQUFTLEVBQUUsT0FBTyxFQUMxQixRQUFRLENBQUMsRUFBRSxjQUFjLEVBRzFCO0lBRUQsVUFBVSxDQUFDLEVBQUUsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLGtCQUFrQixDQUFDLENBTzlDO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"tx_permitted_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/tx_permitted_validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,KAAK,EAAE,EAAE,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE5E,qBAAa,oBAAqB,YAAW,WAAW,CAAC,EAAE,CAAC;;IAIxD,OAAO,CAAC,SAAS;IADnB,YACU,SAAS,EAAE,OAAO,EAC1B,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAED,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAO9C;CACF"}

package/dest/msg_validators/tx_validator/tx_permitted_validator.js

@@ -0,0 +1,24 @@
+import { createLogger } from '@aztec/foundation/log';
+export class TxPermittedValidator {
+    permitted;
+    #log;
+    constructor(permitted, bindings){
+        this.permitted = permitted;
+        this.#log = createLogger('p2p:tx_validator:tx_permitted', bindings);
+    }
+    validateTx(tx) {
+        if (!this.permitted) {
+            const txHash = tx.getTxHash();
+            this.#log.verbose(`Rejecting tx ${txHash.toString()}. Reason: Transactions are not permitted`);
+            return Promise.resolve({
+                result: 'invalid',
+                reason: [
+                    'Transactions are not permitted'
+                ]
+            });
+        }
+        return Promise.resolve({
+            result: 'valid'
+        });
+    }
+}

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

@@ -1,9 +1,11 @@
+import { type LoggerBindings } from '@aztec/foundation/log';
 import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
 import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 export declare class TxProofValidator implements TxValidator<Tx> {
     #private;
     private verifier;
-    constructor(verifier: ClientProtocolCircuitVerifier);
+    readonly identifier: symbol;
+    constructor(verifier: ClientProtocolCircuitVerifier, bindings?: LoggerBindings);
     validateTx(tx: Tx): Promise<TxValidationResult>;
 }
-//# sourceMappingURL=tx_proof_validator.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfcHJvb2ZfdmFsaWRhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbXNnX3ZhbGlkYXRvcnMvdHhfdmFsaWRhdG9yL3R4X3Byb29mX3ZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQWUsS0FBSyxjQUFjLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFDdkYsT0FBTyxLQUFLLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNyRixPQUFPLEVBQTBCLEVBQUUsRUFBRSxLQUFLLGtCQUFrQixFQUFFLEtBQUssV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFekcscUJBQWEsZ0JBQWlCLFlBQVcsV0FBVyxDQUFDLEVBQUUsQ0FBQzs7SUFNcEQsT0FBTyxDQUFDLFFBQVE7SUFMbEIsU0FBZ0IsVUFBVSxFQUFFLE1BQU0sQ0FBOEI7SUFJaEUsWUFDVSxRQUFRLEVBQUUsNkJBQTZCLEVBQy9DLFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFHMUI7SUFFSyxVQUFVLENBQUMsRUFBRSxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsa0JBQWtCLENBQUMsQ0FRcEQ7Q0FDRiJ9

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

@@ -1 +1 @@
-{"version":3,"file":"tx_proof_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/tx_proof_validator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,EAAE,EAAE,EAAE,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEjF,qBAAa,gBAAiB,YAAW,WAAW,CAAC,EAAE,CAAC;;IAG1C,OAAO,CAAC,QAAQ;gBAAR,QAAQ,EAAE,6BAA6B;IAErD,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAQtD"}
+{"version":3,"file":"tx_proof_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/tx_validator/tx_proof_validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,EAA0B,EAAE,EAAE,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEzG,qBAAa,gBAAiB,YAAW,WAAW,CAAC,EAAE,CAAC;;IAMpD,OAAO,CAAC,QAAQ;IALlB,SAAgB,UAAU,EAAE,MAAM,CAA8B;IAIhE,YACU,QAAQ,EAAE,6BAA6B,EAC/C,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAEK,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAQpD;CACF"}

package/dest/msg_validators/tx_validator/tx_proof_validator.js

@@ -1,23 +1,26 @@
 import { createLogger } from '@aztec/foundation/log';
-import { Tx } from '@aztec/stdlib/tx';
+import { TX_ERROR_INVALID_PROOF } from '@aztec/stdlib/tx';
 export class TxProofValidator {
     verifier;
+    identifier;
     #log;
-    constructor(verifier){
+    constructor(verifier, bindings){
         this.verifier = verifier;
-        this.#log = createLogger('p2p:tx_validator:private_proof');
+        this.identifier = Symbol('TxProofValidator');
+        this.#log = createLogger('p2p:tx_validator:proof', bindings);
     }
     async validateTx(tx) {
-        if (!await this.verifier.verifyProof(tx)) {
-            this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for invalid proof`);
+        const result = await this.verifier.verifyProof(tx);
+        if (!result.valid) {
+            this.#log.verbose(`Rejecting tx ${tx.getTxHash().toString()} for invalid proof`);
             return {
                 result: 'invalid',
                 reason: [
-                    'Invalid proof'
+                    TX_ERROR_INVALID_PROOF
                 ]
             };
         }
-        this.#log.trace(`Accepted ${Tx.getHash(tx)} with valid proof`);
+        this.#log.trace(`Accepted ${tx.getTxHash().toString()} with valid proof`);
         return {
             result: 'valid'
         };