@aztec/sequencer-client 0.47.0 → 0.48.0

package/src/sequencer/sequencer.ts

@@ -9,11 +9,11 @@ import {
 import {
   type AllowedElement,
   BlockProofError,
-  type BlockProver,
   PROVING_STATUS,
+  type ProverClient,
 } from '@aztec/circuit-types/interfaces';
 import { type L2BlockBuiltStats } from '@aztec/circuit-types/stats';
-import { AztecAddress, EthAddress, type GlobalVariables, type Header } from '@aztec/circuits.js';
+import { AztecAddress, EthAddress, type GlobalVariables, type Header, IS_DEV_NET } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
@@ -24,9 +24,10 @@ import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec
 import { type WorldStateStatus, type WorldStateSynchronizer } from '@aztec/world-state';
 
 import { type GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
-import { type L1Publisher } from '../publisher/l1-publisher.js';
+import { type Attestation, type L1Publisher } from '../publisher/l1-publisher.js';
 import { type TxValidatorFactory } from '../tx_validator/tx_validator_factory.js';
 import { type SequencerConfig } from './config.js';
+import { SequencerMetrics } from './metrics.js';
 
 /**
  * Sequencer client
@@ -42,6 +43,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;
@@ -51,15 +54,14 @@ export class Sequencer {
   private allowedInTeardown: AllowedElement[] = [];
   private maxBlockSizeInBytes: number = 1024 * 1024;
   private skipSubmitProofs: boolean = false;
-
-  public readonly tracer: Tracer;
+  private metrics: SequencerMetrics;
 
   constructor(
     private publisher: L1Publisher,
     private globalsBuilder: GlobalVariableBuilder,
     private p2pClient: P2P,
     private worldState: WorldStateSynchronizer,
-    private prover: BlockProver,
+    private prover: ProverClient,
     private l2BlockSource: L2BlockSource,
     private l1ToL2MessageSource: L1ToL2MessageSource,
     private publicProcessorFactory: PublicProcessorFactory,
@@ -69,24 +71,34 @@ export class Sequencer {
     private log = createDebugLogger('aztec:sequencer'),
   ) {
     this.updateConfig(config);
-    this.tracer = telemetry.getTracer('Sequencer');
+    this.metrics = new SequencerMetrics(telemetry, () => this.state, 'Sequencer');
     this.log.verbose(`Initialized sequencer with ${this.minTxsPerBLock}-${this.maxTxsPerBlock} txs per block.`);
   }
 
+  get tracer(): Tracer {
+    return this.metrics.tracer;
+  }
+
   /**
    * Updates sequencer config.
    * @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;
     }
@@ -96,7 +108,7 @@ 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
@@ -162,16 +174,17 @@ export class Sequencer {
     try {
       // Update state when the previous block has been synced
       const prevBlockSynced = await this.isBlockSynced();
-      if (prevBlockSynced && this.state === SequencerState.PUBLISHING_BLOCK) {
-        this.log.debug(`Block has been synced`);
-        this.state = SequencerState.IDLE;
-      }
-
       // Do not go forward with new block if the previous one has not been mined and processed
       if (!prevBlockSynced) {
+        this.log.debug('Previous block has not been mined and processed yet');
         return;
       }
 
+      if (prevBlockSynced && this.state === SequencerState.PUBLISHING_BLOCK) {
+        this.log.debug(`Block has been synced`);
+        this.state = SequencerState.IDLE;
+      }
+
       const historicalHeader = (await this.l2BlockSource.getBlock(-1))?.header;
       const newBlockNumber =
         (historicalHeader === undefined
@@ -179,21 +192,42 @@ 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))) {
+      if (!(await this.publisher.isItMyTurnToSubmit())) {
         this.log.debug('Not my turn to submit block');
         return;
       }
 
-      this.state = SequencerState.WAITING_FOR_TXS;
+      // 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;
 
-      // Get txs to build the new block
-      const pendingTxs = this.p2pClient.getTxs('pending');
-      if (pendingTxs.length < this.minTxsPerBLock) {
+      // 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 there are not enough txs in the pool (got ${pendingTxs.length} min ${this.minTxsPerBLock})`,
+          `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 = this.p2pClient.getTxs('pending');
+
+      // If we haven't hit the maxSecondsBetweenBlocks, we need to have at least minTxsPerBLock txs.
+      if (pendingTxs.length < this.minTxsPerBLock) {
+        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`);
 
       const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(
@@ -202,6 +236,8 @@ export class Sequencer {
         this._feeRecipient,
       );
 
+      // @todo @LHerskind Include some logic to consider slots
+
       // TODO: It should be responsibility of the P2P layer to validate txs before passing them on here
       const allValidTxs = await this.takeValidTxs(
         pendingTxs,
@@ -215,11 +251,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());
@@ -227,12 +267,15 @@ export class Sequencer {
         await this.p2pClient.deleteTxs(txHashes);
       }
       this.log.error(`Rolling back world state DB due to error assembling block`, (err as any).stack);
-      // Cancel any further proving on the block
-      this.prover?.cancelBlock();
       await this.worldState.getLatest().rollback();
     }
   }
 
+  /** 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(),
   }))
@@ -240,7 +283,9 @@ export class Sequencer {
     validTxs: Tx[],
     newGlobalVariables: GlobalVariables,
     historicalHeader: Header | undefined,
+    elapsedSinceLastBlock: number,
   ): Promise<void> {
+    this.metrics.recordNewBlock(newGlobalVariables.blockNumber.toNumber(), validTxs.length);
     const workTimer = new Timer();
     this.state = SequencerState.CREATING_BLOCK;
     this.log.info(`Building block ${newGlobalVariables.blockNumber.toNumber()} with ${validTxs.length} transactions`);
@@ -248,11 +293,15 @@ export class Sequencer {
     const assertBlockHeight = async () => {
       const currentBlockNumber = await this.l2BlockSource.getBlockNumber();
       if (currentBlockNumber + 1 !== newGlobalVariables.blockNumber.toNumber()) {
+        this.metrics.recordCancelledBlock();
         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`);
       }
+
+      // @todo @LHerskind Should take into account, block number, proposer and slot number
     };
 
     // Get l1 to l2 messages from the contract
@@ -269,10 +318,11 @@ export class Sequencer {
     const blockSize = Math.max(2, numRealTxs);
 
     const blockBuildingTimer = new Timer();
-    const blockTicket = await this.prover.startNewBlock(blockSize, newGlobalVariables, l1ToL2Messages);
+    const prover = this.prover.createBlockProver(this.worldState.getLatest());
+    const blockTicket = await prover.startNewBlock(blockSize, newGlobalVariables, l1ToL2Messages);
 
     const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
-      processor.process(validTxs, blockSize, this.prover, this.txValidatorFactory.validatorForProcessedTxs()),
+      processor.process(validTxs, blockSize, prover, this.txValidatorFactory.validatorForProcessedTxs()),
     );
     if (failedTxs.length > 0) {
       const failedTxData = failedTxs.map(fail => fail.tx);
@@ -280,16 +330,20 @@ 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();
+      prover.cancelBlock();
       return;
     }
 
     await assertBlockHeight();
 
     // All real transactions have been added, set the block as full and complete the proving.
-    await this.prover.setBlockCompleted();
+    await prover.setBlockCompleted();
 
     // Here we are now waiting for the block to be proven.
     // TODO(@PhilWindle) We should probably periodically check for things like another
@@ -302,30 +356,75 @@ export class Sequencer {
     await assertBlockHeight();
 
     // Block is proven, now finalise and publish!
-    const { block, aggregationObject, proof } = await this.prover.finaliseBlock();
+    const { block, aggregationObject, proof } = await prover.finaliseBlock();
 
     await assertBlockHeight();
 
-    this.log.verbose(`Assembled block ${block.number}`, {
-      eventName: 'l2-block-built',
-      duration: workTimer.ms(),
-      publicProcessDuration: publicProcessorDuration,
-      rollupCircuitsDuration: blockBuildingTimer.ms(),
-      ...block.getStats(),
-    } satisfies L2BlockBuiltStats);
+    const workDuration = workTimer.ms();
+    this.log.verbose(
+      `Assembled block ${block.number} (txEffectsHash: ${block.header.contentCommitment.txsEffectsHash.toString(
+        'hex',
+      )})`,
+      {
+        eventName: 'l2-block-built',
+        duration: workDuration,
+        publicProcessDuration: publicProcessorDuration,
+        rollupCircuitsDuration: blockBuildingTimer.ms(),
+        ...block.getStats(),
+      } satisfies L2BlockBuiltStats,
+    );
 
-    await this.publishL2Block(block);
-    this.log.info(`Submitted rollup block ${block.number} with ${processedTxs.length} transactions`);
+    try {
+      const attestations = await this.collectAttestations(block);
+      await this.publishL2Block(block, attestations);
+      this.metrics.recordPublishedBlock(workDuration);
+      this.log.info(
+        `Submitted rollup block ${block.number} with ${
+          processedTxs.length
+        } transactions duration=${workDuration}ms (Submitter: ${await this.publisher.senderAddress()})`,
+      );
+    } catch (err) {
+      this.metrics.recordFailedBlock();
+      throw err;
+    }
 
     // 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 && !this.skipSubmitProofs) {
-      await this.publisher.submitProof(block.header, block.archive.root, aggregationObject, proof);
+      await this.publisher.submitProof(
+        block.header,
+        block.archive.root,
+        prover.getProverId(),
+        aggregationObject,
+        proof,
+      );
       this.log.info(`Submitted proof for block ${block.number}`);
     }
   }
 
+  protected async collectAttestations(block: L2Block): Promise<Attestation[] | undefined> {
+    // @todo  This should collect attestations properly and fix the ordering of them to make sense
+    //        the current implementation is a PLACEHOLDER and should be nuked from orbit.
+    //        It is assuming that there will only be ONE (1) validator, so only one attestation
+    //        is needed.
+    // @note  This is quite a sin, but I'm committing war crimes in this code already.
+    //            _ ._  _ , _ ._
+    //          (_ ' ( `  )_  .__)
+    //       ( (  (    )   `)  ) _)
+    //      (__ (_   (_ . _) _) ,__)
+    //           `~~`\ ' . /`~~`
+    //                ;   ;
+    //                /   \
+    //  _____________/_ __ \_____________
+    if (IS_DEV_NET) {
+      return undefined;
+    }
+
+    const myAttestation = await this.publisher.attest(block.archive.root.toString());
+    return [myAttestation];
+  }
+
   /**
    * Publishes the L2Block to the rollup contract.
    * @param block - The L2Block to be published.
@@ -333,10 +432,10 @@ export class Sequencer {
   @trackSpan('Sequencer.publishL2Block', block => ({
     [Attributes.BLOCK_NUMBER]: block.number,
   }))
-  protected async publishL2Block(block: L2Block) {
+  protected async publishL2Block(block: L2Block, attestations?: Attestation[]) {
     // Publishes new block to the network and awaits the tx to be mined
     this.state = SequencerState.PUBLISHING_BLOCK;
-    const publishedL2Block = await this.publisher.processL2Block(block);
+    const publishedL2Block = await this.publisher.processL2Block(block, attestations);
     if (publishedL2Block) {
       this.lastPublishedBlock = block.number;
     } else {

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

@@ -1,7 +1,7 @@
 import { PublicKernelType, type Tx, type TxValidator } from '@aztec/circuit-types';
 import { type AztecAddress, type Fr } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { GasTokenArtifact } from '@aztec/protocol-contracts/gas-token';
+import { FeeJuiceArtifact } from '@aztec/protocol-contracts/fee-juice';
 import { AbstractPhaseManager, computeFeePayerBalanceStorageSlot } from '@aztec/simulator';
 
 /** Provides a view into public contract state */
@@ -12,11 +12,11 @@ export interface PublicStateSource {
 export class GasTxValidator implements TxValidator<Tx> {
   #log = createDebugLogger('aztec:sequencer:tx_validator:tx_gas');
   #publicDataSource: PublicStateSource;
-  #gasTokenAddress: AztecAddress;
+  #feeJuiceAddress: AztecAddress;
 
-  constructor(publicDataSource: PublicStateSource, gasTokenAddress: AztecAddress, public enforceFees: boolean) {
+  constructor(publicDataSource: PublicStateSource, feeJuiceAddress: AztecAddress, public enforceFees: boolean) {
     this.#publicDataSource = publicDataSource;
-    this.#gasTokenAddress = gasTokenAddress;
+    this.#feeJuiceAddress = feeJuiceAddress;
   }
 
   async validateTxs(txs: Tx[]): Promise<[validTxs: Tx[], invalidTxs: Tx[]]> {
@@ -50,17 +50,19 @@ export class GasTxValidator implements TxValidator<Tx> {
 
     // Read current balance of the feePayer
     const initialBalance = await this.#publicDataSource.storageRead(
-      this.#gasTokenAddress,
+      this.#feeJuiceAddress,
       computeFeePayerBalanceStorageSlot(feePayer),
     );
 
-    // If there is a claim in this tx that increases the fee payer balance in gas token, add it to balance
+    // If there is a claim in this tx that increases the fee payer balance in Fee Juice, add it to balance
     const { [PublicKernelType.SETUP]: setupFns } = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx);
     const claimFunctionCall = setupFns.find(
       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.contractAddress.equals(this.#feeJuiceAddress) &&
+        fn.callContext.msgSender.equals(this.#feeJuiceAddress) &&
+        fn.callContext.functionSelector.equals(
+          FeeJuiceArtifact.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

@@ -1,11 +1,12 @@
 import { type AllowedElement, type ProcessedTx, type Tx, type TxValidator } from '@aztec/circuit-types';
 import { type GlobalVariables } from '@aztec/circuits.js';
-import { GasTokenAddress } from '@aztec/protocol-contracts/gas-token';
+import { FeeJuiceAddress } from '@aztec/protocol-contracts/fee-juice';
 import { WorldStateDB, WorldStatePublicDB } from '@aztec/simulator';
 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,10 +21,11 @@ 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),
-      new GasTxValidator(new WorldStatePublicDB(this.merkleTreeDb), GasTokenAddress, this.enforceFees),
+      new GasTxValidator(new WorldStatePublicDB(this.merkleTreeDb), FeeJuiceAddress, this.enforceFees),
     );
   }
 

package/dest/global_variable_builder/config.d.ts

@@ -1,19 +0,0 @@
-import { type L1ContractAddresses } from '@aztec/ethereum';
-/**
- * Configuration of the L1GlobalReader.
- */
-export interface GlobalReaderConfig {
-    /**
-     * The RPC Url of the ethereum host.
-     */
-    rpcUrl: string;
-    /**
-     * The chain ID of the ethereum host.
-     */
-    l1ChainId: number;
-    /**
-     * The deployed l1 contract addresses
-     */
-    l1Contracts: L1ContractAddresses;
-}
-//# sourceMappingURL=config.d.ts.map

package/dest/global_variable_builder/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/global_variable_builder/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,WAAW,EAAE,mBAAmB,CAAC;CAClC"}

package/dest/global_variable_builder/config.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2dsb2JhbF92YXJpYWJsZV9idWlsZGVyL2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/src/global_variable_builder/config.ts

@@ -1,20 +0,0 @@
-import { type L1ContractAddresses } from '@aztec/ethereum';
-
-/**
- * Configuration of the L1GlobalReader.
- */
-export interface GlobalReaderConfig {
-  /**
-   * The RPC Url of the ethereum host.
-   */
-  rpcUrl: string;
-  /**
-   * The chain ID of the ethereum host.
-   */
-  l1ChainId: number;
-
-  /**
-   * The deployed l1 contract addresses
-   */
-  l1Contracts: L1ContractAddresses;
-}