@aztec/sequencer-client 0.41.0 → 0.43.0

package/src/config.ts

@@ -1,14 +1,11 @@
-import { type AllowedFunction } from '@aztec/circuit-types';
+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 { EthAddress } from '@aztec/foundation/eth-address';
-import { EcdsaAccountContractArtifact } from '@aztec/noir-contracts.js/EcdsaAccount';
 import { FPCContract } from '@aztec/noir-contracts.js/FPC';
-import { GasTokenContract } from '@aztec/noir-contracts.js/GasToken';
-import { SchnorrAccountContractArtifact } from '@aztec/noir-contracts.js/SchnorrAccount';
-import { SchnorrHardcodedAccountContractArtifact } from '@aztec/noir-contracts.js/SchnorrHardcodedAccount';
-import { SchnorrSingleKeyAccountContractArtifact } from '@aztec/noir-contracts.js/SchnorrSingleKeyAccount';
 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';
 
@@ -50,6 +47,7 @@ export function getConfigEnvVars(): SequencerClientConfig {
     SEQ_MIN_TX_PER_BLOCK,
     SEQ_ALLOWED_SETUP_FN,
     SEQ_ALLOWED_TEARDOWN_FN,
+    SEQ_MAX_BLOCK_SIZE_IN_BYTES,
     AVAILABILITY_ORACLE_CONTRACT_ADDRESS,
     ROLLUP_CONTRACT_ADDRESS,
     REGISTRY_CONTRACT_ADDRESS,
@@ -61,6 +59,7 @@ export function getConfigEnvVars(): SequencerClientConfig {
     FEE_RECIPIENT,
     ACVM_WORKING_DIRECTORY,
     ACVM_BINARY_PATH,
+    ENFORCE_FEES = '',
   } = process.env;
 
   const publisherPrivateKey: Hex = SEQ_PUBLISHER_PRIVATE_KEY
@@ -82,6 +81,7 @@ export function getConfigEnvVars(): SequencerClientConfig {
   };
 
   return {
+    enforceFees: ['1', 'true'].includes(ENFORCE_FEES),
     rpcUrl: ETHEREUM_HOST ? ETHEREUM_HOST : '',
     chainId: CHAIN_ID ? +CHAIN_ID : 31337, // 31337 is the default chain id for anvil
     version: VERSION ? +VERSION : 1, // 1 is our default version
@@ -89,6 +89,7 @@ export function getConfigEnvVars(): SequencerClientConfig {
     requiredConfirmations: SEQ_REQUIRED_CONFIRMATIONS ? +SEQ_REQUIRED_CONFIRMATIONS : 1,
     l1BlockPublishRetryIntervalMS: 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,
     maxTxsPerBlock: SEQ_MAX_TX_PER_BLOCK ? +SEQ_MAX_TX_PER_BLOCK : 32,
@@ -98,73 +99,81 @@ export function getConfigEnvVars(): SequencerClientConfig {
     feeRecipient: FEE_RECIPIENT ? AztecAddress.fromString(FEE_RECIPIENT) : undefined,
     acvmWorkingDirectory: ACVM_WORKING_DIRECTORY ? ACVM_WORKING_DIRECTORY : undefined,
     acvmBinaryPath: ACVM_BINARY_PATH ? ACVM_BINARY_PATH : undefined,
-    allowedFunctionsInSetup: SEQ_ALLOWED_SETUP_FN
+    allowedInSetup: SEQ_ALLOWED_SETUP_FN
       ? parseSequencerAllowList(SEQ_ALLOWED_SETUP_FN)
       : getDefaultAllowedSetupFunctions(),
-    allowedFunctionsInTeardown: SEQ_ALLOWED_TEARDOWN_FN
+    allowedInTeardown: SEQ_ALLOWED_TEARDOWN_FN
       ? parseSequencerAllowList(SEQ_ALLOWED_TEARDOWN_FN)
       : getDefaultAllowedTeardownFunctions(),
   };
 }
 
-function parseSequencerAllowList(value: string): AllowedFunction[] {
-  const entries: AllowedFunction[] = [];
+/**
+ * Parses a string to a list of allowed elements.
+ * Each encoded is expected to be of one of the following formats
+ * `I:${address}`
+ * `I:${address}:${selector}`
+ * `C:${classId}`
+ * `C:${classId}:${selector}`
+ *
+ * @param value The string to parse
+ * @returns A list of allowed elements
+ */
+export function parseSequencerAllowList(value: string): AllowedElement[] {
+  const entries: AllowedElement[] = [];
 
   if (!value) {
     return entries;
   }
 
   for (const val of value.split(',')) {
-    const [identifierString, selectorString] = val.split(':');
-    const selector = FunctionSelector.fromString(selectorString);
-
-    if (identifierString.startsWith('0x')) {
-      entries.push({
-        address: AztecAddress.fromString(identifierString),
-        selector,
-      });
-    } else {
-      entries.push({
-        classId: Fr.fromString(identifierString),
-        selector,
-      });
+    const [typeString, identifierString, selectorString] = val.split(':');
+    const selector = selectorString !== undefined ? FunctionSelector.fromString(selectorString) : undefined;
+
+    if (typeString === 'I') {
+      if (selector) {
+        entries.push({
+          address: AztecAddress.fromString(identifierString),
+          selector,
+        });
+      } else {
+        entries.push({
+          address: AztecAddress.fromString(identifierString),
+        });
+      }
+    } else if (typeString === 'C') {
+      if (selector) {
+        entries.push({
+          classId: Fr.fromString(identifierString),
+          selector,
+        });
+      } else {
+        entries.push({
+          classId: Fr.fromString(identifierString),
+        });
+      }
     }
   }
 
   return entries;
 }
 
-function getDefaultAllowedSetupFunctions(): AllowedFunction[] {
+function getDefaultAllowedSetupFunctions(): AllowedElement[] {
   return [
+    // needed for authwit support
     {
-      classId: getContractClassFromArtifact(SchnorrAccountContractArtifact).id,
-      selector: FunctionSelector.fromSignature('approve_public_authwit(Field)'),
-    },
-    {
-      classId: getContractClassFromArtifact(SchnorrHardcodedAccountContractArtifact).id,
-      selector: FunctionSelector.fromSignature('approve_public_authwit(Field)'),
-    },
-    {
-      classId: getContractClassFromArtifact(SchnorrSingleKeyAccountContractArtifact).id,
-      selector: FunctionSelector.fromSignature('approve_public_authwit(Field)'),
+      address: AuthRegistryAddress,
     },
+    // needed for claiming on the same tx as a spend
     {
-      classId: getContractClassFromArtifact(EcdsaAccountContractArtifact).id,
-      selector: FunctionSelector.fromSignature('approve_public_authwit(Field)'),
-    },
-
-    // needed for native payments while they are not yet enshrined
-    {
-      classId: getContractClassFromArtifact(GasTokenContract.artifact).id,
-      selector: FunctionSelector.fromSignature('pay_fee(Field)'),
+      address: GasTokenAddress,
+      selector: FunctionSelector.fromSignature('_increase_public_balance((Field),Field)'),
     },
-
     // needed for private transfers via FPC
     {
       classId: getContractClassFromArtifact(TokenContractArtifact).id,
       selector: FunctionSelector.fromSignature('_increase_public_balance((Field),Field)'),
     },
-
     {
       classId: getContractClassFromArtifact(FPCContract.artifact).id,
       selector: FunctionSelector.fromSignature('prepare_fee((Field),Field,(Field),Field)'),
@@ -172,19 +181,15 @@ function getDefaultAllowedSetupFunctions(): AllowedFunction[] {
   ];
 }
 
-function getDefaultAllowedTeardownFunctions(): AllowedFunction[] {
+function getDefaultAllowedTeardownFunctions(): AllowedElement[] {
   return [
-    {
-      classId: getContractClassFromArtifact(GasTokenContract.artifact).id,
-      selector: FunctionSelector.fromSignature('pay_fee(Field)'),
-    },
     {
       classId: getContractClassFromArtifact(FPCContract.artifact).id,
-      selector: FunctionSelector.fromSignature('pay_fee((Field),Field,(Field))'),
+      selector: FunctionSelector.fromSignature('pay_refund((Field),Field,(Field))'),
     },
     {
       classId: getContractClassFromArtifact(FPCContract.artifact).id,
-      selector: FunctionSelector.fromSignature('pay_fee_with_shielded_rebate(Field,(Field),Field)'),
+      selector: FunctionSelector.fromSignature('pay_refund_with_shielded_rebate(Field,(Field),Field)'),
     },
   ];
 }

package/src/publisher/l1-publisher.ts

@@ -1,6 +1,8 @@
 import { type L2Block } from '@aztec/circuit-types';
 import { type L1PublishStats } from '@aztec/circuit-types/stats';
+import { type EthAddress, type Fr, type Proof } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
+import { serializeToBuffer } from '@aztec/foundation/serialize';
 import { InterruptibleSleep } from '@aztec/foundation/sleep';
 
 import pick from 'lodash.pick';
@@ -40,6 +42,10 @@ export type MinimalTransactionReceipt = {
  * Pushes txs to the L1 chain and waits for their completion.
  */
 export interface L1PublisherTxSender {
+  getSenderAddress(): Promise<EthAddress>;
+
+  getSubmitterAddressForBlock(blockNumber: number): Promise<EthAddress>;
+
   /**
    * Publishes tx effects to Availability Oracle.
    * @param encodedBody - Encoded block body.
@@ -91,6 +97,8 @@ export type L1ProcessArgs = {
   archive: Buffer;
   /** L2 block body. */
   body: Buffer;
+  /** Aggregation object needed to verify the proof */
+  aggregationObject: Buffer;
   /** Root rollup proof of the L2 block. */
   proof: Buffer;
 };
@@ -113,12 +121,18 @@ export class L1Publisher implements L2BlockReceiver {
     this.sleepTimeMs = config?.l1BlockPublishRetryIntervalMS ?? 60_000;
   }
 
+  public async isItMyTurnToSubmit(blockNumber: number): Promise<boolean> {
+    const submitter = await this.txSender.getSubmitterAddressForBlock(blockNumber);
+    const sender = await this.txSender.getSenderAddress();
+    return submitter.isZero() || submitter.equals(sender);
+  }
+
   /**
    * Publishes L2 block on L1.
    * @param block - L2 block to publish.
    * @returns True once the tx has been confirmed and is successful, false on revert or interrupt, blocks otherwise.
    */
-  public async processL2Block(block: L2Block): Promise<boolean> {
+  public async processL2Block(block: L2Block, aggregationObject: Fr[], proof: Proof): Promise<boolean> {
     // TODO(#4148) Remove this block number check, it's here because we don't currently have proper genesis state on the contract
     const lastArchive = block.header.lastArchive.root.toBuffer();
     if (block.number != 1 && !(await this.checkLastArchiveHash(lastArchive))) {
@@ -166,7 +180,8 @@ export class L1Publisher implements L2BlockReceiver {
       header: block.header.toBuffer(),
       archive: block.archive.root.toBuffer(),
       body: encodedBody,
-      proof: Buffer.alloc(0),
+      aggregationObject: serializeToBuffer(aggregationObject),
+      proof: proof.withoutPublicInputs(),
     };
 
     // Process block
@@ -242,6 +257,7 @@ export class L1Publisher implements L2BlockReceiver {
   private async sendPublishTx(encodedBody: Buffer): Promise<string | undefined> {
     while (!this.interrupted) {
       try {
+        this.log.info(`TxEffects size=${encodedBody.length} bytes`);
         return await this.txSender.sendPublishTx(encodedBody);
       } catch (err) {
         this.log.error(`TxEffects publish failed`, err);

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

@@ -1,4 +1,5 @@
 import { type L2Block } from '@aztec/circuit-types';
+import { EthAddress } from '@aztec/circuits.js';
 import { createEthereumChain } from '@aztec/ethereum';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { AvailabilityOracleAbi, RollupAbi } from '@aztec/l1-artifacts';
@@ -71,6 +72,20 @@ export class ViemTxSender implements L1PublisherTxSender {
     });
   }
 
+  getSenderAddress(): Promise<EthAddress> {
+    return Promise.resolve(EthAddress.fromString(this.account.address));
+  }
+
+  async getSubmitterAddressForBlock(blockNumber: number): Promise<EthAddress> {
+    try {
+      const submitter = await this.rollupContract.read.whoseTurnIsIt([BigInt(blockNumber)]);
+      return EthAddress.fromString(submitter);
+    } catch (err) {
+      this.log.warn(`Failed to get submitter for block ${blockNumber}: ${err}`);
+      return EthAddress.ZERO;
+    }
+  }
+
   async getCurrentArchive(): Promise<Buffer> {
     const archive = await this.rollupContract.read.archive();
     return Buffer.from(archive.replace('0x', ''), 'hex');
@@ -145,6 +160,7 @@ export class ViemTxSender implements L1PublisherTxSender {
     const args = [
       `0x${encodedData.header.toString('hex')}`,
       `0x${encodedData.archive.toString('hex')}`,
+      `0x${encodedData.aggregationObject.toString('hex')}`,
       `0x${encodedData.proof.toString('hex')}`,
     ] as const;
 

package/src/receiver.ts

@@ -1,4 +1,5 @@
 import { type L2Block } from '@aztec/circuit-types';
+import type { Fr, Proof } from '@aztec/circuits.js';
 
 /**
  * Given the necessary rollup data, verifies it, and updates the underlying state accordingly to advance the state of the system.
@@ -8,6 +9,8 @@ export interface L2BlockReceiver {
   /**
    * Receive and L2 block and process it, returns true if successful.
    * @param l2BlockData - L2 block to process.
+   * @param aggregationObject - The aggregation object for the block's proof.
+   * @param proof - The proof for the block.
    */
-  processL2Block(l2BlockData: L2Block): Promise<boolean>;
+  processL2Block(l2BlockData: L2Block, aggregationObject: Fr[], proof: Proof): Promise<boolean>;
 }

package/src/sequencer/sequencer.ts

@@ -6,9 +6,14 @@ import {
   Tx,
   type TxValidator,
 } from '@aztec/circuit-types';
-import { type AllowedFunction, type BlockProver, PROVING_STATUS } from '@aztec/circuit-types/interfaces';
+import {
+  type AllowedElement,
+  BlockProofError,
+  type BlockProver,
+  PROVING_STATUS,
+} from '@aztec/circuit-types/interfaces';
 import { type L2BlockBuiltStats } from '@aztec/circuit-types/stats';
-import { AztecAddress, EthAddress } from '@aztec/circuits.js';
+import { AztecAddress, EthAddress, type Proof } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
@@ -41,8 +46,9 @@ export class Sequencer {
   private _feeRecipient = AztecAddress.ZERO;
   private lastPublishedBlock = 0;
   private state = SequencerState.STOPPED;
-  private allowedFunctionsInSetup: AllowedFunction[] = [];
-  private allowedFunctionsInTeardown: AllowedFunction[] = [];
+  private allowedInSetup: AllowedElement[] = [];
+  private allowedInTeardown: AllowedElement[] = [];
+  private maxBlockSizeInBytes: number = 1024 * 1024;
 
   constructor(
     private publisher: L1Publisher,
@@ -81,12 +87,15 @@ export class Sequencer {
     if (config.feeRecipient) {
       this._feeRecipient = config.feeRecipient;
     }
-    if (config.allowedFunctionsInSetup) {
-      this.allowedFunctionsInSetup = config.allowedFunctionsInSetup;
+    if (config.allowedInSetup) {
+      this.allowedInSetup = config.allowedInSetup;
+    }
+    if (config.maxBlockSizeInBytes) {
+      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.allowedFunctionsInTeardown) {
-      this.allowedFunctionsInTeardown = config.allowedFunctionsInTeardown;
+    if (config.allowedInTeardown) {
+      this.allowedInTeardown = config.allowedInTeardown;
     }
   }
 
@@ -153,6 +162,18 @@ export class Sequencer {
         return;
       }
 
+      const historicalHeader = (await this.l2BlockSource.getBlock(-1))?.header;
+      const newBlockNumber =
+        (historicalHeader === undefined
+          ? await this.l2BlockSource.getBlockNumber()
+          : 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');
+        return;
+      }
+
       const workTimer = new Timer();
       this.state = SequencerState.WAITING_FOR_TXS;
 
@@ -163,12 +184,6 @@ export class Sequencer {
       }
       this.log.debug(`Retrieved ${pendingTxs.length} txs from P2P pool`);
 
-      const historicalHeader = (await this.l2BlockSource.getBlock(-1))?.header;
-      const newBlockNumber =
-        (historicalHeader === undefined
-          ? await this.l2BlockSource.getBlockNumber()
-          : Number(historicalHeader.globalVariables.blockNumber.toBigInt())) + 1;
-
       /**
        * We'll call this function before running expensive operations to avoid wasted work.
        */
@@ -177,6 +192,9 @@ export class Sequencer {
         if (currentBlockNumber + 1 !== newBlockNumber) {
           throw new Error('New block was emitted while building block');
         }
+        if (!(await this.publisher.isItMyTurnToSubmit(newBlockNumber))) {
+          throw new Error(`Not this sequencer turn to submit block`);
+        }
       };
 
       const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(
@@ -186,10 +204,18 @@ export class Sequencer {
       );
 
       // TODO: It should be responsibility of the P2P layer to validate txs before passing them on here
-      const validTxs = await this.takeValidTxs(
+      const allValidTxs = await this.takeValidTxs(
         pendingTxs,
-        this.txValidatorFactory.validatorForNewTxs(newGlobalVariables, this.allowedFunctionsInSetup),
+        this.txValidatorFactory.validatorForNewTxs(newGlobalVariables, this.allowedInSetup),
       );
+
+      // TODO: We are taking the size of the tx from private-land, but we should be doing this after running
+      // public functions. Only reason why we do it here now is because the public processor and orchestrator
+      // are set up such that they require knowing the total number of txs in advance. Still, main reason for
+      // exceeding max block size in bytes is contract class registration, which happens in private-land. This
+      // may break if we start emitting lots of log data from public-land.
+      const validTxs = this.takeTxsWithinMaxSize(allValidTxs);
+
       if (validTxs.length < this.minTxsPerBLock) {
         return;
       }
@@ -205,16 +231,15 @@ 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 emptyTx = processor.makeEmptyProcessedTx();
-
       const blockBuildingTimer = new Timer();
 
       // We must initialise the block to be a power of 2 in size
       const numRealTxs = validTxs.length;
       const pow2 = Math.log2(numRealTxs);
+      // TODO turn this back into a Math.ceil once we can pad blocks to the next-power-of-2 with empty txs
       const totalTxs = 2 ** Math.ceil(pow2);
       const blockSize = Math.max(2, totalTxs);
-      const blockTicket = await this.prover.startNewBlock(blockSize, newGlobalVariables, l1ToL2Messages, emptyTx);
+      const blockTicket = await this.prover.startNewBlock(blockSize, newGlobalVariables, l1ToL2Messages);
 
       const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
         processor.process(validTxs, blockSize, this.prover, this.txValidatorFactory.validatorForProcessedTxs()),
@@ -247,8 +272,7 @@ export class Sequencer {
       await assertBlockHeight();
 
       // Block is proven, now finalise and publish!
-      const blockResult = await this.prover.finaliseBlock();
-      const block = blockResult.block;
+      const { block, aggregationObject, proof } = await this.prover.finaliseBlock();
 
       await assertBlockHeight();
 
@@ -260,9 +284,14 @@ export class Sequencer {
         ...block.getStats(),
       } satisfies L2BlockBuiltStats);
 
-      await this.publishL2Block(block);
+      await this.publishL2Block(block, aggregationObject, proof);
       this.log.info(`Submitted rollup block ${block.number} with ${processedTxs.length} transactions`);
     } catch (err) {
+      if (BlockProofError.isBlockProofError(err)) {
+        const txHashes = err.txHashes.filter(h => !h.isZero());
+        this.log.warn(`Proving block failed, removing ${txHashes.length} txs from pool`);
+        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();
@@ -274,10 +303,10 @@ export class Sequencer {
    * Publishes the L2Block to the rollup contract.
    * @param block - The L2Block to be published.
    */
-  protected async publishL2Block(block: L2Block) {
+  protected async publishL2Block(block: L2Block, aggregationObject: Fr[], proof: Proof) {
     // 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, aggregationObject, proof);
     if (publishedL2Block) {
       this.lastPublishedBlock = block.number;
     } else {
@@ -295,6 +324,26 @@ export class Sequencer {
     return valid.slice(0, this.maxTxsPerBlock);
   }
 
+  protected takeTxsWithinMaxSize(txs: Tx[]): Tx[] {
+    const maxSize = this.maxBlockSizeInBytes;
+    let totalSize = 0;
+
+    const toReturn: Tx[] = [];
+    for (const tx of txs) {
+      const txSize = tx.getSize() - tx.proof.toBuffer().length;
+      if (totalSize + txSize > maxSize) {
+        this.log.warn(
+          `Dropping tx ${tx.getTxHash()} with estimated size ${txSize} due to exceeding ${maxSize} block size limit (currently at ${totalSize})`,
+        );
+        continue;
+      }
+      toReturn.push(tx);
+      totalSize += txSize;
+    }
+
+    return toReturn;
+  }
+
   /**
    * Returns whether the previous block sent has been mined, and all dependencies have caught up with it.
    * @returns Boolean indicating if our dependencies are synced to the latest block.

package/src/tx_validator/gas_validator.ts

@@ -1,6 +1,8 @@
-import { type Tx, type TxValidator } from '@aztec/circuit-types';
+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 { AbstractPhaseManager, computeFeePayerBalanceStorageSlot } from '@aztec/simulator';
 
 /** Provides a view into public contract state */
 export interface PublicStateSource {
@@ -11,12 +13,10 @@ export class GasTxValidator implements TxValidator<Tx> {
   #log = createDebugLogger('aztec:sequencer:tx_validator:tx_gas');
   #publicDataSource: PublicStateSource;
   #gasTokenAddress: AztecAddress;
-  #requireFees: boolean;
 
-  constructor(publicDataSource: PublicStateSource, gasTokenAddress: AztecAddress, requireFees = false) {
+  constructor(publicDataSource: PublicStateSource, gasTokenAddress: AztecAddress, public enforceFees: boolean) {
     this.#publicDataSource = publicDataSource;
     this.#gasTokenAddress = gasTokenAddress;
-    this.#requireFees = requireFees;
   }
 
   async validateTxs(txs: Tx[]): Promise<[validTxs: Tx[], invalidTxs: Tx[]]> {
@@ -34,9 +34,43 @@ export class GasTxValidator implements TxValidator<Tx> {
     return [validTxs, invalidTxs];
   }
 
-  #validateTxFee(_tx: Tx): Promise<boolean> {
-    return Promise.resolve(true);
+  async #validateTxFee(tx: Tx): Promise<boolean> {
+    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`);
+      } else {
+        return true;
+      }
+    }
+
+    // Compute the maximum fee that this tx may pay, based on its gasLimits and maxFeePerGas
+    const feeLimit = tx.data.constants.txContext.gasSettings.getFeeLimit();
 
-    // TODO(#5920) re-enable sequencer checks after we have fee payer in kernel outputs
+    // Read current balance of the feePayer
+    const initialBalance = await this.#publicDataSource.storageRead(
+      this.#gasTokenAddress,
+      computeFeePayerBalanceStorageSlot(feePayer),
+    );
+
+    // If there is a claim in this tx that increases the fee payer balance in gas token, 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.args[0].equals(feePayer) &&
+        !fn.callContext.isStaticCall &&
+        !fn.callContext.isDelegateCall,
+    );
+
+    const balance = claimFunctionCall ? initialBalance.add(claimFunctionCall.args[1]) : initialBalance;
+    if (balance.lt(feeLimit)) {
+      this.#log.info(`Rejecting transaction due to not enough fee payer balance`, { feePayer, balance, feeLimit });
+      return false;
+    }
+    return true;
   }
 }