@aztec/sequencer-client 0.76.4 → 0.77.0-testnet-ignition.21

package/src/slasher/slasher_client.ts

@@ -1,36 +1,27 @@
 import {
-  type L2Block,
-  type L2BlockId,
-  type L2BlockSource,
-  L2BlockStream,
-  type L2BlockStreamEvent,
-  type L2Tips,
-} from '@aztec/circuit-types';
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js/constants';
-import { type L1ContractsConfig, type L1ReaderConfig, createEthereumChain } from '@aztec/ethereum';
+  type L1ContractsConfig,
+  type L1ReaderConfig,
+  type ViemPublicClient,
+  createEthereumChain,
+} from '@aztec/ethereum';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
-import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncSingleton } from '@aztec/kv-store';
 import { SlashFactoryAbi } from '@aztec/l1-artifacts';
+import {
+  type L2BlockId,
+  type L2BlockSourceEvent,
+  type L2BlockSourceEventEmitter,
+  L2BlockSourceEvents,
+} from '@aztec/stdlib/block';
 import { type TelemetryClient, WithTracer, getTelemetryClient } from '@aztec/telemetry-client';
 
-import {
-  type Chain,
-  type GetContractReturnType,
-  type HttpTransport,
-  type PublicClient,
-  createPublicClient,
-  getAddress,
-  getContract,
-  http,
-} from 'viem';
+import { type GetContractReturnType, createPublicClient, fallback, getAddress, getContract, http } from 'viem';
 
 /**
  * Enum defining the possible states of the Slasher client.
  */
 export enum SlasherClientState {
   IDLE,
-  SYNCHING,
   RUNNING,
   STOPPED,
 }
@@ -86,22 +77,9 @@ type SlashEvent = {
  *    slashing only the first, because the "lifetime" of the second would have passed after that vote
  */
 export class SlasherClient extends WithTracer {
-  private currentState = SlasherClientState.IDLE;
-  private syncPromise = Promise.resolve();
-  private syncResolve?: () => void = undefined;
-  private latestBlockNumberAtStart = -1;
-  private provenBlockNumberAtStart = -1;
-
-  private synchedBlockHashes: AztecAsyncMap<number, string>;
-  private synchedLatestBlockNumber: AztecAsyncSingleton<number>;
-  private synchedProvenBlockNumber: AztecAsyncSingleton<number>;
-
-  private blockStream;
-
   private slashEvents: SlashEvent[] = [];
 
-  protected slashFactoryContract?: GetContractReturnType<typeof SlashFactoryAbi, PublicClient<HttpTransport, Chain>> =
-    undefined;
+  protected slashFactoryContract?: GetContractReturnType<typeof SlashFactoryAbi, ViemPublicClient> = undefined;
 
   // The amount to slash for a prune.
   // Note that we set it to 0, such that no actual slashing will happen, but the event will be fired,
@@ -110,27 +88,17 @@ export class SlasherClient extends WithTracer {
 
   constructor(
     private config: SlasherConfig & L1ContractsConfig & L1ReaderConfig,
-    private store: AztecAsyncKVStore,
-    private l2BlockSource: L2BlockSource,
+    private l2BlockSource: L2BlockSourceEventEmitter,
     telemetry: TelemetryClient = getTelemetryClient(),
     private log = createLogger('slasher'),
   ) {
     super(telemetry, 'slasher');
 
-    this.blockStream = new L2BlockStream(l2BlockSource, this, this, createLogger('slasher:block_stream'), {
-      batchSize: config.blockRequestBatchSize,
-      pollIntervalMS: config.blockCheckIntervalMS,
-    });
-
-    this.synchedBlockHashes = store.openMap('slasher_block_hashes');
-    this.synchedLatestBlockNumber = store.openSingleton('slasher_last_l2_block');
-    this.synchedProvenBlockNumber = store.openSingleton('slasher_last_proven_l2_block');
-
     if (config.l1Contracts.slashFactoryAddress && config.l1Contracts.slashFactoryAddress !== EthAddress.ZERO) {
-      const chain = createEthereumChain(config.l1RpcUrl, config.l1ChainId);
+      const chain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
       const publicClient = createPublicClient({
         chain: chain.chainInfo,
-        transport: http(chain.rpcUrl),
+        transport: fallback(chain.rpcUrls.map(url => http(url))),
         pollingInterval: config.viemPollingIntervalMS,
       });
 
@@ -146,6 +114,11 @@ export class SlasherClient extends WithTracer {
     this.log.info(`Slasher client initialized`);
   }
 
+  public start() {
+    this.log.info('Starting Slasher client...');
+    this.l2BlockSource.on(L2BlockSourceEvents.L2PruneDetected, this.handlePruneL2Blocks.bind(this));
+  }
+
   // This is where we should put a bunch of the improvements mentioned earlier.
   public async getSlashPayload(slotNumber: bigint): Promise<EthAddress | undefined> {
     if (!this.slashFactoryContract) {
@@ -177,198 +150,32 @@ export class SlasherClient extends WithTracer {
     return EthAddress.fromString(payloadAddress);
   }
 
-  public getL2BlockHash(number: number): Promise<string | undefined> {
-    return this.synchedBlockHashes.getAsync(number);
-  }
-
-  public async getL2Tips(): Promise<L2Tips> {
-    const latestBlockNumber = await this.getSyncedLatestBlockNum();
-    let latestBlockHash: string | undefined;
-    const provenBlockNumber = await this.getSyncedProvenBlockNum();
-    let provenBlockHash: string | undefined;
-
-    if (latestBlockNumber > 0) {
-      latestBlockHash = await this.synchedBlockHashes.getAsync(latestBlockNumber);
-      if (typeof latestBlockHash === 'undefined') {
-        this.log.warn(`Block hash for latest block ${latestBlockNumber} not found`);
-        throw new Error();
-      }
-    }
-
-    if (provenBlockNumber > 0) {
-      provenBlockHash = await this.synchedBlockHashes.getAsync(provenBlockNumber);
-      if (typeof provenBlockHash === 'undefined') {
-        this.log.warn(`Block hash for proven block ${provenBlockNumber} not found`);
-        throw new Error();
-      }
-    }
-
-    return Promise.resolve({
-      latest: { hash: latestBlockHash!, number: latestBlockNumber },
-      proven: { hash: provenBlockHash!, number: provenBlockNumber },
-      finalized: { hash: provenBlockHash!, number: provenBlockNumber },
-    });
-  }
-
-  public async handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
+  public handleBlockStreamEvent(event: L2BlockSourceEvent): Promise<void> {
     this.log.debug(`Handling block stream event ${event.type}`);
     switch (event.type) {
-      case 'blocks-added':
-        await this.handleLatestL2Blocks(event.blocks);
-        break;
-      case 'chain-finalized':
-        // TODO (alexg): I think we can prune the block hashes map here
-        break;
-      case 'chain-proven': {
-        const from = (await this.getSyncedProvenBlockNum()) + 1;
-        const limit = event.blockNumber - from + 1;
-        await this.handleProvenL2Blocks(await this.l2BlockSource.getBlocks(from, limit));
-        break;
-      }
-      case 'chain-pruned':
-        await this.handlePruneL2Blocks(event.blockNumber);
+      case L2BlockSourceEvents.L2PruneDetected:
+        this.handlePruneL2Blocks(event);
         break;
       default: {
-        const _: never = event;
         break;
       }
     }
-  }
-
-  public async start() {
-    if (this.currentState === SlasherClientState.STOPPED) {
-      throw new Error('Slasher already stopped');
-    }
-    if (this.currentState !== SlasherClientState.IDLE) {
-      return this.syncPromise;
-    }
-
-    // get the current latest block numbers
-    this.latestBlockNumberAtStart = await this.l2BlockSource.getBlockNumber();
-    this.provenBlockNumberAtStart = await this.l2BlockSource.getProvenBlockNumber();
-
-    const syncedLatestBlock = (await this.getSyncedLatestBlockNum()) + 1;
-    const syncedProvenBlock = (await this.getSyncedProvenBlockNum()) + 1;
-
-    // if there are blocks to be retrieved, go to a synching state
-    if (syncedLatestBlock <= this.latestBlockNumberAtStart || syncedProvenBlock <= this.provenBlockNumberAtStart) {
-      this.setCurrentState(SlasherClientState.SYNCHING);
-      this.syncPromise = new Promise(resolve => {
-        this.syncResolve = resolve;
-      });
-      this.log.verbose(`Starting sync from ${syncedLatestBlock} (last proven ${syncedProvenBlock})`);
-    } else {
-      // if no blocks to be retrieved, go straight to running
-      this.setCurrentState(SlasherClientState.RUNNING);
-      this.syncPromise = Promise.resolve();
-      this.log.verbose(`Block ${syncedLatestBlock} (proven ${syncedProvenBlock}) already beyond current block`);
-    }
-
-    this.blockStream.start();
-    this.log.verbose(`Started block downloader from block ${syncedLatestBlock}`);
-
-    return this.syncPromise;
+    return Promise.resolve();
   }
 
   /**
    * Allows consumers to stop the instance of the slasher client.
    * 'ready' will now return 'false' and the running promise that keeps the client synced is interrupted.
    */
-  public async stop() {
+  public stop() {
     this.log.debug('Stopping Slasher client...');
-    await this.blockStream.stop();
-    this.log.debug('Stopped block downloader');
-    await this.store.close();
-    this.log.debug('Stopped slasher store');
-    this.setCurrentState(SlasherClientState.STOPPED);
+    this.l2BlockSource.removeListener(L2BlockSourceEvents.L2PruneDetected, this.handlePruneL2Blocks.bind(this));
     this.log.info('Slasher client stopped.');
   }
 
-  /**
-   * Public function to check if the slasher client is fully synced and ready to receive txs.
-   * @returns True if the slasher client is ready to receive txs.
-   */
-  public isReady() {
-    return this.currentState === SlasherClientState.RUNNING;
-  }
-
-  /**
-   * Public function to check the latest block number that the slasher client is synced to.
-   * @returns Block number of latest L2 Block we've synced with.
-   */
-  public async getSyncedLatestBlockNum(): Promise<number> {
-    return (await this.synchedLatestBlockNumber.getAsync()) ?? INITIAL_L2_BLOCK_NUM - 1;
-  }
-
-  /**
-   * Public function to check the latest proven block number that the slasher client is synced to.
-   * @returns Block number of latest proven L2 Block we've synced with.
-   */
-  public async getSyncedProvenBlockNum(): Promise<number> {
-    return (await this.synchedProvenBlockNumber.getAsync()) ?? INITIAL_L2_BLOCK_NUM - 1;
-  }
-
-  /**
-   * Method to check the status of the slasher client.
-   * @returns Information about slasher client status: state & syncedToBlockNum.
-   */
-  public async getStatus(): Promise<SlasherSyncState> {
-    const blockNumber = await this.getSyncedLatestBlockNum();
-    const blockHash =
-      blockNumber == 0
-        ? ''
-        : await this.l2BlockSource
-            .getBlockHeader(blockNumber)
-            .then(header => header?.hash())
-            .then(hash => hash?.toString());
-    return Promise.resolve({
-      state: this.currentState,
-      syncedToL2Block: { number: blockNumber, hash: blockHash },
-    } as SlasherSyncState);
-  }
-
-  /**
-   * Handles new blocks
-   * @param blocks - A list of blocks that the slasher client needs to store block hashes for
-   * @returns Empty promise.
-   */
-  private async handleLatestL2Blocks(blocks: L2Block[]): Promise<void> {
-    if (!blocks.length) {
-      return;
-    }
-
-    await this.store.transactionAsync(async () => {
-      for (const block of blocks) {
-        await this.synchedBlockHashes.set(block.number, (await block.hash()).toString());
-      }
-
-      const lastBlockNum = blocks[blocks.length - 1].number;
-      await this.synchedLatestBlockNumber.set(lastBlockNum);
-    });
-
-    await this.startServiceIfSynched();
-  }
-
-  /**
-   * Handles new proven blocks by updating the proven block number
-   * @param blocks - A list of proven L2 blocks.
-   * @returns Empty promise.
-   */
-  private async handleProvenL2Blocks(blocks: L2Block[]): Promise<void> {
-    if (!blocks.length) {
-      return Promise.resolve();
-    }
-    const lastBlockNum = blocks[blocks.length - 1].number;
-    await this.synchedProvenBlockNumber.set(lastBlockNum);
-    this.log.debug(`Synched to proven block ${lastBlockNum}`);
-
-    await this.startServiceIfSynched();
-  }
-
-  private async handlePruneL2Blocks(latestBlock: number): Promise<void> {
-    const blockHeader = await this.l2BlockSource.getBlockHeader(latestBlock);
-    const slotNumber = blockHeader ? blockHeader.globalVariables.slotNumber.toBigInt() : BigInt(0);
-    const epochNumber = slotNumber / BigInt(this.config.aztecEpochDuration);
+  // I need to get the slot number from the block that was just pruned
+  private handlePruneL2Blocks(event: L2BlockSourceEvent): void {
+    const { slotNumber, epochNumber } = event;
     this.log.info(`Detected chain prune. Punishing the validators at epoch ${epochNumber}`);
 
     // Set the lifetime such that we have a full round that we could vote throughout.
@@ -382,34 +189,5 @@ export class SlasherClient extends WithTracer {
       amount: this.slashingAmount,
       lifetime,
     });
-
-    await this.synchedLatestBlockNumber.set(latestBlock);
-  }
-
-  private async startServiceIfSynched() {
-    const [latestBlock, provenBlock] = await Promise.all([
-      this.getSyncedLatestBlockNum(),
-      this.getSyncedProvenBlockNum(),
-    ]);
-    if (
-      this.currentState === SlasherClientState.SYNCHING &&
-      latestBlock >= this.latestBlockNumberAtStart &&
-      provenBlock >= this.provenBlockNumberAtStart
-    ) {
-      this.log.debug(`Synched to blocks at start`);
-      this.setCurrentState(SlasherClientState.RUNNING);
-      if (this.syncResolve !== undefined) {
-        this.syncResolve();
-      }
-    }
-  }
-
-  /**
-   * Method to set the value of the current state.
-   * @param newState - New state value.
-   */
-  private setCurrentState(newState: SlasherClientState) {
-    this.currentState = newState;
-    this.log.debug(`Moved to state ${SlasherClientState[this.currentState]}`);
   }
 }

package/src/test/index.ts

@@ -1,9 +1,9 @@
-import { type PublicProcessorFactory } from '@aztec/simulator/server';
+import type { PublicProcessorFactory } from '@aztec/simulator/server';
 
 import { SequencerClient } from '../client/sequencer-client.js';
-import { type SequencerPublisher } from '../publisher/sequencer-publisher.js';
+import type { SequencerPublisher } from '../publisher/sequencer-publisher.js';
 import { Sequencer } from '../sequencer/sequencer.js';
-import { type SequencerTimetable } from '../sequencer/timetable.js';
+import type { SequencerTimetable } from '../sequencer/timetable.js';
 
 class TestSequencer_ extends Sequencer {
   public override publicProcessorFactory!: PublicProcessorFactory;

package/src/tx_validator/archive_cache.ts

@@ -1,6 +1,7 @@
-import { MerkleTreeId, type MerkleTreeReadOperations } from '@aztec/circuit-types';
-import { type Fr } from '@aztec/circuits.js';
-import { type ArchiveSource } from '@aztec/p2p';
+import type { Fr } from '@aztec/foundation/fields';
+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.

package/src/tx_validator/gas_validator.ts

@@ -1,8 +1,11 @@
-import { type Tx, TxExecutionPhase, type TxValidationResult, type TxValidator } from '@aztec/circuit-types';
-import { type AztecAddress, Fr, FunctionSelector, type GasFees } from '@aztec/circuits.js';
-import { U128 } from '@aztec/foundation/abi';
+import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
-import { computeFeePayerBalanceStorageSlot, getExecutionRequestsByPhase } from '@aztec/simulator/server';
+import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
+import { getExecutionRequestsByPhase } from '@aztec/simulator/server';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasFees } from '@aztec/stdlib/gas';
+import { type Tx, TxExecutionPhase, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 
 /** Provides a view into public contract state */
 export interface PublicStateSource {
@@ -13,23 +16,16 @@ export class GasTxValidator implements TxValidator<Tx> {
   #log = createLogger('sequencer:tx_validator:tx_gas');
   #publicDataSource: PublicStateSource;
   #feeJuiceAddress: AztecAddress;
-  #enforceFees: boolean;
   #gasFees: GasFees;
 
-  constructor(
-    publicDataSource: PublicStateSource,
-    feeJuiceAddress: AztecAddress,
-    enforceFees: boolean,
-    gasFees: GasFees,
-  ) {
+  constructor(publicDataSource: PublicStateSource, feeJuiceAddress: AztecAddress, gasFees: GasFees) {
     this.#publicDataSource = publicDataSource;
     this.#feeJuiceAddress = feeJuiceAddress;
-    this.#enforceFees = enforceFees;
     this.#gasFees = gasFees;
   }
 
-  validateTx(tx: Tx): Promise<TxValidationResult> {
-    if (this.#shouldSkip(tx)) {
+  async validateTx(tx: Tx): Promise<TxValidationResult> {
+    if (await this.#shouldSkip(tx)) {
       return Promise.resolve({ result: 'skipped', reason: ['Insufficient fee per gas'] });
     }
     return this.#validateTxFee(tx);
@@ -37,11 +33,11 @@ export class GasTxValidator implements TxValidator<Tx> {
 
   /**
    * Check whether the tx's max fees are valid for the current block, and skip if not.
-   * We skip instead of invalidating since the tx may become elligible later.
+   * We skip instead of invalidating since the tx may become eligible later.
    * Note that circuits check max fees even if fee payer is unset, so we
    * keep this validation even if the tx does not pay fees.
    */
-  #shouldSkip(tx: Tx): boolean {
+  async #shouldSkip(tx: Tx): Promise<boolean> {
     const gasSettings = tx.data.constants.txContext.gasSettings;
 
     // Skip the tx if its max fees are not enough for the current block's gas fees.
@@ -51,22 +47,16 @@ export class GasTxValidator implements TxValidator<Tx> {
       maxFeesPerGas.feePerL2Gas.lt(this.#gasFees.feePerL2Gas);
 
     if (notEnoughMaxFees) {
-      this.#log.warn(`Skipping transaction ${tx.getTxHash()} due to insufficient fee per gas`);
+      this.#log.warn(`Skipping transaction ${await tx.getTxHash()} due to insufficient fee per gas`, {
+        txMaxFeesPerGas: maxFeesPerGas.toInspect(),
+        currentGasFees: this.#gasFees.toInspect(),
+      });
     }
     return notEnoughMaxFees;
   }
 
   async #validateTxFee(tx: Tx): Promise<TxValidationResult> {
     const feePayer = tx.data.feePayer;
-    // TODO(@spalladino) Eventually remove the is_zero condition as we should always charge fees to every tx
-    if (feePayer.isZero()) {
-      if (this.#enforceFees) {
-        this.#log.warn(`Rejecting transaction ${tx.getTxHash()} due to missing fee payer`);
-        return { result: 'invalid', reason: ['Missing fee payer'] };
-      } else {
-        return { result: 'valid' };
-      }
-    }
 
     // Compute the maximum fee that this tx may pay, based on its gasLimits and maxFeePerGas
     const feeLimit = tx.data.constants.txContext.gasSettings.getFeeLimit();
@@ -80,7 +70,7 @@ export class GasTxValidator implements TxValidator<Tx> {
     // If there is a claim in this tx that increases the fee payer balance in Fee Juice, add it to balance
     const setupFns = getExecutionRequestsByPhase(tx, TxExecutionPhase.SETUP);
     const increasePublicBalanceSelector = await FunctionSelector.fromSignature(
-      '_increase_public_balance((Field),(Field,Field))',
+      '_increase_public_balance((Field),u128)',
     );
     const claimFunctionCall = setupFns.find(
       fn =>
@@ -93,10 +83,11 @@ export class GasTxValidator implements TxValidator<Tx> {
         !fn.callContext.isStaticCall,
     );
 
-    // `amount` in the claim function call arguments occupies 2 fields as it is represented as U128.
-    const balance = claimFunctionCall
-      ? initialBalance.add(new Fr(U128.fromFields(claimFunctionCall.args.slice(2, 4)).toInteger()))
-      : initialBalance;
+    // The claim amount is at index 2 in the args array because:
+    // - Index 0: Target function selector (due to dispatch routing)
+    // - Index 1: Amount recipient
+    // - Index 2: Amount being claimed
+    const balance = claimFunctionCall ? initialBalance.add(claimFunctionCall.args[2]) : initialBalance;
     if (balance.lt(feeLimit)) {
       this.#log.warn(`Rejecting transaction due to not enough fee payer balance`, {
         feePayer,

package/src/tx_validator/nullifier_cache.ts

@@ -1,5 +1,6 @@
-import { MerkleTreeId, type MerkleTreeReadOperations } from '@aztec/circuit-types';
-import { type NullifierSource } from '@aztec/p2p';
+import type { NullifierSource } from '@aztec/p2p';
+import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
 
 /**
  * Implements a nullifier source by checking a DB and an in-memory collection.

package/src/tx_validator/phases_validator.ts

@@ -1,14 +1,14 @@
+import { createLogger } from '@aztec/foundation/log';
+import { ContractsDataSourcePublicDB, getExecutionRequestsByPhase } from '@aztec/simulator/server';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
 import {
-  type AllowedElement,
   type PublicExecutionRequest,
   Tx,
   TxExecutionPhase,
   type TxValidationResult,
   type TxValidator,
-} from '@aztec/circuit-types';
-import { type ContractDataSource } from '@aztec/circuits.js';
-import { createLogger } from '@aztec/foundation/log';
-import { ContractsDataSourcePublicDB, getExecutionRequestsByPhase } from '@aztec/simulator/server';
+} from '@aztec/stdlib/tx';
 
 export class PhasesTxValidator implements TxValidator<Tx> {
   #log = createLogger('sequencer:tx_validator:tx_phases');
@@ -46,7 +46,7 @@ export class PhasesTxValidator implements TxValidator<Tx> {
 
       return { result: 'valid' };
     } finally {
-      await this.contractDataSource.removeNewContracts(tx);
+      this.contractDataSource.clearContractsForTx();
     }
   }
 
@@ -78,14 +78,14 @@ export class PhasesTxValidator implements TxValidator<Tx> {
       }
 
       if ('classId' in entry && !('selector' in entry)) {
-        if (contractClass.contractClassId.equals(entry.classId)) {
+        if (contractClass.currentContractClassId.equals(entry.classId)) {
           return true;
         }
       }
 
       if ('classId' in entry && 'selector' in entry) {
         if (
-          contractClass.contractClassId.equals(entry.classId) &&
+          contractClass.currentContractClassId.equals(entry.classId) &&
           (entry.selector === undefined || entry.selector.equals(functionSelector))
         ) {
           return true;

package/src/tx_validator/test_utils.ts

@@ -1,6 +1,8 @@
-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';
+import type { Fr } from '@aztec/foundation/fields';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { computeVarArgsHash } from '@aztec/stdlib/hash';
+import type { Tx } from '@aztec/stdlib/tx';
 
 export function patchNonRevertibleFn(
   tx: Tx,

package/src/tx_validator/tx_validator_factory.ts

@@ -1,12 +1,4 @@
-import {
-  type AllowedElement,
-  type ClientProtocolCircuitVerifier,
-  type MerkleTreeReadOperations,
-  type ProcessedTx,
-  type Tx,
-  type TxValidator,
-} from '@aztec/circuit-types';
-import { type AztecAddress, type ContractDataSource, Fr, type GasFees, type GlobalVariables } from '@aztec/circuits.js';
+import { Fr } from '@aztec/foundation/fields';
 import {
   AggregateTxValidator,
   BlockHeaderTxValidator,
@@ -17,6 +9,15 @@ import {
 } from '@aztec/p2p';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { readPublicState } from '@aztec/simulator/server';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { GasFees } from '@aztec/stdlib/gas';
+import type {
+  AllowedElement,
+  ClientProtocolCircuitVerifier,
+  MerkleTreeReadOperations,
+} from '@aztec/stdlib/interfaces/server';
+import { GlobalVariables, type ProcessedTx, type Tx, type TxValidator } from '@aztec/stdlib/tx';
 
 import { ArchiveCache } from './archive_cache.js';
 import { GasTxValidator, type PublicStateSource } from './gas_validator.js';
@@ -27,24 +28,32 @@ export function createValidatorForAcceptingTxs(
   db: MerkleTreeReadOperations,
   contractDataSource: ContractDataSource,
   verifier: ClientProtocolCircuitVerifier | undefined,
-  data: {
+  {
+    blockNumber,
+    l1ChainId,
+    setupAllowList,
+    gasFees,
+    skipFeeEnforcement,
+  }: {
     blockNumber: number;
     l1ChainId: number;
-    enforceFees: boolean;
     setupAllowList: AllowedElement[];
     gasFees: GasFees;
+    skipFeeEnforcement?: boolean;
   },
 ): TxValidator<Tx> {
-  const { blockNumber, l1ChainId, enforceFees, setupAllowList, gasFees } = data;
   const validators: TxValidator<Tx>[] = [
     new DataTxValidator(),
     new MetadataTxValidator(new Fr(l1ChainId), new Fr(blockNumber)),
     new DoubleSpendTxValidator(new NullifierCache(db)),
     new PhasesTxValidator(contractDataSource, setupAllowList),
-    new GasTxValidator(new DatabasePublicStateSource(db), ProtocolContractAddress.FeeJuice, enforceFees, gasFees),
     new BlockHeaderTxValidator(new ArchiveCache(db)),
   ];
 
+  if (!skipFeeEnforcement) {
+    validators.push(new GasTxValidator(new DatabasePublicStateSource(db), ProtocolContractAddress.FeeJuice, gasFees));
+  }
+
   if (verifier) {
     validators.push(new TxProofValidator(verifier));
   }
@@ -56,7 +65,6 @@ export function createValidatorsForBlockBuilding(
   db: MerkleTreeReadOperations,
   contractDataSource: ContractDataSource,
   globalVariables: GlobalVariables,
-  enforceFees: boolean,
   setupAllowList: AllowedElement[],
 ): {
   preprocessValidator: TxValidator<Tx>;
@@ -73,7 +81,6 @@ export function createValidatorsForBlockBuilding(
       archiveCache,
       publicStateSource,
       contractDataSource,
-      enforceFees,
       globalVariables,
       setupAllowList,
     ),
@@ -95,7 +102,6 @@ function preprocessValidator(
   archiveCache: ArchiveCache,
   publicStateSource: PublicStateSource,
   contractDataSource: ContractDataSource,
-  enforceFees: boolean,
   globalVariables: GlobalVariables,
   setupAllowList: AllowedElement[],
 ): TxValidator<Tx> {
@@ -104,7 +110,7 @@ function preprocessValidator(
     new MetadataTxValidator(globalVariables.chainId, globalVariables.blockNumber),
     new DoubleSpendTxValidator(nullifierCache),
     new PhasesTxValidator(contractDataSource, setupAllowList),
-    new GasTxValidator(publicStateSource, ProtocolContractAddress.FeeJuice, enforceFees, globalVariables.gasFees),
+    new GasTxValidator(publicStateSource, ProtocolContractAddress.FeeJuice, globalVariables.gasFees),
     new BlockHeaderTxValidator(archiveCache),
   );
 }