@aztec/sequencer-client 0.46.7 → 0.47.1

package/src/config.ts

@@ -1,16 +1,14 @@
 import { type AllowedElement } from '@aztec/circuit-types';
 import { AztecAddress, Fr, FunctionSelector, getContractClassFromArtifact } from '@aztec/circuits.js';
-import { type L1ContractAddresses, NULL_KEY } from '@aztec/ethereum';
+import { getL1ContractAddressesFromEnv } from '@aztec/ethereum';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { FPCContract } from '@aztec/noir-contracts.js/FPC';
 import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
 import { AuthRegistryAddress } from '@aztec/protocol-contracts/auth-registry';
 import { GasTokenAddress } from '@aztec/protocol-contracts/gas-token';
 
-import { type Hex } from 'viem';
-
 import { type GlobalReaderConfig } from './global_variable_builder/index.js';
-import { type PublisherConfig, type TxSenderConfig } from './publisher/config.js';
+import { type PublisherConfig, type TxSenderConfig, getTxSenderConfigFromEnv } from './publisher/config.js';
 import { type SequencerConfig } from './sequencer/config.js';
 
 /** Chain configuration. */
@@ -35,25 +33,17 @@ export type SequencerClientConfig = PublisherConfig &
  */
 export function getConfigEnvVars(): SequencerClientConfig {
   const {
-    SEQ_PUBLISHER_PRIVATE_KEY,
-    ETHEREUM_HOST,
-    L1_CHAIN_ID,
     VERSION,
-    SEQ_REQUIRED_CONFIRMATIONS,
     SEQ_PUBLISH_RETRY_INTERVAL_MS,
     SEQ_TX_POLLING_INTERVAL_MS,
     SEQ_MAX_TX_PER_BLOCK,
     SEQ_MIN_TX_PER_BLOCK,
+    SEQ_MAX_SECONDS_BETWEEN_BLOCKS,
+    SEQ_MIN_SECONDS_BETWEEN_BLOCKS,
     SEQ_ALLOWED_SETUP_FN,
     SEQ_ALLOWED_TEARDOWN_FN,
     SEQ_MAX_BLOCK_SIZE_IN_BYTES,
-    AVAILABILITY_ORACLE_CONTRACT_ADDRESS,
-    ROLLUP_CONTRACT_ADDRESS,
-    REGISTRY_CONTRACT_ADDRESS,
-    INBOX_CONTRACT_ADDRESS,
-    OUTBOX_CONTRACT_ADDRESS,
-    GAS_TOKEN_CONTRACT_ADDRESS,
-    GAS_PORTAL_CONTRACT_ADDRESS,
+    SEQ_SKIP_SUBMIT_PROOFS,
     COINBASE,
     FEE_RECIPIENT,
     ACVM_WORKING_DIRECTORY,
@@ -61,37 +51,18 @@ export function getConfigEnvVars(): SequencerClientConfig {
     ENFORCE_FEES = '',
   } = process.env;
 
-  const publisherPrivateKey: Hex = SEQ_PUBLISHER_PRIVATE_KEY
-    ? `0x${SEQ_PUBLISHER_PRIVATE_KEY.replace('0x', '')}`
-    : NULL_KEY;
-  // Populate the relevant addresses for use by the sequencer
-  const addresses: L1ContractAddresses = {
-    availabilityOracleAddress: AVAILABILITY_ORACLE_CONTRACT_ADDRESS
-      ? EthAddress.fromString(AVAILABILITY_ORACLE_CONTRACT_ADDRESS)
-      : EthAddress.ZERO,
-    rollupAddress: ROLLUP_CONTRACT_ADDRESS ? EthAddress.fromString(ROLLUP_CONTRACT_ADDRESS) : EthAddress.ZERO,
-    registryAddress: REGISTRY_CONTRACT_ADDRESS ? EthAddress.fromString(REGISTRY_CONTRACT_ADDRESS) : EthAddress.ZERO,
-    inboxAddress: INBOX_CONTRACT_ADDRESS ? EthAddress.fromString(INBOX_CONTRACT_ADDRESS) : EthAddress.ZERO,
-    outboxAddress: OUTBOX_CONTRACT_ADDRESS ? EthAddress.fromString(OUTBOX_CONTRACT_ADDRESS) : EthAddress.ZERO,
-    gasTokenAddress: GAS_TOKEN_CONTRACT_ADDRESS ? EthAddress.fromString(GAS_TOKEN_CONTRACT_ADDRESS) : EthAddress.ZERO,
-    gasPortalAddress: GAS_PORTAL_CONTRACT_ADDRESS
-      ? EthAddress.fromString(GAS_PORTAL_CONTRACT_ADDRESS)
-      : EthAddress.ZERO,
-  };
-
   return {
     enforceFees: ['1', 'true'].includes(ENFORCE_FEES),
-    rpcUrl: ETHEREUM_HOST ? ETHEREUM_HOST : '',
-    l1ChainId: L1_CHAIN_ID ? +L1_CHAIN_ID : 31337, // 31337 is the default chain id for anvil
     version: VERSION ? +VERSION : 1, // 1 is our default version
-    requiredConfirmations: SEQ_REQUIRED_CONFIRMATIONS ? +SEQ_REQUIRED_CONFIRMATIONS : 1,
-    l1BlockPublishRetryIntervalMS: SEQ_PUBLISH_RETRY_INTERVAL_MS ? +SEQ_PUBLISH_RETRY_INTERVAL_MS : 1_000,
+    l1PublishRetryIntervalMS: SEQ_PUBLISH_RETRY_INTERVAL_MS ? +SEQ_PUBLISH_RETRY_INTERVAL_MS : 1_000,
     transactionPollingIntervalMS: SEQ_TX_POLLING_INTERVAL_MS ? +SEQ_TX_POLLING_INTERVAL_MS : 1_000,
     maxBlockSizeInBytes: SEQ_MAX_BLOCK_SIZE_IN_BYTES ? +SEQ_MAX_BLOCK_SIZE_IN_BYTES : undefined,
-    l1Contracts: addresses,
-    publisherPrivateKey,
+    l1Contracts: getL1ContractAddressesFromEnv(),
     maxTxsPerBlock: SEQ_MAX_TX_PER_BLOCK ? +SEQ_MAX_TX_PER_BLOCK : 32,
     minTxsPerBlock: SEQ_MIN_TX_PER_BLOCK ? +SEQ_MIN_TX_PER_BLOCK : 1,
+    maxSecondsBetweenBlocks: SEQ_MAX_SECONDS_BETWEEN_BLOCKS ? +SEQ_MAX_SECONDS_BETWEEN_BLOCKS : 0,
+    minSecondsBetweenBlocks: SEQ_MIN_SECONDS_BETWEEN_BLOCKS ? +SEQ_MIN_SECONDS_BETWEEN_BLOCKS : 0,
+    sequencerSkipSubmitProofs: ['1', 'true'].includes(SEQ_SKIP_SUBMIT_PROOFS ?? ''),
     // TODO: undefined should not be allowed for the following 2 values in PROD
     coinbase: COINBASE ? EthAddress.fromString(COINBASE) : undefined,
     feeRecipient: FEE_RECIPIENT ? AztecAddress.fromString(FEE_RECIPIENT) : undefined,
@@ -103,6 +74,7 @@ export function getConfigEnvVars(): SequencerClientConfig {
     allowedInTeardown: SEQ_ALLOWED_TEARDOWN_FN
       ? parseSequencerAllowList(SEQ_ALLOWED_TEARDOWN_FN)
       : getDefaultAllowedTeardownFunctions(),
+    ...getTxSenderConfigFromEnv('SEQ'),
   };
 }
 

package/src/index.ts

@@ -2,6 +2,8 @@ export * from './client/index.js';
 export * from './config.js';
 export * from './publisher/index.js';
 export * from './sequencer/index.js';
+export * from './tx_validator/aggregate_tx_validator.js';
+export * from './tx_validator/data_validator.js';
 
 // Used by the node to simulate public parts of transactions. Should these be moved to a shared library?
 export * from './global_variable_builder/index.js';

package/src/publisher/config.ts

@@ -1,4 +1,6 @@
-import { type L1ContractAddresses } from '@aztec/ethereum';
+import { type L1ContractAddresses, NULL_KEY } from '@aztec/ethereum';
+
+import { type Hex } from 'viem';
 
 /**
  * The configuration of the rollup transaction publisher.
@@ -37,5 +39,21 @@ export interface PublisherConfig {
   /**
    * The interval to wait between publish retries.
    */
-  l1BlockPublishRetryIntervalMS: number;
+  l1PublishRetryIntervalMS: number;
+}
+
+export function getTxSenderConfigFromEnv(scope: 'PROVER' | 'SEQ'): Omit<TxSenderConfig, 'l1Contracts'> {
+  const { ETHEREUM_HOST, L1_CHAIN_ID } = process.env;
+
+  const PUBLISHER_PRIVATE_KEY = process.env[`${scope}_PUBLISHER_PRIVATE_KEY`];
+  const REQUIRED_CONFIRMATIONS = process.env[`${scope}_REQUIRED_CONFIRMATIONS`];
+
+  const publisherPrivateKey: Hex = PUBLISHER_PRIVATE_KEY ? `0x${PUBLISHER_PRIVATE_KEY.replace('0x', '')}` : NULL_KEY;
+
+  return {
+    rpcUrl: ETHEREUM_HOST ? ETHEREUM_HOST : '',
+    requiredConfirmations: REQUIRED_CONFIRMATIONS ? +REQUIRED_CONFIRMATIONS : 1,
+    publisherPrivateKey,
+    l1ChainId: L1_CHAIN_ID ? +L1_CHAIN_ID : 31337,
+  };
 }

package/src/publisher/index.ts

@@ -3,7 +3,7 @@ import { L1Publisher } from './l1-publisher.js';
 import { ViemTxSender } from './viem-tx-sender.js';
 
 export { L1Publisher } from './l1-publisher.js';
-export { PublisherConfig } from './config.js';
+export { PublisherConfig, TxSenderConfig, getTxSenderConfigFromEnv } from './config.js';
 
 /**
  * Returns a new instance of the L1Publisher.

package/src/publisher/l1-publisher.ts

@@ -46,8 +46,8 @@ export interface L1PublisherTxSender {
   /** Returns the EOA used for sending txs to L1.  */
   getSenderAddress(): Promise<EthAddress>;
 
-  /** Returns the address elected for submitting a given block number or zero if anyone can submit. */
-  getSubmitterAddressForBlock(blockNumber: number): Promise<EthAddress>;
+  /** Returns the address of the current proposer or zero if anyone can submit. */
+  getSubmitterAddressForBlock(): Promise<EthAddress>;
 
   /**
    * Publishes tx effects to Availability Oracle.
@@ -134,11 +134,11 @@ export class L1Publisher implements L2BlockReceiver {
   private log = createDebugLogger('aztec:sequencer:publisher');
 
   constructor(private txSender: L1PublisherTxSender, config?: PublisherConfig) {
-    this.sleepTimeMs = config?.l1BlockPublishRetryIntervalMS ?? 60_000;
+    this.sleepTimeMs = config?.l1PublishRetryIntervalMS ?? 60_000;
   }
 
-  public async isItMyTurnToSubmit(blockNumber: number): Promise<boolean> {
-    const submitter = await this.txSender.getSubmitterAddressForBlock(blockNumber);
+  public async isItMyTurnToSubmit(): Promise<boolean> {
+    const submitter = await this.txSender.getSubmitterAddressForBlock();
     const sender = await this.txSender.getSenderAddress();
     return submitter.isZero() || submitter.equals(sender);
   }

package/src/publisher/viem-tx-sender.ts

@@ -77,12 +77,12 @@ export class ViemTxSender implements L1PublisherTxSender {
     return Promise.resolve(EthAddress.fromString(this.account.address));
   }
 
-  async getSubmitterAddressForBlock(blockNumber: number): Promise<EthAddress> {
+  async getSubmitterAddressForBlock(): Promise<EthAddress> {
     try {
-      const submitter = await this.rollupContract.read.whoseTurnIsIt([BigInt(blockNumber)]);
+      const submitter = await this.rollupContract.read.getCurrentProposer();
       return EthAddress.fromString(submitter);
     } catch (err) {
-      this.log.warn(`Failed to get submitter for block ${blockNumber}: ${err}`);
+      this.log.warn(`Failed to get submitter: ${err}`);
       return EthAddress.ZERO;
     }
   }

package/src/sequencer/sequencer.ts

@@ -42,6 +42,8 @@ export class Sequencer {
   private pollingIntervalMs: number = 1000;
   private maxTxsPerBlock = 32;
   private minTxsPerBLock = 1;
+  private minSecondsBetweenBlocks = 0;
+  private maxSecondsBetweenBlocks = 0;
   // TODO: zero values should not be allowed for the following 2 values in PROD
   private _coinbase = EthAddress.ZERO;
   private _feeRecipient = AztecAddress.ZERO;
@@ -50,6 +52,7 @@ export class Sequencer {
   private allowedInSetup: AllowedElement[] = [];
   private allowedInTeardown: AllowedElement[] = [];
   private maxBlockSizeInBytes: number = 1024 * 1024;
+  private skipSubmitProofs: boolean = false;
 
   public readonly tracer: Tracer;
 
@@ -77,15 +80,21 @@ export class Sequencer {
    * @param config - New parameters.
    */
   public updateConfig(config: SequencerConfig) {
-    if (config.transactionPollingIntervalMS) {
+    if (config.transactionPollingIntervalMS !== undefined) {
       this.pollingIntervalMs = config.transactionPollingIntervalMS;
     }
-    if (config.maxTxsPerBlock) {
+    if (config.maxTxsPerBlock !== undefined) {
       this.maxTxsPerBlock = config.maxTxsPerBlock;
     }
-    if (config.minTxsPerBlock) {
+    if (config.minTxsPerBlock !== undefined) {
       this.minTxsPerBLock = config.minTxsPerBlock;
     }
+    if (config.minSecondsBetweenBlocks !== undefined) {
+      this.minSecondsBetweenBlocks = config.minSecondsBetweenBlocks;
+    }
+    if (config.maxSecondsBetweenBlocks !== undefined) {
+      this.maxSecondsBetweenBlocks = config.maxSecondsBetweenBlocks;
+    }
     if (config.coinbase) {
       this._coinbase = config.coinbase;
     }
@@ -95,13 +104,17 @@ export class Sequencer {
     if (config.allowedInSetup) {
       this.allowedInSetup = config.allowedInSetup;
     }
-    if (config.maxBlockSizeInBytes) {
+    if (config.maxBlockSizeInBytes !== undefined) {
       this.maxBlockSizeInBytes = config.maxBlockSizeInBytes;
     }
     // TODO(#5917) remove this. it is no longer needed since we don't need to whitelist functions in teardown
     if (config.allowedInTeardown) {
       this.allowedInTeardown = config.allowedInTeardown;
     }
+    // TODO(palla/prover) This flag should not be needed: the sequencer should be initialized with a blockprover
+    // that does not return proofs at all (just simulates circuits), and use that to determine whether to submit
+    // proofs or not.
+    this.skipSubmitProofs = !!config.sequencerSkipSubmitProofs;
   }
 
   /**
@@ -174,17 +187,41 @@ export class Sequencer {
           : Number(historicalHeader.globalVariables.blockNumber.toBigInt())) + 1;
 
       // Do not go forward with new block if not my turn
-      if (!(await this.publisher.isItMyTurnToSubmit(newBlockNumber))) {
-        this.log.verbose('Not my turn to submit block');
+      if (!(await this.publisher.isItMyTurnToSubmit())) {
+        this.log.debug('Not my turn to submit block');
+        return;
+      }
+
+      // Compute time elapsed since the previous block
+      const lastBlockTime = historicalHeader?.globalVariables.timestamp.toNumber() || 0;
+      const currentTime = Math.floor(Date.now() / 1000);
+      const elapsedSinceLastBlock = currentTime - lastBlockTime;
+
+      // Do not go forward with new block if not enough time has passed since last block
+      if (this.minSecondsBetweenBlocks > 0 && elapsedSinceLastBlock < this.minSecondsBetweenBlocks) {
+        this.log.debug(
+          `Not creating block because not enough time has passed since last block (last block at ${lastBlockTime} current time ${currentTime})`,
+        );
         return;
       }
 
       this.state = SequencerState.WAITING_FOR_TXS;
 
-      // Get txs to build the new block
-      const pendingTxs = await this.p2pClient.getTxs();
+      // Get txs to build the new block.
+      const pendingTxs = this.p2pClient.getTxs('pending');
+
+      // If we haven't hit the maxSecondsBetweenBlocks, we need to have at least minTxsPerBLock txs.
       if (pendingTxs.length < this.minTxsPerBLock) {
-        return;
+        if (this.skipMinTxsPerBlockCheck(elapsedSinceLastBlock)) {
+          this.log.debug(
+            `Creating block with only ${pendingTxs.length} txs as more than ${this.maxSecondsBetweenBlocks}s have passed since last block`,
+          );
+        } else {
+          this.log.debug(
+            `Not creating block because not enough txs in the pool (got ${pendingTxs.length} min ${this.minTxsPerBLock})`,
+          );
+          return;
+        }
       }
       this.log.debug(`Retrieved ${pendingTxs.length} txs from P2P pool`);
 
@@ -207,11 +244,15 @@ export class Sequencer {
       // may break if we start emitting lots of log data from public-land.
       const validTxs = this.takeTxsWithinMaxSize(allValidTxs);
 
-      if (validTxs.length < this.minTxsPerBLock) {
+      // Bail if we don't have enough valid txs
+      if (!this.skipMinTxsPerBlockCheck(elapsedSinceLastBlock) && validTxs.length < this.minTxsPerBLock) {
+        this.log.debug(
+          `Not creating block because not enough valid txs loaded from the pool (got ${validTxs.length} min ${this.minTxsPerBLock})`,
+        );
         return;
       }
 
-      await this.buildBlockAndPublish(validTxs, newGlobalVariables, historicalHeader);
+      await this.buildBlockAndPublish(validTxs, newGlobalVariables, historicalHeader, elapsedSinceLastBlock);
     } catch (err) {
       if (BlockProofError.isBlockProofError(err)) {
         const txHashes = err.txHashes.filter(h => !h.isZero());
@@ -225,6 +266,11 @@ export class Sequencer {
     }
   }
 
+  /** Whether to skip the check of min txs per block if more than maxSecondsBetweenBlocks has passed since the previous block. */
+  private skipMinTxsPerBlockCheck(elapsed: number): boolean {
+    return this.maxSecondsBetweenBlocks > 0 && elapsed >= this.maxSecondsBetweenBlocks;
+  }
+
   @trackSpan('Sequencer.buildBlockAndPublish', (_validTxs, newGlobalVariables, _historicalHeader) => ({
     [Attributes.BLOCK_NUMBER]: newGlobalVariables.blockNumber.toNumber(),
   }))
@@ -232,6 +278,7 @@ export class Sequencer {
     validTxs: Tx[],
     newGlobalVariables: GlobalVariables,
     historicalHeader: Header | undefined,
+    elapsedSinceLastBlock: number,
   ): Promise<void> {
     const workTimer = new Timer();
     this.state = SequencerState.CREATING_BLOCK;
@@ -242,7 +289,8 @@ export class Sequencer {
       if (currentBlockNumber + 1 !== newGlobalVariables.blockNumber.toNumber()) {
         throw new Error('New block was emitted while building block');
       }
-      if (!(await this.publisher.isItMyTurnToSubmit(newGlobalVariables.blockNumber.toNumber()))) {
+
+      if (!(await this.publisher.isItMyTurnToSubmit())) {
         throw new Error(`Not this sequencer turn to submit block`);
       }
     };
@@ -255,7 +303,7 @@ export class Sequencer {
     );
 
     // We create a fresh processor each time to reset any cached state (eg storage writes)
-    const processor = await this.publicProcessorFactory.create(historicalHeader, newGlobalVariables);
+    const processor = this.publicProcessorFactory.create(historicalHeader, newGlobalVariables);
 
     const numRealTxs = validTxs.length;
     const blockSize = Math.max(2, numRealTxs);
@@ -272,7 +320,11 @@ export class Sequencer {
       await this.p2pClient.deleteTxs(Tx.getHashes(failedTxData));
     }
 
-    if (processedTxs.length === 0) {
+    // TODO: This check should be processedTxs.length < this.minTxsPerBLock, so we don't publish a block with
+    // less txs than the minimum. But that'd cause the entire block to be aborted and retried. Instead, we should
+    // go back to the p2p pool and load more txs until we hit our minTxsPerBLock target. Only if there are no txs
+    // we should bail.
+    if (processedTxs.length === 0 && !this.skipMinTxsPerBlockCheck(elapsedSinceLastBlock)) {
       this.log.verbose('No txs processed correctly to build block. Exiting');
       this.prover.cancelBlock();
       return;
@@ -309,10 +361,10 @@ export class Sequencer {
     await this.publishL2Block(block);
     this.log.info(`Submitted rollup block ${block.number} with ${processedTxs.length} transactions`);
 
-    // Submit the proof if we have configured this sequencer to run with a prover.
+    // Submit the proof if we have configured this sequencer to run with an actual prover.
     // This is temporary while we submit one proof per block, but will have to change once we
     // move onto proving batches of multiple blocks at a time.
-    if (aggregationObject && proof) {
+    if (aggregationObject && proof && !this.skipSubmitProofs) {
       await this.publisher.submitProof(block.header, block.archive.root, aggregationObject, proof);
       this.log.info(`Submitted proof for block ${block.number}`);
     }
@@ -378,7 +430,15 @@ export class Sequencer {
       this.l1ToL2MessageSource.getBlockNumber(),
     ]);
     const min = Math.min(...syncedBlocks);
-    return min >= this.lastPublishedBlock;
+    const [worldState, p2p, l2BlockSource, l1ToL2MessageSource] = syncedBlocks;
+    const result = min >= this.lastPublishedBlock;
+    this.log.debug(`Sync check to last published block ${this.lastPublishedBlock} ${result ? 'succeeded' : 'failed'}`, {
+      worldState,
+      p2p,
+      l2BlockSource,
+      l1ToL2MessageSource,
+    });
+    return result;
   }
 
   get coinbase(): EthAddress {

package/src/tx_validator/data_validator.ts

@@ -0,0 +1,61 @@
+import { Tx, type TxValidator } from '@aztec/circuit-types';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+export class DataTxValidator implements TxValidator<Tx> {
+  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_data');
+
+  validateTxs(txs: Tx[]): Promise<[validTxs: Tx[], invalidTxs: Tx[]]> {
+    const validTxs: Tx[] = [];
+    const invalidTxs: Tx[] = [];
+    for (const tx of txs) {
+      if (!this.#hasCorrectExecutionRequests(tx)) {
+        invalidTxs.push(tx);
+        continue;
+      }
+
+      validTxs.push(tx);
+    }
+
+    return Promise.resolve([validTxs, invalidTxs]);
+  }
+
+  #hasCorrectExecutionRequests(tx: Tx): boolean {
+    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}.`,
+      );
+      return false;
+    }
+
+    const invalidExecutionRequestIndex = tx.enqueuedPublicFunctionCalls.findIndex(
+      (execRequest, i) => !execRequest.isForCallRequest(callRequests[i]),
+    );
+    if (invalidExecutionRequestIndex !== -1) {
+      this.#log.warn(
+        `Rejecting tx ${Tx.getHash(
+          tx,
+        )} because of incorrect execution requests for public call at index ${invalidExecutionRequestIndex}.`,
+      );
+      return false;
+    }
+
+    const teardownCallRequest = tx.data.getTeardownPublicCallRequest();
+    const isInvalidTeardownExecutionRequest =
+      (!teardownCallRequest && !tx.publicTeardownFunctionCall.isEmpty()) ||
+      (teardownCallRequest && !tx.publicTeardownFunctionCall.isForCallRequest(teardownCallRequest));
+    if (isInvalidTeardownExecutionRequest) {
+      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} because of incorrect teardown execution requests.`);
+      return false;
+    }
+
+    return true;
+  }
+
+  // TODO: Check logs.
+}

package/src/tx_validator/gas_validator.ts

@@ -60,7 +60,9 @@ export class GasTxValidator implements TxValidator<Tx> {
       fn =>
         fn.contractAddress.equals(this.#gasTokenAddress) &&
         fn.callContext.msgSender.equals(this.#gasTokenAddress) &&
-        fn.functionSelector.equals(GasTokenArtifact.functions.find(f => f.name === '_increase_public_balance')!) &&
+        fn.callContext.functionSelector.equals(
+          GasTokenArtifact.functions.find(f => f.name === '_increase_public_balance')!,
+        ) &&
         fn.args[0].equals(feePayer) &&
         !fn.callContext.isStaticCall &&
         !fn.callContext.isDelegateCall,

package/src/tx_validator/phases_validator.ts

@@ -1,5 +1,10 @@
-import { type AllowedElement, PublicKernelType, Tx, type TxValidator } from '@aztec/circuit-types';
-import { type PublicCallRequest } from '@aztec/circuits.js';
+import {
+  type AllowedElement,
+  type PublicExecutionRequest,
+  PublicKernelType,
+  Tx,
+  type TxValidator,
+} from '@aztec/circuit-types';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { AbstractPhaseManager, ContractsDataSourcePublicDB } from '@aztec/simulator';
 import { type ContractDataSource } from '@aztec/types/contracts';
@@ -47,7 +52,7 @@ export class PhasesTxValidator implements TxValidator<Tx> {
         this.#log.warn(
           `Rejecting tx ${Tx.getHash(tx)} because it calls setup function not on allow list: ${
             setupFn.contractAddress
-          }:${setupFn.functionSelector}`,
+          }:${setupFn.callContext.functionSelector}`,
         );
 
         return false;
@@ -57,12 +62,15 @@ export class PhasesTxValidator implements TxValidator<Tx> {
     return true;
   }
 
-  async isOnAllowList(publicCall: PublicCallRequest, allowList: AllowedElement[]): Promise<boolean> {
+  async isOnAllowList(publicCall: PublicExecutionRequest, allowList: AllowedElement[]): Promise<boolean> {
     if (publicCall.isEmpty()) {
       return true;
     }
 
-    const { contractAddress, functionSelector } = publicCall;
+    const {
+      contractAddress,
+      callContext: { functionSelector },
+    } = publicCall;
 
     // do these checks first since they don't require the contract class
     for (const entry of allowList) {

package/src/tx_validator/test_utils.ts

@@ -1,5 +1,6 @@
 import { type Tx } from '@aztec/circuit-types';
 import { type AztecAddress, type Fr, type FunctionSelector } from '@aztec/circuits.js';
+import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 
 export function patchNonRevertibleFn(
   tx: Tx,
@@ -25,13 +26,19 @@ function patchFn(
 ): { address: AztecAddress; selector: FunctionSelector } {
   const fn = tx.enqueuedPublicFunctionCalls.at(-1 * index - 1)!;
   fn.contractAddress = overrides.address ?? fn.contractAddress;
-  fn.functionSelector = overrides.selector;
+  fn.callContext.functionSelector = overrides.selector;
   fn.args = overrides.args ?? fn.args;
   fn.callContext.msgSender = overrides.msgSender ?? fn.callContext.msgSender;
-  tx.data.forPublic![where].publicCallStack[index] = fn.toCallRequest();
+  tx.enqueuedPublicFunctionCalls[index] = fn;
+
+  const request = tx.data.forPublic![where].publicCallStack[index];
+  request.item.contractAddress = fn.contractAddress;
+  request.item.callContext = fn.callContext;
+  request.item.argsHash = computeVarArgsHash(fn.args);
+  tx.data.forPublic![where].publicCallStack[index] = request;
 
   return {
     address: fn.contractAddress,
-    selector: fn.functionSelector,
+    selector: fn.callContext.functionSelector,
   };
 }

package/src/tx_validator/tx_validator_factory.ts

@@ -6,6 +6,7 @@ import { type ContractDataSource } from '@aztec/types/contracts';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
 import { AggregateTxValidator } from './aggregate_tx_validator.js';
+import { DataTxValidator } from './data_validator.js';
 import { DoubleSpendTxValidator } from './double_spend_validator.js';
 import { GasTxValidator } from './gas_validator.js';
 import { MetadataTxValidator } from './metadata_validator.js';
@@ -20,6 +21,7 @@ export class TxValidatorFactory {
 
   validatorForNewTxs(globalVariables: GlobalVariables, setupAllowList: AllowedElement[]): TxValidator<Tx> {
     return new AggregateTxValidator(
+      new DataTxValidator(),
       new MetadataTxValidator(globalVariables),
       new DoubleSpendTxValidator(new WorldStateDB(this.merkleTreeDb)),
       new PhasesTxValidator(this.contractDataSource, setupAllowList),