@aztec/sequencer-client 0.47.1 → 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
@@ -53,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,
@@ -71,10 +71,14 @@ 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.
@@ -170,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
@@ -231,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,
@@ -260,8 +267,6 @@ 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();
     }
   }
@@ -280,6 +285,7 @@ export class Sequencer {
     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`);
@@ -287,12 +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())) {
         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
@@ -309,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);
@@ -326,14 +336,14 @@ export class Sequencer {
     // 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
@@ -346,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.
@@ -377,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/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,18 +50,18 @@ 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.contractAddress.equals(this.#feeJuiceAddress) &&
+        fn.callContext.msgSender.equals(this.#feeJuiceAddress) &&
         fn.callContext.functionSelector.equals(
-          GasTokenArtifact.functions.find(f => f.name === '_increase_public_balance')!,
+          FeeJuiceArtifact.functions.find(f => f.name === '_increase_public_balance')!,
         ) &&
         fn.args[0].equals(feePayer) &&
         !fn.callContext.isStaticCall &&

package/src/tx_validator/tx_validator_factory.ts

@@ -1,6 +1,6 @@
 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';
@@ -25,7 +25,7 @@ export class TxValidatorFactory {
       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;
-}