@aztec/sequencer-client 0.42.0 → 0.44.0

package/src/sequencer/sequencer.ts

@@ -7,19 +7,20 @@ import {
   type TxValidator,
 } from '@aztec/circuit-types';
 import {
-  type AllowedFunction,
+  type AllowedElement,
   BlockProofError,
   type BlockProver,
   PROVING_STATUS,
 } from '@aztec/circuit-types/interfaces';
 import { type L2BlockBuiltStats } from '@aztec/circuit-types/stats';
-import { AztecAddress, EthAddress, type Proof } from '@aztec/circuits.js';
+import { AztecAddress, EthAddress, type GlobalVariables, type Header, 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';
 import { Timer, elapsed } from '@aztec/foundation/timer';
 import { type P2P } from '@aztec/p2p';
 import { type PublicProcessorFactory } from '@aztec/simulator';
+import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec/telemetry-client';
 import { type WorldStateStatus, type WorldStateSynchronizer } from '@aztec/world-state';
 
 import { type GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
@@ -46,10 +47,12 @@ 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;
 
+  public readonly tracer: Tracer;
+
   constructor(
     private publisher: L1Publisher,
     private globalsBuilder: GlobalVariableBuilder,
@@ -60,10 +63,12 @@ export class Sequencer {
     private l1ToL2MessageSource: L1ToL2MessageSource,
     private publicProcessorFactory: PublicProcessorFactory,
     private txValidatorFactory: TxValidatorFactory,
+    telemetry: TelemetryClient,
     config: SequencerConfig = {},
     private log = createDebugLogger('aztec:sequencer'),
   ) {
     this.updateConfig(config);
+    this.tracer = telemetry.getTracer('Sequencer');
     this.log.verbose(`Initialized sequencer with ${this.minTxsPerBLock}-${this.maxTxsPerBlock} txs per block.`);
   }
 
@@ -87,15 +92,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;
     }
   }
 
@@ -162,7 +167,18 @@ export class Sequencer {
         return;
       }
 
-      const workTimer = new Timer();
+      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;
+      }
+
       this.state = SequencerState.WAITING_FOR_TXS;
 
       // Get txs to build the new block
@@ -172,22 +188,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.
-       */
-      const assertBlockHeight = async () => {
-        const currentBlockNumber = await this.l2BlockSource.getBlockNumber();
-        if (currentBlockNumber + 1 !== newBlockNumber) {
-          throw new Error('New block was emitted while building block');
-        }
-      };
-
       const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(
         new Fr(newBlockNumber),
         this._coinbase,
@@ -197,7 +197,7 @@ export class Sequencer {
       // TODO: It should be responsibility of the P2P layer to validate txs before passing them on here
       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
@@ -211,72 +211,7 @@ export class Sequencer {
         return;
       }
 
-      this.log.info(`Building block ${newBlockNumber} with ${validTxs.length} transactions`);
-      this.state = SequencerState.CREATING_BLOCK;
-
-      // Get l1 to l2 messages from the contract
-      this.log.debug('Requesting L1 to L2 messages from contract');
-      const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(newBlockNumber));
-      this.log.verbose(`Retrieved ${l1ToL2Messages.length} L1 to L2 messages for block ${newBlockNumber}`);
-
-      // We create a fresh processor each time to reset any cached state (eg storage writes)
-      const processor = await this.publicProcessorFactory.create(historicalHeader, newGlobalVariables);
-
-      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);
-
-      const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
-        processor.process(validTxs, blockSize, this.prover, this.txValidatorFactory.validatorForProcessedTxs()),
-      );
-      if (failedTxs.length > 0) {
-        const failedTxData = failedTxs.map(fail => fail.tx);
-        this.log.debug(`Dropping failed txs ${Tx.getHashes(failedTxData).join(', ')}`);
-        await this.p2pClient.deleteTxs(Tx.getHashes(failedTxData));
-      }
-
-      if (processedTxs.length === 0) {
-        this.log.verbose('No txs processed correctly to build block. Exiting');
-        this.prover.cancelBlock();
-        return;
-      }
-
-      await assertBlockHeight();
-
-      // All real transactions have been added, set the block as full and complete the proving.
-      await this.prover.setBlockCompleted();
-
-      // Here we are now waiting for the block to be proven.
-      // TODO(@PhilWindle) We should probably periodically check for things like another
-      // block being published before ours instead of just waiting on our block
-      const result = await blockTicket.provingPromise;
-      if (result.status === PROVING_STATUS.FAILURE) {
-        throw new Error(`Block proving failed, reason: ${result.reason}`);
-      }
-
-      await assertBlockHeight();
-
-      // Block is proven, now finalise and publish!
-      const { block, aggregationObject, proof } = await this.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);
-
-      await this.publishL2Block(block, aggregationObject, proof);
-      this.log.info(`Submitted rollup block ${block.number} with ${processedTxs.length} transactions`);
+      await this.buildBlockAndPublish(validTxs, newGlobalVariables, historicalHeader);
     } catch (err) {
       if (BlockProofError.isBlockProofError(err)) {
         const txHashes = err.txHashes.filter(h => !h.isZero());
@@ -290,10 +225,100 @@ export class Sequencer {
     }
   }
 
+  @trackSpan('Sequencer.buildBlockAndPublish', (_validTxs, newGlobalVariables, _historicalHeader) => ({
+    [Attributes.BLOCK_NUMBER]: newGlobalVariables.blockNumber.toNumber(),
+  }))
+  private async buildBlockAndPublish(
+    validTxs: Tx[],
+    newGlobalVariables: GlobalVariables,
+    historicalHeader: Header | undefined,
+  ): Promise<void> {
+    const workTimer = new Timer();
+    this.state = SequencerState.CREATING_BLOCK;
+    this.log.info(`Building block ${newGlobalVariables.blockNumber.toNumber()} with ${validTxs.length} transactions`);
+
+    const assertBlockHeight = async () => {
+      const currentBlockNumber = await this.l2BlockSource.getBlockNumber();
+      if (currentBlockNumber + 1 !== newGlobalVariables.blockNumber.toNumber()) {
+        throw new Error('New block was emitted while building block');
+      }
+      if (!(await this.publisher.isItMyTurnToSubmit(newGlobalVariables.blockNumber.toNumber()))) {
+        throw new Error(`Not this sequencer turn to submit block`);
+      }
+    };
+
+    // Get l1 to l2 messages from the contract
+    this.log.debug('Requesting L1 to L2 messages from contract');
+    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(newGlobalVariables.blockNumber.toBigInt());
+    this.log.verbose(
+      `Retrieved ${l1ToL2Messages.length} L1 to L2 messages for block ${newGlobalVariables.blockNumber.toNumber()}`,
+    );
+
+    // We create a fresh processor each time to reset any cached state (eg storage writes)
+    const processor = await this.publicProcessorFactory.create(historicalHeader, newGlobalVariables);
+
+    const numRealTxs = validTxs.length;
+    const pow2 = Math.log2(numRealTxs);
+    const totalTxs = 2 ** Math.ceil(pow2);
+    const blockSize = Math.max(2, totalTxs);
+
+    const blockBuildingTimer = new Timer();
+    const blockTicket = await this.prover.startNewBlock(blockSize, newGlobalVariables, l1ToL2Messages);
+
+    const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
+      processor.process(validTxs, blockSize, this.prover, this.txValidatorFactory.validatorForProcessedTxs()),
+    );
+    if (failedTxs.length > 0) {
+      const failedTxData = failedTxs.map(fail => fail.tx);
+      this.log.debug(`Dropping failed txs ${Tx.getHashes(failedTxData).join(', ')}`);
+      await this.p2pClient.deleteTxs(Tx.getHashes(failedTxData));
+    }
+
+    if (processedTxs.length === 0) {
+      this.log.verbose('No txs processed correctly to build block. Exiting');
+      this.prover.cancelBlock();
+      return;
+    }
+
+    await assertBlockHeight();
+
+    // All real transactions have been added, set the block as full and complete the proving.
+    await this.prover.setBlockCompleted();
+
+    // Here we are now waiting for the block to be proven.
+    // TODO(@PhilWindle) We should probably periodically check for things like another
+    // block being published before ours instead of just waiting on our block
+    const result = await blockTicket.provingPromise;
+    if (result.status === PROVING_STATUS.FAILURE) {
+      throw new Error(`Block proving failed, reason: ${result.reason}`);
+    }
+
+    await assertBlockHeight();
+
+    // Block is proven, now finalise and publish!
+    const { block, aggregationObject, proof } = await this.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);
+
+    await this.publishL2Block(block, aggregationObject, proof);
+    this.log.info(`Submitted rollup block ${block.number} with ${processedTxs.length} transactions`);
+  }
+
   /**
    * Publishes the L2Block to the rollup contract.
    * @param block - The L2Block to be published.
    */
+  @trackSpan('Sequencer.publishL2Block', block => ({
+    [Attributes.BLOCK_NUMBER]: block.number,
+  }))
   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;
@@ -321,10 +346,10 @@ export class Sequencer {
 
     const toReturn: Tx[] = [];
     for (const tx of txs) {
-      const txSize = tx.getStats().size - tx.proof.toBuffer().length;
+      const txSize = tx.getSize() - tx.proof.toBuffer().length;
       if (totalSize + txSize > maxSize) {
         this.log.warn(
-          `Dropping tx ${tx.getTxHash()} with size ${txSize} due to exceeding ${maxSize} block size limit (currently at ${totalSize})`,
+          `Dropping tx ${tx.getTxHash()} with estimated size ${txSize} due to exceeding ${maxSize} block size limit (currently at ${totalSize})`,
         );
         continue;
       }

package/src/tx_validator/gas_validator.ts

@@ -1,8 +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, PublicKernelPhase, computeFeePayerBalanceStorageSlot } from '@aztec/simulator';
+import { AbstractPhaseManager, computeFeePayerBalanceStorageSlot } from '@aztec/simulator';
 
 /** Provides a view into public contract state */
 export interface PublicStateSource {
@@ -14,7 +14,7 @@ export class GasTxValidator implements TxValidator<Tx> {
   #publicDataSource: PublicStateSource;
   #gasTokenAddress: AztecAddress;
 
-  constructor(publicDataSource: PublicStateSource, gasTokenAddress: AztecAddress) {
+  constructor(publicDataSource: PublicStateSource, gasTokenAddress: AztecAddress, public enforceFees: boolean) {
     this.#publicDataSource = publicDataSource;
     this.#gasTokenAddress = gasTokenAddress;
   }
@@ -38,7 +38,11 @@ export class GasTxValidator implements TxValidator<Tx> {
     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()) {
-      return true;
+      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
@@ -51,7 +55,7 @@ export class GasTxValidator implements TxValidator<Tx> {
     );
 
     // If there is a claim in this tx that increases the fee payer balance in gas token, add it to balance
-    const { [PublicKernelPhase.SETUP]: setupFns } = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx);
+    const { [PublicKernelType.SETUP]: setupFns } = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx);
     const claimFunctionCall = setupFns.find(
       fn =>
         fn.contractAddress.equals(this.#gasTokenAddress) &&

package/src/tx_validator/phases_validator.ts

@@ -1,14 +1,14 @@
-import { type AllowedFunction, Tx, type TxValidator } from '@aztec/circuit-types';
+import { type AllowedElement, PublicKernelType, Tx, type TxValidator } from '@aztec/circuit-types';
 import { type PublicCallRequest } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { AbstractPhaseManager, ContractsDataSourcePublicDB, PublicKernelPhase } from '@aztec/simulator';
+import { AbstractPhaseManager, ContractsDataSourcePublicDB } from '@aztec/simulator';
 import { type ContractDataSource } from '@aztec/types/contracts';
 
 export class PhasesTxValidator implements TxValidator<Tx> {
   #log = createDebugLogger('aztec:sequencer:tx_validator:tx_phases');
   private contractDataSource: ContractsDataSourcePublicDB;
 
-  constructor(contracts: ContractDataSource, private setupAllowList: AllowedFunction[]) {
+  constructor(contracts: ContractDataSource, private setupAllowList: AllowedElement[]) {
     this.contractDataSource = new ContractsDataSourcePublicDB(contracts);
   }
 
@@ -40,7 +40,7 @@ export class PhasesTxValidator implements TxValidator<Tx> {
       return true;
     }
 
-    const { [PublicKernelPhase.SETUP]: setupFns } = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx);
+    const { [PublicKernelType.SETUP]: setupFns } = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx);
 
     for (const setupFn of setupFns) {
       if (!(await this.isOnAllowList(setupFn, this.setupAllowList))) {
@@ -57,7 +57,7 @@ export class PhasesTxValidator implements TxValidator<Tx> {
     return true;
   }
 
-  async isOnAllowList(publicCall: PublicCallRequest, allowList: AllowedFunction[]): Promise<boolean> {
+  async isOnAllowList(publicCall: PublicCallRequest, allowList: AllowedElement[]): Promise<boolean> {
     if (publicCall.isEmpty()) {
       return true;
     }
@@ -66,27 +66,37 @@ export class PhasesTxValidator implements TxValidator<Tx> {
 
     // do these checks first since they don't require the contract class
     for (const entry of allowList) {
-      if (!('address' in entry)) {
-        continue;
+      if ('address' in entry && !('selector' in entry)) {
+        if (contractAddress.equals(entry.address)) {
+          return true;
+        }
       }
 
-      if (contractAddress.equals(entry.address) && entry.selector.equals(functionSelector)) {
-        return true;
+      if ('address' in entry && 'selector' in entry) {
+        if (contractAddress.equals(entry.address) && entry.selector.equals(functionSelector)) {
+          return true;
+        }
       }
-    }
 
-    const contractClass = await this.contractDataSource.getContractInstance(contractAddress);
-    if (!contractClass) {
-      throw new Error(`Contract not found: ${publicCall.contractAddress.toString()}`);
-    }
+      const contractClass = await this.contractDataSource.getContractInstance(contractAddress);
 
-    for (const entry of allowList) {
-      if (!('classId' in entry)) {
-        continue;
+      if (!contractClass) {
+        throw new Error(`Contract not found: ${publicCall.contractAddress.toString()}`);
+      }
+
+      if ('classId' in entry && !('selector' in entry)) {
+        if (contractClass.contractClassId.equals(entry.classId)) {
+          return true;
+        }
       }
 
-      if (contractClass.contractClassId.equals(entry.classId) && entry.selector.equals(functionSelector)) {
-        return true;
+      if ('classId' in entry && 'selector' in entry) {
+        if (
+          contractClass.contractClassId.equals(entry.classId) &&
+          (entry.selector === undefined || entry.selector.equals(functionSelector))
+        ) {
+          return true;
+        }
       }
     }
 

package/src/tx_validator/tx_validator_factory.ts

@@ -1,4 +1,4 @@
-import { type AllowedFunction, type ProcessedTx, type Tx, type TxValidator } from '@aztec/circuit-types';
+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 { WorldStateDB, WorldStatePublicDB } from '@aztec/simulator';
@@ -12,14 +12,18 @@ import { MetadataTxValidator } from './metadata_validator.js';
 import { PhasesTxValidator } from './phases_validator.js';
 
 export class TxValidatorFactory {
-  constructor(private merkleTreeDb: MerkleTreeOperations, private contractDataSource: ContractDataSource) {}
+  constructor(
+    private merkleTreeDb: MerkleTreeOperations,
+    private contractDataSource: ContractDataSource,
+    private enforceFees: boolean,
+  ) {}
 
-  validatorForNewTxs(globalVariables: GlobalVariables, setupAllowList: AllowedFunction[]): TxValidator<Tx> {
+  validatorForNewTxs(globalVariables: GlobalVariables, setupAllowList: AllowedElement[]): TxValidator<Tx> {
     return new AggregateTxValidator(
       new MetadataTxValidator(globalVariables),
       new DoubleSpendTxValidator(new WorldStateDB(this.merkleTreeDb)),
       new PhasesTxValidator(this.contractDataSource, setupAllowList),
-      new GasTxValidator(new WorldStatePublicDB(this.merkleTreeDb), GasTokenAddress),
+      new GasTxValidator(new WorldStatePublicDB(this.merkleTreeDb), GasTokenAddress, this.enforceFees),
     );
   }