@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/src/msg_validators/msg_seen_validator/msg_seen_validator.ts

@@ -0,0 +1,36 @@
+// Implements a queue of message IDs
+export class MessageSeenValidator {
+  private queue: Array<string>;
+  private writePointer = 0;
+  private seenMessages: Set<string> = new Set();
+
+  constructor(private queueLength: number) {
+    if (this.queueLength <= 0) {
+      throw new Error('Queue length must be greater than 0');
+    }
+    this.queue = new Array<string>(this.queueLength);
+  }
+
+  // Adds a message if not seen before. Returns true if added, false if already seen.
+  public addMessage(msgId: string): boolean {
+    // Check if the message is already in the cache
+    if (this.seenMessages.has(msgId)) {
+      return false;
+    }
+    // If we are at the cache limit, remove the oldest msg ID
+    if (this.seenMessages.size >= this.queueLength) {
+      const msgToRemove = this.queue[this.writePointer];
+      this.seenMessages.delete(msgToRemove);
+    }
+
+    // Insert the message into the cache and the queue
+    this.seenMessages.add(msgId);
+    this.queue[this.writePointer] = msgId;
+    this.writePointer = this.writePointer === this.queueLength - 1 ? 0 : this.writePointer + 1;
+    return true;
+  }
+
+  public size() {
+    return this.seenMessages.size;
+  }
+}

package/src/msg_validators/proposal_validator/block_proposal_validator.ts

@@ -0,0 +1,10 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { BlockProposal, P2PValidator } from '@aztec/stdlib/p2p';
+
+import { ProposalValidator } from '../proposal_validator/proposal_validator.js';
+
+export class BlockProposalValidator extends ProposalValidator<BlockProposal> implements P2PValidator<BlockProposal> {
+  constructor(epochCache: EpochCacheInterface, opts: { txsPermitted: boolean }) {
+    super(epochCache, opts, 'p2p:block_proposal_validator');
+  }
+}

package/src/msg_validators/proposal_validator/checkpoint_proposal_validator.ts

@@ -0,0 +1,13 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { CheckpointProposal, P2PValidator } from '@aztec/stdlib/p2p';
+
+import { ProposalValidator } from '../proposal_validator/proposal_validator.js';
+
+export class CheckpointProposalValidator
+  extends ProposalValidator<CheckpointProposal>
+  implements P2PValidator<CheckpointProposal>
+{
+  constructor(epochCache: EpochCacheInterface, opts: { txsPermitted: boolean }) {
+    super(epochCache, opts, 'p2p:checkpoint_proposal_validator');
+  }
+}

package/src/msg_validators/proposal_validator/index.ts

@@ -0,0 +1,3 @@
+export * from './block_proposal_validator.js';
+export * from './checkpoint_proposal_validator.js';
+export * from './proposal_validator.js';

package/src/msg_validators/proposal_validator/proposal_validator.ts

@@ -0,0 +1,92 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { NoCommitteeError } from '@aztec/ethereum/contracts';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { BlockProposal, CheckpointProposal, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+
+export abstract class ProposalValidator<TProposal extends BlockProposal | CheckpointProposal> {
+  protected epochCache: EpochCacheInterface;
+  protected logger: Logger;
+  protected txsPermitted: boolean;
+
+  constructor(epochCache: EpochCacheInterface, opts: { txsPermitted: boolean }, loggerName: string) {
+    this.epochCache = epochCache;
+    this.txsPermitted = opts.txsPermitted;
+    this.logger = createLogger(loggerName);
+  }
+
+  public async validate(proposal: TProposal): Promise<PeerErrorSeverity | undefined> {
+    try {
+      // Signature validity
+      const proposer = proposal.getSender();
+      if (!proposer) {
+        this.logger.debug(`Penalizing peer for proposal with invalid signature`);
+        return PeerErrorSeverity.MidToleranceError;
+      }
+
+      // Transactions permitted check
+      const embeddedTxCount = proposal.txs?.length ?? 0;
+      if (!this.txsPermitted && (proposal.txHashes.length > 0 || embeddedTxCount > 0)) {
+        this.logger.debug(
+          `Penalizing peer for proposal with ${proposal.txHashes.length} transaction(s) when transactions are not permitted`,
+        );
+        return PeerErrorSeverity.MidToleranceError;
+      }
+
+      // Embedded txs must be listed in txHashes
+      const hashSet = new Set(proposal.txHashes.map(h => h.toString()));
+      const missingTxHashes =
+        embeddedTxCount > 0
+          ? proposal.txs!.filter(tx => !hashSet.has(tx.getTxHash().toString())).map(tx => tx.getTxHash().toString())
+          : [];
+      if (embeddedTxCount > 0 && missingTxHashes.length > 0) {
+        this.logger.warn('Penalizing peer for embedded transaction(s) not included in txHashes', {
+          embeddedTxCount,
+          txHashesLength: proposal.txHashes.length,
+          missingTxHashes,
+        });
+        return PeerErrorSeverity.MidToleranceError;
+      }
+
+      // Slot and proposer checks
+      const { currentProposer, nextProposer, currentSlot, nextSlot } =
+        await this.epochCache.getProposerAttesterAddressInCurrentOrNextSlot();
+      const slotNumber = proposal.slotNumber;
+      if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
+        this.logger.debug(`Penalizing peer for invalid slot number ${slotNumber}`, { currentSlot, nextSlot });
+        return PeerErrorSeverity.HighToleranceError;
+      }
+      if (slotNumber === currentSlot && currentProposer !== undefined && !proposer.equals(currentProposer)) {
+        this.logger.debug(`Penalizing peer for invalid proposer for current slot ${slotNumber}`, {
+          currentProposer,
+          nextProposer,
+          proposer: proposer.toString(),
+        });
+        return PeerErrorSeverity.MidToleranceError;
+      }
+      if (slotNumber === nextSlot && nextProposer !== undefined && !proposer.equals(nextProposer)) {
+        this.logger.debug(`Penalizing peer for invalid proposer for next slot ${slotNumber}`, {
+          currentProposer,
+          nextProposer,
+          proposer: proposer.toString(),
+        });
+        return PeerErrorSeverity.MidToleranceError;
+      }
+
+      // Validate tx hashes for all txs embedded in the proposal
+      if (!(await Promise.all(proposal.txs?.map(tx => tx.validateTxHash()) ?? [])).every(v => v)) {
+        this.logger.warn(`Penalizing peer for invalid tx hashes in proposal`, {
+          proposer,
+          slotNumber,
+        });
+        return PeerErrorSeverity.LowToleranceError;
+      }
+
+      return undefined;
+    } catch (e) {
+      if (e instanceof NoCommitteeError) {
+        return PeerErrorSeverity.LowToleranceError;
+      }
+      throw e;
+    }
+  }
+}

package/src/msg_validators/proposal_validator/proposal_validator_test_suite.ts

@@ -0,0 +1,206 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { type BlockProposal, type CheckpointProposal, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+import type { MockProxy } from 'jest-mock-extended';
+
+export interface ProposalValidatorTestParams<TProposal extends BlockProposal | CheckpointProposal> {
+  validatorFactory: (
+    epochCache: EpochCacheInterface,
+    opts: { txsPermitted: boolean },
+  ) => { validate: (proposal: TProposal) => Promise<PeerErrorSeverity | undefined> };
+  makeProposal: (options?: any) => Promise<TProposal>;
+  makeHeader: (epochNumber: number | bigint, slotNumber: number | bigint, blockNumber: number | bigint) => any;
+  getSigner: () => Secp256k1Signer;
+  getAddress: (signer?: Secp256k1Signer) => EthAddress;
+  getSlot: (slot: number | bigint) => any;
+  getTxHashes: (n: number) => TxHash[];
+  getTxs: () => any[];
+  epochCacheMock: () => MockProxy<EpochCacheInterface>;
+}
+
+export function sharedProposalValidatorTests<TProposal extends BlockProposal | CheckpointProposal>(
+  params: ProposalValidatorTestParams<TProposal>,
+) {
+  const { validatorFactory, makeProposal, makeHeader, getSigner, getAddress, getSlot, getTxHashes, epochCacheMock } =
+    params;
+
+  describe('shared proposal validation logic', () => {
+    let epochCache: MockProxy<EpochCacheInterface>;
+    let validator: { validate: (proposal: TProposal) => Promise<PeerErrorSeverity | undefined> };
+
+    beforeEach(() => {
+      epochCache = epochCacheMock();
+      validator = validatorFactory(epochCache, { txsPermitted: true });
+    });
+
+    it('returns high tolerance error if slot number is not current or next slot', async () => {
+      const header = makeHeader(1, 97, 97);
+      const mockProposal = await makeProposal({ blockHeader: header, lastBlockHeader: header });
+      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+        currentSlot: getSlot(98),
+        nextSlot: getSlot(99),
+        currentProposer: getAddress(),
+        nextProposer: getAddress(),
+      });
+      const result = await validator.validate(mockProposal);
+      expect(result).toBe(PeerErrorSeverity.HighToleranceError);
+    });
+
+    it('returns mid tolerance error if proposer is not current proposer for current slot', async () => {
+      const currentProposer = getSigner();
+      const nextProposer = getSigner();
+      const invalidProposer = getSigner();
+      const header = makeHeader(1, 100, 100);
+      const mockProposal = await makeProposal({
+        blockHeader: header,
+        lastBlockHeader: header,
+        signer: invalidProposer,
+      });
+      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+        currentSlot: getSlot(100),
+        nextSlot: getSlot(101),
+        currentProposer: getAddress(currentProposer),
+        nextProposer: getAddress(nextProposer),
+      });
+      const result = await validator.validate(mockProposal);
+      expect(result).toBe(PeerErrorSeverity.MidToleranceError);
+    });
+
+    it('returns mid tolerance error if proposer is not next proposer for next slot', async () => {
+      const currentProposer = getSigner();
+      const nextProposer = getSigner();
+      const invalidProposer = getSigner();
+      const header = makeHeader(1, 101, 101);
+      const mockProposal = await makeProposal({
+        blockHeader: header,
+        lastBlockHeader: header,
+        signer: invalidProposer,
+      });
+      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+        currentSlot: getSlot(100),
+        nextSlot: getSlot(101),
+        currentProposer: getAddress(currentProposer),
+        nextProposer: getAddress(nextProposer),
+      });
+      const result = await validator.validate(mockProposal);
+      expect(result).toBe(PeerErrorSeverity.MidToleranceError);
+    });
+
+    it('returns mid tolerance error if proposer is current proposer but proposal is for next slot', async () => {
+      const currentProposer = getSigner();
+      const nextProposer = getSigner();
+      const header = makeHeader(1, 101, 101);
+      const mockProposal = await makeProposal({
+        blockHeader: header,
+        lastBlockHeader: header,
+        signer: currentProposer,
+      });
+      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+        currentSlot: getSlot(100),
+        nextSlot: getSlot(101),
+        currentProposer: getAddress(currentProposer),
+        nextProposer: getAddress(nextProposer),
+      });
+      const result = await validator.validate(mockProposal);
+      expect(result).toBe(PeerErrorSeverity.MidToleranceError);
+    });
+
+    it('returns undefined if proposal is valid for current slot and proposer', async () => {
+      const currentProposer = getSigner();
+      const nextProposer = getSigner();
+      const header = makeHeader(1, 100, 100);
+      const mockProposal = await makeProposal({
+        blockHeader: header,
+        lastBlockHeader: header,
+        signer: currentProposer,
+      });
+      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+        currentSlot: getSlot(100),
+        nextSlot: getSlot(101),
+        currentProposer: getAddress(currentProposer),
+        nextProposer: getAddress(nextProposer),
+      });
+      const result = await validator.validate(mockProposal);
+      expect(result).toBeUndefined();
+    });
+
+    it('returns undefined if proposal is valid for next slot and proposer', async () => {
+      const currentProposer = getSigner();
+      const nextProposer = getSigner();
+      const header = makeHeader(1, 101, 101);
+      const mockProposal = await makeProposal({ blockHeader: header, lastBlockHeader: header, signer: nextProposer });
+      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+        currentSlot: getSlot(100),
+        nextSlot: getSlot(101),
+        currentProposer: getAddress(currentProposer),
+        nextProposer: getAddress(nextProposer),
+      });
+      const result = await validator.validate(mockProposal);
+      expect(result).toBeUndefined();
+    });
+
+    describe('transaction permission validation', () => {
+      it('returns mid tolerance error if txs not permitted and proposal contains txHashes', async () => {
+        const currentProposer = getSigner();
+        const validatorWithTxsDisabled = validatorFactory(epochCache, { txsPermitted: false });
+        const header = makeHeader(1, 100, 100);
+        const mockProposal = await makeProposal({
+          blockHeader: header,
+          lastBlockHeader: header,
+          signer: currentProposer,
+          txHashes: getTxHashes(2),
+        });
+        epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+          currentSlot: getSlot(100),
+          nextSlot: getSlot(101),
+          currentProposer: getAddress(currentProposer),
+          nextProposer: getAddress(),
+        });
+        const result = await validatorWithTxsDisabled.validate(mockProposal);
+        expect(result).toBe(PeerErrorSeverity.MidToleranceError);
+      });
+
+      it('returns undefined if txs not permitted but proposal has no txHashes', async () => {
+        const currentProposer = getSigner();
+        const validatorWithTxsDisabled = validatorFactory(epochCache, { txsPermitted: false });
+        const header = makeHeader(1, 100, 100);
+        const mockProposal = await makeProposal({
+          blockHeader: header,
+          lastBlockHeader: header,
+          signer: currentProposer,
+          txHashes: getTxHashes(0),
+        });
+        epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+          currentSlot: getSlot(100),
+          nextSlot: getSlot(101),
+          currentProposer: getAddress(currentProposer),
+          nextProposer: getAddress(),
+        });
+        const result = await validatorWithTxsDisabled.validate(mockProposal);
+        expect(result).toBeUndefined();
+      });
+
+      it('returns undefined if txs permitted and proposal contains txHashes', async () => {
+        const currentProposer = getSigner();
+        const header = makeHeader(1, 100, 100);
+        const mockProposal = await makeProposal({
+          blockHeader: header,
+          lastBlockHeader: header,
+          signer: currentProposer,
+          txHashes: getTxHashes(2),
+        });
+        epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+          currentSlot: getSlot(100),
+          nextSlot: getSlot(101),
+          currentProposer: getAddress(currentProposer),
+          nextProposer: getAddress(),
+        });
+        const result = await validator.validate(mockProposal);
+        expect(result).toBeUndefined();
+      });
+    });
+  });
+}

package/src/msg_validators/tx_validator/allowed_public_setup.ts

@@ -0,0 +1,35 @@
+import { FPCContract } from '@aztec/noir-contracts.js/FPC';
+import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
+
+let defaultAllowedSetupFunctions: AllowedElement[] | undefined = undefined;
+export async function getDefaultAllowedSetupFunctions(): Promise<AllowedElement[]> {
+  if (defaultAllowedSetupFunctions === undefined) {
+    defaultAllowedSetupFunctions = [
+      // needed for authwit support
+      {
+        address: ProtocolContractAddress.AuthRegistry,
+      },
+      // needed for claiming on the same tx as a spend
+      {
+        address: ProtocolContractAddress.FeeJuice,
+        // We can't restrict the selector because public functions get routed via dispatch.
+        // selector: FunctionSelector.fromSignature('_increase_public_balance((Field),u128)'),
+      },
+      // needed for private transfers via FPC
+      {
+        classId: (await getContractClassFromArtifact(TokenContractArtifact)).id,
+        // We can't restrict the selector because public functions get routed via dispatch.
+        // selector: FunctionSelector.fromSignature('_increase_public_balance((Field),u128)'),
+      },
+      {
+        classId: (await getContractClassFromArtifact(FPCContract.artifact)).id,
+        // We can't restrict the selector because public functions get routed via dispatch.
+        // selector: FunctionSelector.fromSignature('prepare_fee((Field),Field,(Field),Field)'),
+      },
+    ];
+  }
+  return defaultAllowedSetupFunctions;
+}

package/src/msg_validators/tx_validator/archive_cache.ts

@@ -0,0 +1,28 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { ArchiveSource } from '@aztec/p2p';
+import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+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 implements ArchiveSource {
+  archives: Map<string, bigint>;
+
+  constructor(private db: MerkleTreeReadOperations) {
+    this.archives = new Map<string, bigint>();
+  }
+
+  public async getArchiveIndices(archives: Fr[]): Promise<(bigint | undefined)[]> {
+    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/src/msg_validators/tx_validator/block_header_validator.ts

@@ -1,6 +1,6 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
-import { type AnyTx, Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import { type AnyTx, TX_ERROR_BLOCK_HEADER, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 
 export interface ArchiveSource {
   getArchiveIndices: (archives: Fr[]) => Promise<(bigint | undefined)[]>;
@@ -15,10 +15,10 @@ export class BlockHeaderTxValidator<T extends AnyTx> implements TxValidator<T> {
   }
 
   async validateTx(tx: T): Promise<TxValidationResult> {
-    const [index] = await this.#archiveSource.getArchiveIndices([await tx.data.constants.historicalHeader.hash()]);
+    const [index] = await this.#archiveSource.getArchiveIndices([await tx.data.constants.anchorBlockHeader.hash()]);
     if (index === undefined) {
-      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for referencing an unknown block header`);
-      return { result: 'invalid', reason: ['Block header not found'] };
+      this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for referencing an unknown block header`);
+      return { result: 'invalid', reason: [TX_ERROR_BLOCK_HEADER] };
     }
     return { result: 'valid' };
   }

package/src/msg_validators/tx_validator/data_validator.ts

@@ -1,106 +1,126 @@
-import { MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS } from '@aztec/constants';
+import { MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
-import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+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,
+  type TxValidationResult,
+  type TxValidator,
+} from '@aztec/stdlib/tx';
 
 export class DataTxValidator implements TxValidator<Tx> {
   #log = createLogger('p2p:tx_validator:tx_data');
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {
-    const execRequestRes = this.#hasCorrectExecutionRequests(tx);
-    // Note: If we ever skip txs here, must change this return statement to account for them.
-    return (await execRequestRes).result === 'invalid' ? execRequestRes : this.#hasCorrectContractClassLogs(tx);
+    const reason =
+      (await this.#hasCorrectHash(tx)) ??
+      (await this.#hasCorrectCalldata(tx)) ??
+      (await this.#hasCorrectContractClassLogs(tx));
+    return reason ? { result: 'invalid', reason: [reason] } : { result: 'valid' };
   }
 
-  async #hasCorrectExecutionRequests(tx: Tx): Promise<TxValidationResult> {
-    const callRequests = [
-      ...tx.data.getRevertiblePublicCallRequests(),
-      ...tx.data.getNonRevertiblePublicCallRequests(),
-    ];
-    if (callRequests.length !== tx.enqueuedPublicFunctionCalls.length) {
-      this.#log.warn(
-        `Rejecting tx ${Tx.getHash(tx)} because of mismatch number of execution requests for public calls. Expected ${
-          callRequests.length
-        }. Got ${tx.enqueuedPublicFunctionCalls.length}.`,
+  async #hasCorrectHash(tx: Tx): Promise<string | undefined> {
+    const expected = await Tx.computeTxHash(tx);
+    if (!tx.getTxHash().equals(expected)) {
+      const reason = TX_ERROR_INCORRECT_HASH;
+      this.#log.verbose(
+        `Rejecting tx ${tx.getTxHash().toString()}. Reason: ${reason}. Expected hash ${expected.toString()}. Got ${tx
+          .getTxHash()
+          .toString()}.`,
       );
-      return { result: 'invalid', reason: ['Wrong number of execution requests for public calls'] };
+      return reason;
     }
+    return undefined;
+  }
 
-    if (tx.getTotalPublicArgsCount() > MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS) {
-      this.#log.warn(
-        `Rejecting tx ${await Tx.getHash(
-          tx,
-        )} because the total length of args to public enqueued calls is greater than ${MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS}`,
+  async #hasCorrectCalldata(tx: Tx): Promise<string | undefined> {
+    if (tx.publicFunctionCalldata.length !== tx.numberOfPublicCalls()) {
+      const reason = TX_ERROR_CALLDATA_COUNT_MISMATCH;
+      this.#log.verbose(
+        `Rejecting tx ${tx.getTxHash().toString()}. Reason: ${reason}. Expected ${tx.numberOfPublicCalls()}. Got ${
+          tx.publicFunctionCalldata.length
+        }.`,
       );
-      return { result: 'invalid', reason: ['Too many args in total to enqueued public calls'] };
+      return reason;
     }
-    const invalidExecutionRequestIndex = (
-      await Promise.all(
-        tx.enqueuedPublicFunctionCalls.map(
-          async (execRequest, i) => !(await execRequest.isForCallRequest(callRequests[i])),
-        ),
-      )
-    ).findIndex(Boolean);
-    if (invalidExecutionRequestIndex !== -1) {
-      this.#log.warn(
-        `Rejecting tx ${await Tx.getHash(
-          tx,
-        )} because of incorrect execution requests for public call at index ${invalidExecutionRequestIndex}.`,
+
+    if (tx.getTotalPublicCalldataCount() > MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS) {
+      const reason = TX_ERROR_CALLDATA_COUNT_TOO_LARGE;
+      this.#log.verbose(
+        `Rejecting tx ${tx
+          .getTxHash()
+          .toString()}. Reason: ${reason}. Expected no greater than ${MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS} fields. Got ${tx.getTotalPublicCalldataCount()}.`,
       );
-      return { result: 'invalid', reason: ['Incorrect execution request for public call'] };
+      return reason;
     }
 
-    const teardownCallRequest = tx.data.getTeardownPublicCallRequest();
-    const isInvalidTeardownExecutionRequest =
-      (!teardownCallRequest && !tx.publicTeardownFunctionCall.isEmpty()) ||
-      (teardownCallRequest && !(await tx.publicTeardownFunctionCall.isForCallRequest(teardownCallRequest)));
-    if (isInvalidTeardownExecutionRequest) {
-      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} because of incorrect teardown execution requests.`);
-      return { result: 'invalid', reason: ['Incorrect teardown execution request'] };
+    const callRequests = tx.getPublicCallRequestsWithCalldata();
+    for (let i = 0; i < callRequests.length; i++) {
+      const { request, calldata } = callRequests[i];
+      const hash = await computeCalldataHash(calldata);
+      if (!hash.equals(request.calldataHash)) {
+        const reason = TX_ERROR_INCORRECT_CALLDATA;
+        this.#log.verbose(`Rejecting tx ${tx.getTxHash().toString()}. Reason: ${reason}. Call request index: ${i}.`);
+        return reason;
+      }
     }
 
-    return { result: 'valid' };
+    return undefined;
   }
 
-  async #hasCorrectContractClassLogs(tx: Tx): Promise<TxValidationResult> {
+  async #hasCorrectContractClassLogs(tx: Tx): Promise<string | undefined> {
     const contractClassLogsHashes = tx.data.getNonEmptyContractClassLogsHashes();
-    const hashedContractClasslogs = await Promise.all(tx.contractClassLogs.map(l => l.hash()));
-    if (contractClassLogsHashes.length !== hashedContractClasslogs.length) {
-      this.#log.warn(
-        `Rejecting tx ${Tx.getHash(tx)} because of mismatched number of contract class logs. Expected ${
+    if (contractClassLogsHashes.length !== tx.contractClassLogFields.length) {
+      this.#log.verbose(
+        `Rejecting tx ${tx.getTxHash().toString()} because of mismatched number of contract class logs. Expected ${
           contractClassLogsHashes.length
-        }. Got ${hashedContractClasslogs.length}.`,
+        }. Got ${tx.contractClassLogFields.length}.`,
       );
-      return { result: 'invalid', reason: ['Mismatched number of contract class logs'] };
+      return TX_ERROR_CONTRACT_CLASS_LOG_COUNT;
     }
+
+    const expectedHashes = await Promise.all(tx.contractClassLogFields.map(l => l.hash()));
     for (const [i, logHash] of contractClassLogsHashes.entries()) {
-      const hashedLog = hashedContractClasslogs[i];
-      if (!logHash.value.equals(hashedLog)) {
-        if (hashedContractClasslogs.some(l => logHash.value.equals(l))) {
-          const matchingLogIndex = hashedContractClasslogs.findIndex(l => logHash.value.equals(l));
-          this.#log.warn(
-            `Rejecting tx ${Tx.getHash(
-              tx,
-            )} because of mismatched contract class logs indices. Expected ${i} from the kernel's log hashes. Got ${matchingLogIndex} in the tx.`,
+      const hash = expectedHashes[i];
+      if (!logHash.value.equals(hash)) {
+        if (expectedHashes.some(h => logHash.value.equals(h))) {
+          const matchingLogIndex = expectedHashes.findIndex(l => logHash.value.equals(l));
+          this.#log.verbose(
+            `Rejecting tx ${tx
+              .getTxHash()
+              .toString()} because of mismatched contract class logs indices. Expected ${i} from the kernel's log hashes. Got ${matchingLogIndex} in the tx.`,
           );
-          return { result: 'invalid', reason: ['Incorrectly sorted contract class logs'] };
+          return TX_ERROR_CONTRACT_CLASS_LOG_SORTING;
         } else {
-          this.#log.warn(
-            `Rejecting tx ${Tx.getHash(tx)} because of mismatched contract class logs. Expected hash ${
+          this.#log.verbose(
+            `Rejecting tx ${tx.getTxHash().toString()} because of mismatched contract class logs. Expected hash ${
               logHash.value
-            } from the kernels. Got ${hashedLog} in the tx.`,
+            } from the kernels. Got ${hash} in the tx.`,
           );
-          return { result: 'invalid', reason: ['Mismatched contract class logs'] };
+          return TX_ERROR_CONTRACT_CLASS_LOGS;
         }
       }
-      if (logHash.logHash.length !== tx.contractClassLogs[i].getEmittedLength()) {
-        this.#log.warn(
-          `Rejecting tx ${Tx.getHash(tx)} because of mismatched contract class logs length. Expected ${
+
+      const expectedMinLength = 1 + tx.contractClassLogFields[i].fields.findLastIndex(f => !f.isZero());
+      if (logHash.logHash.length < expectedMinLength) {
+        this.#log.verbose(
+          `Rejecting tx ${tx
+            .getTxHash()
+            .toString()} because of incorrect contract class log length. Expected the length to be at least ${expectedMinLength}. Got ${
             logHash.logHash.length
-          } from the kernel's log hashes. Got ${tx.contractClassLogs[i].getEmittedLength()} in the tx.`,
+          }.`,
         );
-        return { result: 'invalid', reason: ['Mismatched contract class logs length'] };
+        return TX_ERROR_CONTRACT_CLASS_LOG_LENGTH;
       }
     }
-    return { result: 'valid' };
+
+    return undefined;
   }
 }