@aztec/sequencer-client 0.47.0 → 0.48.0

package/src/publisher/l1-publisher-metrics.ts

@@ -0,0 +1,108 @@
+import type { L1PublishBlockStats, L1PublishProofStats } from '@aztec/circuit-types/stats';
+import {
+  Attributes,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+import { formatEther } from 'viem/utils';
+
+export type L1TxType = 'submitProof' | 'process';
+
+export class L1PublisherMetrics {
+  private gasPrice: Histogram;
+
+  private txCount: UpDownCounter;
+  private txDuration: Histogram;
+  private txGas: Histogram;
+  private txCalldataSize: Histogram;
+  private txCalldataGas: Histogram;
+
+  constructor(client: TelemetryClient, name = 'L1Publisher') {
+    const meter = client.getMeter(name);
+
+    this.gasPrice = meter.createHistogram(Metrics.L1_PUBLISHER_GAS_PRICE, {
+      description: 'The gas price used for transactions',
+      unit: 'gwei',
+      valueType: ValueType.DOUBLE,
+    });
+
+    this.txCount = meter.createUpDownCounter(Metrics.L1_PUBLISHER_TX_COUNT, {
+      description: 'The number of transactions processed',
+    });
+
+    this.txDuration = meter.createHistogram(Metrics.L1_PUBLISHER_TX_DURATION, {
+      description: 'The duration of transaction processing',
+      unit: 'ms',
+      valueType: ValueType.INT,
+      advice: {
+        explicitBucketBoundaries: [10, 50, 100, 200, 500, 1000, 2000, 5000, 10000],
+      },
+    });
+
+    this.txGas = meter.createHistogram(Metrics.L1_PUBLISHER_TX_GAS, {
+      description: 'The gas consumed by transactions',
+      unit: 'gas',
+      valueType: ValueType.INT,
+    });
+
+    this.txCalldataSize = meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_SIZE, {
+      description: 'The size of the calldata in transactions',
+      unit: 'bytes',
+      valueType: ValueType.INT,
+      advice: {
+        explicitBucketBoundaries: [0, 100, 200, 500, 1000, 2000, 5000, 10000],
+      },
+    });
+
+    this.txCalldataGas = meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_GAS, {
+      description: 'The gas consumed by the calldata in transactions',
+      unit: 'gas',
+      valueType: ValueType.INT,
+    });
+  }
+
+  recordFailedTx(txType: L1TxType) {
+    this.txCount.add(1, {
+      [Attributes.L1_TX_TYPE]: txType,
+      [Attributes.OK]: false,
+    });
+  }
+
+  recordSubmitProof(durationMs: number, stats: L1PublishProofStats) {
+    this.recordTx('submitProof', durationMs, stats);
+  }
+
+  recordProcessBlockTx(durationMs: number, stats: L1PublishBlockStats) {
+    this.recordTx('process', durationMs, stats);
+  }
+
+  private recordTx(txType: L1TxType, durationMs: number, stats: Omit<L1PublishProofStats, 'eventName'>) {
+    const attributes = {
+      [Attributes.L1_TX_TYPE]: txType,
+    } as const;
+
+    this.txCount.add(1, {
+      ...attributes,
+      [Attributes.OK]: true,
+    });
+
+    this.txDuration.record(Math.ceil(durationMs), attributes);
+    this.txGas.record(
+      // safe to downcast - total block limit is 30M gas which fits in a JS number
+      Number(stats.gasUsed),
+      attributes,
+    );
+    this.txCalldataGas.record(stats.calldataGas, attributes);
+    this.txCalldataSize.record(stats.calldataSize, attributes);
+
+    try {
+      this.gasPrice.record(parseInt(formatEther(stats.gasPrice, 'gwei'), 10));
+    } catch (e) {
+      // ignore
+    }
+  }
+}

package/src/publisher/l1-publisher.ts

@@ -5,11 +5,14 @@ import { type Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { serializeToBuffer } from '@aztec/foundation/serialize';
 import { InterruptibleSleep } from '@aztec/foundation/sleep';
+import { Timer } from '@aztec/foundation/timer';
+import { type TelemetryClient } from '@aztec/telemetry-client';
 
 import pick from 'lodash.pick';
 
 import { type L2BlockReceiver } from '../receiver.js';
 import { type PublisherConfig } from './config.js';
+import { L1PublisherMetrics } from './l1-publisher-metrics.js';
 
 /**
  * Stats for a sent transaction.
@@ -39,15 +42,25 @@ export type MinimalTransactionReceipt = {
   logs: any[];
 };
 
+/**
+ * @notice An attestation for the sequencing model.
+ * @todo    This is not where it belongs. But I think we should do a bigger rewrite of some of
+ *          this spaghetti.
+ */
+export type Attestation = { isEmpty: boolean; v: number; r: `0x${string}`; s: `0x${string}` };
+
 /**
  * Pushes txs to the L1 chain and waits for their completion.
  */
 export interface L1PublisherTxSender {
+  /** Attests to the given archive root. */
+  attest(archive: `0x${string}`): Promise<Attestation>;
+
   /** Returns the EOA used for sending txs to L1.  */
   getSenderAddress(): Promise<EthAddress>;
 
-  /** Returns the address elected for submitting a given block number or zero if anyone can submit. */
-  getSubmitterAddressForBlock(blockNumber: number): Promise<EthAddress>;
+  /** Returns the address of the L2 proposer at the NEXT Ethereum block zero if anyone can submit. */
+  getProposerAtNextEthBlock(): Promise<EthAddress>;
 
   /**
    * Publishes tx effects to Availability Oracle.
@@ -63,6 +76,13 @@ export interface L1PublisherTxSender {
    */
   sendProcessTx(encodedData: L1ProcessArgs): Promise<string | undefined>;
 
+  /**
+   * Publishes tx effects to availability oracle and send L2 block to rollup contract
+   * @param encodedData - Data for processing the new L2 block.
+   * @returns The hash of the tx.
+   */
+  sendPublishAndProcessTx(encodedData: L1ProcessArgs): Promise<string | undefined>;
+
   /**
    * Sends a tx to the L1 rollup contract with a proof. Returns once the tx has been mined.
    * @param encodedData - Serialized data for processing the new L2 block.
@@ -105,6 +125,8 @@ export type L1ProcessArgs = {
   archive: Buffer;
   /** L2 block body. */
   body: Buffer;
+  /** Attestations */
+  attestations?: Attestation[];
 };
 
 /** Arguments to the submitProof method of the rollup contract */
@@ -113,6 +135,8 @@ export type L1SubmitProofArgs = {
   header: Buffer;
   /** A root of the archive tree after the L2 block is applied. */
   archive: Buffer;
+  /** Identifier of the prover. */
+  proverId: Buffer;
   /** The proof for the block. */
   proof: Buffer;
   /** The aggregation object for the block's proof. */
@@ -131,14 +155,24 @@ export class L1Publisher implements L2BlockReceiver {
   private interruptibleSleep = new InterruptibleSleep();
   private sleepTimeMs: number;
   private interrupted = false;
+  private metrics: L1PublisherMetrics;
   private log = createDebugLogger('aztec:sequencer:publisher');
 
-  constructor(private txSender: L1PublisherTxSender, config?: PublisherConfig) {
+  constructor(private txSender: L1PublisherTxSender, client: TelemetryClient, config?: PublisherConfig) {
     this.sleepTimeMs = config?.l1PublishRetryIntervalMS ?? 60_000;
+    this.metrics = new L1PublisherMetrics(client, 'L1Publisher');
+  }
+
+  public async attest(archive: `0x${string}`): Promise<Attestation> {
+    return await this.txSender.attest(archive);
   }
 
-  public async isItMyTurnToSubmit(blockNumber: number): Promise<boolean> {
-    const submitter = await this.txSender.getSubmitterAddressForBlock(blockNumber);
+  public async senderAddress(): Promise<EthAddress> {
+    return await this.txSender.getSenderAddress();
+  }
+
+  public async isItMyTurnToSubmit(): Promise<boolean> {
+    const submitter = await this.txSender.getProposerAtNextEthBlock();
     const sender = await this.txSender.getSenderAddress();
     return submitter.isZero() || submitter.equals(sender);
   }
@@ -148,7 +182,7 @@ export class L1Publisher implements L2BlockReceiver {
    * @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, attestations?: Attestation[]): Promise<boolean> {
     const ctx = { blockNumber: block.number, blockHash: block.hash().toString() };
     // 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();
@@ -156,58 +190,35 @@ export class L1Publisher implements L2BlockReceiver {
       this.log.info(`Detected different last archive prior to publishing a block, aborting publish...`, ctx);
       return false;
     }
-
     const encodedBody = block.body.toBuffer();
 
-    // Publish block transaction effects
-    while (!this.interrupted) {
-      if (await this.txSender.checkIfTxsAreAvailable(block)) {
-        this.log.verbose(`Transaction effects of block ${block.number} already published.`, ctx);
-        break;
-      }
-
-      const txHash = await this.sendPublishTx(encodedBody);
-      if (!txHash) {
-        return false;
-      }
-
-      const receipt = await this.getTransactionReceipt(txHash);
-      if (!receipt) {
-        return false;
-      }
-
-      if (receipt.status) {
-        let txsEffectsHash;
-        if (receipt.logs.length === 1) {
-          // txsEffectsHash from IAvailabilityOracle.TxsPublished event
-          txsEffectsHash = receipt.logs[0].data;
-        } else {
-          this.log.warn(`Expected 1 log, got ${receipt.logs.length}`, ctx);
-        }
-
-        this.log.info(`Block txs effects published`, { ...ctx, txsEffectsHash });
-        break;
-      }
-
-      this.log.error(`AvailabilityOracle.publish tx status failed: ${receipt.transactionHash}`, ctx);
-      await this.sleepOrInterrupted();
-    }
-
     const processTxArgs = {
       header: block.header.toBuffer(),
       archive: block.archive.root.toBuffer(),
       body: encodedBody,
+      attestations,
     };
 
-    // Process block
+    // Process block and publish the body if needed (if not already published)
     while (!this.interrupted) {
-      const txHash = await this.sendProcessTx(processTxArgs);
+      let txHash;
+      const timer = new Timer();
+
+      if (await this.txSender.checkIfTxsAreAvailable(block)) {
+        this.log.verbose(`Transaction effects of block ${block.number} already published.`, ctx);
+        txHash = await this.sendProcessTx(processTxArgs);
+      } else {
+        txHash = await this.sendPublishAndProcessTx(processTxArgs);
+      }
+
       if (!txHash) {
+        this.log.info(`Failed to publish block ${block.number} to L1`, ctx);
         break;
       }
 
       const receipt = await this.getTransactionReceipt(txHash);
       if (!receipt) {
+        this.log.info(`Failed to get receipt for tx ${txHash}`, ctx);
         break;
       }
 
@@ -221,9 +232,12 @@ export class L1Publisher implements L2BlockReceiver {
           eventName: 'rollup-published-to-l1',
         };
         this.log.info(`Published L2 block to L1 rollup contract`, { ...stats, ...ctx });
+        this.metrics.recordProcessBlockTx(timer.ms(), stats);
         return true;
       }
 
+      this.metrics.recordFailedTx('process');
+
       // Check if someone else incremented the block number
       if (!(await this.checkLastArchiveHash(lastArchive))) {
         this.log.warn('Publish failed. Detected different last archive hash.', ctx);
@@ -238,18 +252,26 @@ export class L1Publisher implements L2BlockReceiver {
     return false;
   }
 
-  public async submitProof(header: Header, archiveRoot: Fr, aggregationObject: Fr[], proof: Proof): Promise<boolean> {
+  public async submitProof(
+    header: Header,
+    archiveRoot: Fr,
+    proverId: Fr,
+    aggregationObject: Fr[],
+    proof: Proof,
+  ): Promise<boolean> {
     const ctx = { blockNumber: header.globalVariables.blockNumber };
 
     const txArgs: L1SubmitProofArgs = {
       header: header.toBuffer(),
       archive: archiveRoot.toBuffer(),
+      proverId: proverId.toBuffer(),
       aggregationObject: serializeToBuffer(aggregationObject),
       proof: proof.withoutPublicInputs(),
     };
 
     // Process block
     while (!this.interrupted) {
+      const timer = new Timer();
       const txHash = await this.sendSubmitProofTx(txArgs);
       if (!txHash) {
         break;
@@ -269,9 +291,11 @@ export class L1Publisher implements L2BlockReceiver {
           eventName: 'proof-published-to-l1',
         };
         this.log.info(`Published L2 block to L1 rollup contract`, { ...stats, ...ctx });
+        this.metrics.recordSubmitProof(timer.ms(), stats);
         return true;
       }
 
+      this.metrics.recordFailedTx('submitProof');
       this.log.error(`Rollup.submitProof tx status failed: ${receipt.transactionHash}`, ctx);
       await this.sleepOrInterrupted();
     }
@@ -345,6 +369,17 @@ export class L1Publisher implements L2BlockReceiver {
     }
   }
 
+  private async sendPublishAndProcessTx(encodedData: L1ProcessArgs): Promise<string | undefined> {
+    while (!this.interrupted) {
+      try {
+        return await this.txSender.sendPublishAndProcessTx(encodedData);
+      } catch (err) {
+        this.log.error(`Rollup publish failed`, err);
+        return undefined;
+      }
+    }
+  }
+
   private async getTransactionReceipt(txHash: string): Promise<MinimalTransactionReceipt | undefined> {
     while (!this.interrupted) {
       try {

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

@@ -1,5 +1,5 @@
 import { type L2Block } from '@aztec/circuit-types';
-import { EthAddress } from '@aztec/circuits.js';
+import { ETHEREUM_SLOT_DURATION, EthAddress } from '@aztec/circuits.js';
 import { createEthereumChain } from '@aztec/ethereum';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { AvailabilityOracleAbi, RollupAbi } from '@aztec/l1-artifacts';
@@ -16,12 +16,14 @@ import {
   getContract,
   hexToBytes,
   http,
+  parseSignature,
 } from 'viem';
 import { type PrivateKeyAccount, privateKeyToAccount } from 'viem/accounts';
 import * as chains from 'viem/chains';
 
 import { type TxSenderConfig } from './config.js';
 import {
+  type Attestation,
   type L1PublisherTxSender,
   type L1SubmitProofArgs,
   type MinimalTransactionReceipt,
@@ -47,7 +49,7 @@ export class ViemTxSender implements L1PublisherTxSender {
   private account: PrivateKeyAccount;
 
   constructor(config: TxSenderConfig) {
-    const { rpcUrl, l1ChainId: chainId, publisherPrivateKey, l1Contracts } = config;
+    const { l1RpcUrl: rpcUrl, l1ChainId: chainId, publisherPrivateKey, l1Contracts } = config;
     const chain = createEthereumChain(rpcUrl, chainId);
     this.account = privateKeyToAccount(publisherPrivateKey);
     const walletClient = createWalletClient({
@@ -73,16 +75,34 @@ export class ViemTxSender implements L1PublisherTxSender {
     });
   }
 
+  async attest(archive: `0x{string}`): Promise<Attestation> {
+    // @note  Something seems slightly off in viem, think it should be Hex instead of Hash
+    //        but as they both are just `0x${string}` it should be fine anyways.
+    const signature = await this.account.signMessage({ message: { raw: archive } });
+    const { r, s, v } = parseSignature(signature as `0x${string}`);
+
+    return {
+      isEmpty: false,
+      v: v ? Number(v) : 0,
+      r: r,
+      s: s,
+    };
+  }
+
   getSenderAddress(): Promise<EthAddress> {
     return Promise.resolve(EthAddress.fromString(this.account.address));
   }
 
-  async getSubmitterAddressForBlock(blockNumber: number): Promise<EthAddress> {
+  // Computes who will be the L2 proposer at the next Ethereum block
+  // Using next Ethereum block so we do NOT need to wait for it being mined before seeing the effect
+  // @note Assumes that all ethereum slots have blocks
+  async getProposerAtNextEthBlock(): Promise<EthAddress> {
     try {
-      const submitter = await this.rollupContract.read.whoseTurnIsIt([BigInt(blockNumber)]);
+      const ts = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(ETHEREUM_SLOT_DURATION));
+      const submitter = await this.rollupContract.read.getProposerAt([ts]);
       return EthAddress.fromString(submitter);
     } catch (err) {
-      this.log.warn(`Failed to get submitter for block ${blockNumber}: ${err}`);
+      this.log.warn(`Failed to get submitter: ${err}`);
       return EthAddress.ZERO;
     }
   }
@@ -158,16 +178,70 @@ export class ViemTxSender implements L1PublisherTxSender {
    * @returns The hash of the mined tx.
    */
   async sendProcessTx(encodedData: ProcessTxArgs): Promise<string | undefined> {
-    const args = [`0x${encodedData.header.toString('hex')}`, `0x${encodedData.archive.toString('hex')}`] as const;
+    if (encodedData.attestations) {
+      const args = [
+        `0x${encodedData.header.toString('hex')}`,
+        `0x${encodedData.archive.toString('hex')}`,
+        encodedData.attestations,
+      ] as const;
 
-    const gas = await this.rollupContract.estimateGas.process(args, {
-      account: this.account,
-    });
-    const hash = await this.rollupContract.write.process(args, {
-      gas,
-      account: this.account,
-    });
-    return hash;
+      const gas = await this.rollupContract.estimateGas.process(args, {
+        account: this.account,
+      });
+      return await this.rollupContract.write.process(args, {
+        gas,
+        account: this.account,
+      });
+    } else {
+      const args = [`0x${encodedData.header.toString('hex')}`, `0x${encodedData.archive.toString('hex')}`] as const;
+
+      const gas = await this.rollupContract.estimateGas.process(args, {
+        account: this.account,
+      });
+      return await this.rollupContract.write.process(args, {
+        gas,
+        account: this.account,
+      });
+    }
+  }
+
+  /**
+   * @notice  Publishes the body AND process the block in one transaction
+   * @param encodedData - Serialized data for processing the new L2 block.
+   * @returns The hash of the transaction
+   */
+  async sendPublishAndProcessTx(encodedData: ProcessTxArgs): Promise<string | undefined> {
+    // @note  This is quite a sin, but I'm committing war crimes in this code already.
+    if (encodedData.attestations) {
+      const args = [
+        `0x${encodedData.header.toString('hex')}`,
+        `0x${encodedData.archive.toString('hex')}`,
+        encodedData.attestations,
+        `0x${encodedData.body.toString('hex')}`,
+      ] as const;
+
+      const gas = await this.rollupContract.estimateGas.publishAndProcess(args, {
+        account: this.account,
+      });
+      return await this.rollupContract.write.publishAndProcess(args, {
+        gas,
+        account: this.account,
+      });
+    } else {
+      const args = [
+        `0x${encodedData.header.toString('hex')}`,
+        `0x${encodedData.archive.toString('hex')}`,
+        `0x${encodedData.body.toString('hex')}`,
+      ] as const;
+
+      const gas = await this.rollupContract.estimateGas.publishAndProcess(args, {
+        account: this.account,
+      });
+      return await this.rollupContract.write.publishAndProcess(args, {
+        gas,
+        account: this.account,
+      });
+    }
   }
 
   /**
@@ -176,10 +250,11 @@ export class ViemTxSender implements L1PublisherTxSender {
    * @returns The hash of the mined tx.
    */
   async sendSubmitProofTx(submitProofArgs: L1SubmitProofArgs): Promise<string | undefined> {
-    const { header, archive, aggregationObject, proof } = submitProofArgs;
+    const { header, archive, proverId, aggregationObject, proof } = submitProofArgs;
     const args = [
       `0x${header.toString('hex')}`,
       `0x${archive.toString('hex')}`,
+      `0x${proverId.toString('hex')}`,
       `0x${aggregationObject.toString('hex')}`,
       `0x${proof.toString('hex')}`,
     ] as const;

package/src/receiver.ts

@@ -1,16 +1,11 @@
 import { type L2Block } from '@aztec/circuit-types';
-import type { Fr, Proof } from '@aztec/circuits.js';
+
+import { type Attestation } from './publisher/l1-publisher.js';
 
 /**
  * Given the necessary rollup data, verifies it, and updates the underlying state accordingly to advance the state of the system.
  * See https://hackmd.io/ouVCnacHQRq2o1oRc5ksNA#RollupReceiver.
  */
 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, aggregationObject: Fr[], proof: Proof): Promise<boolean>;
+  processL2Block(block: L2Block, attestations?: Attestation[]): Promise<boolean>;
 }

package/src/sequencer/metrics.ts

@@ -0,0 +1,86 @@
+import {
+  Attributes,
+  type Gauge,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type Tracer,
+  type UpDownCounter,
+  ValueType,
+  millisecondBuckets,
+} from '@aztec/telemetry-client';
+
+type SequencerStateCallback = () => number;
+
+export class SequencerMetrics {
+  public readonly tracer: Tracer;
+
+  private blockCounter: UpDownCounter;
+  private blockBuildDuration: Histogram;
+  private currentBlockNumber: Gauge;
+  private currentBlockSize: Gauge;
+
+  constructor(client: TelemetryClient, getState: SequencerStateCallback, name = 'Sequencer') {
+    const meter = client.getMeter(name);
+    this.tracer = client.getTracer(name);
+
+    this.blockCounter = meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_COUNT);
+    this.blockBuildDuration = meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION, {
+      unit: 'ms',
+      description: 'Duration to build a block',
+      valueType: ValueType.INT,
+      advice: {
+        explicitBucketBoundaries: millisecondBuckets(2),
+      },
+    });
+
+    const currentState = meter.createObservableGauge(Metrics.SEQUENCER_CURRENT_STATE, {
+      description: 'Current state of the sequencer',
+    });
+
+    currentState.addCallback(observer => {
+      observer.observe(getState());
+    });
+
+    this.currentBlockNumber = meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_NUMBER, {
+      description: 'Current block number',
+    });
+
+    this.currentBlockSize = meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_SIZE, {
+      description: 'Current block number',
+    });
+
+    this.setCurrentBlock(0, 0);
+  }
+
+  recordCancelledBlock() {
+    this.blockCounter.add(1, {
+      [Attributes.STATUS]: 'cancelled',
+    });
+    this.setCurrentBlock(0, 0);
+  }
+
+  recordPublishedBlock(buildDurationMs: number) {
+    this.blockCounter.add(1, {
+      [Attributes.STATUS]: 'published',
+    });
+    this.blockBuildDuration.record(Math.ceil(buildDurationMs));
+    this.setCurrentBlock(0, 0);
+  }
+
+  recordFailedBlock() {
+    this.blockCounter.add(1, {
+      [Attributes.STATUS]: 'failed',
+    });
+    this.setCurrentBlock(0, 0);
+  }
+
+  recordNewBlock(blockNumber: number, txCount: number) {
+    this.setCurrentBlock(blockNumber, txCount);
+  }
+
+  private setCurrentBlock(blockNumber: number, txCount: number) {
+    this.currentBlockNumber.record(blockNumber);
+    this.currentBlockSize.record(txCount);
+  }
+}