@aztec/sequencer-client 3.0.0-canary.a9708bd → 3.0.0-devnet.20251212

package/src/sequencer/block_builder.ts

@@ -1,24 +1,25 @@
-import { MerkleTreeId, elapsed } from '@aztec/aztec.js';
-import { pick } from '@aztec/foundation/collection';
-import type { Fr } from '@aztec/foundation/fields';
+import { MerkleTreeId } from '@aztec/aztec.js/trees';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { merge, pick } from '@aztec/foundation/collection';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import { bufferToHex } from '@aztec/foundation/string';
-import { DateProvider, Timer } from '@aztec/foundation/timer';
+import { DateProvider, Timer, elapsed } from '@aztec/foundation/timer';
 import { getDefaultAllowedSetupFunctions } from '@aztec/p2p/msg_validators';
 import { LightweightBlockFactory } from '@aztec/prover-client/block-factory';
 import {
   GuardedMerkleTreeOperations,
   PublicContractsDB,
   PublicProcessor,
-  TelemetryPublicTxSimulator,
+  createPublicTxSimulatorForBlockBuilding,
 } from '@aztec/simulator/server';
-import type { ChainConfig, SequencerConfig } from '@aztec/stdlib/config';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import { type L1RollupConstants, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import { Gas } from '@aztec/stdlib/gas';
 import type {
   BuildBlockResult,
+  FullNodeBlockBuilderConfig,
   IFullNodeBlockBuilder,
   MerkleTreeWriteOperations,
   PublicProcessorLimits,
@@ -46,7 +47,7 @@ export async function buildBlock(
 ): Promise<BuildBlockResult> {
   const blockBuildingTimer = new Timer();
   const blockNumber = newGlobalVariables.blockNumber;
-  const slot = newGlobalVariables.slotNumber.toBigInt();
+  const slot = newGlobalVariables.slotNumber;
   const msgCount = l1ToL2Messages.length;
   const stateReference = await worldStateFork.getStateReference();
   const archiveTree = await worldStateFork.getTreeInfo(MerkleTreeId.ARCHIVE);
@@ -89,9 +90,14 @@ export async function buildBlock(
   return res;
 }
 
-type FullNodeBlockBuilderConfig = Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'> &
-  Pick<ChainConfig, 'l1ChainId' | 'rollupVersion'> &
-  Pick<SequencerConfig, 'txPublicSetupAllowList' | 'fakeProcessingDelayPerTxMs'>;
+const FullNodeBlockBuilderConfigKeys = [
+  'l1GenesisTime',
+  'slotDuration',
+  'l1ChainId',
+  'rollupVersion',
+  'txPublicSetupAllowList',
+  'fakeProcessingDelayPerTxMs',
+] as const;
 
 export class FullNodeBlockBuilder implements IFullNodeBlockBuilder {
   constructor(
@@ -103,19 +109,11 @@ export class FullNodeBlockBuilder implements IFullNodeBlockBuilder {
   ) {}
 
   public getConfig(): FullNodeBlockBuilderConfig {
-    return pick(
-      this.config,
-      'l1GenesisTime',
-      'slotDuration',
-      'l1ChainId',
-      'rollupVersion',
-      'txPublicSetupAllowList',
-      'fakeProcessingDelayPerTxMs',
-    );
+    return pick(this.config, ...FullNodeBlockBuilderConfigKeys);
   }
 
-  public updateConfig(config: FullNodeBlockBuilderConfig) {
-    this.config = config;
+  public updateConfig(config: Partial<FullNodeBlockBuilderConfig>) {
+    this.config = merge(this.config, pick(config, ...FullNodeBlockBuilderConfigKeys));
   }
 
   public async makeBlockBuilderDeps(globalVariables: GlobalVariables, fork: MerkleTreeWriteOperations) {
@@ -123,13 +121,10 @@ export class FullNodeBlockBuilder implements IFullNodeBlockBuilder {
     const contractsDB = new PublicContractsDB(this.contractDataSource);
     const guardedFork = new GuardedMerkleTreeOperations(fork);
 
-    const publicTxSimulator = new TelemetryPublicTxSimulator(
+    const publicTxSimulator = createPublicTxSimulatorForBlockBuilding(
       guardedFork,
       contractsDB,
       globalVariables,
-      /*doMerkleOperations=*/ true,
-      /*skipFeeEnforcement=*/ true,
-      /*clientInitiatedSimulation=*/ false,
       this.telemetryClient,
     );
 
@@ -157,7 +152,7 @@ export class FullNodeBlockBuilder implements IFullNodeBlockBuilder {
     };
   }
 
-  private async syncToPreviousBlock(parentBlockNumber: number, timeout: number | undefined) {
+  private async syncToPreviousBlock(parentBlockNumber: BlockNumber, timeout: number | undefined) {
     await retryUntil(
       () => this.worldState.syncImmediate(parentBlockNumber, true).then(syncedTo => syncedTo >= parentBlockNumber),
       'sync to previous block',
@@ -174,7 +169,7 @@ export class FullNodeBlockBuilder implements IFullNodeBlockBuilder {
     opts: PublicProcessorLimits,
     suppliedFork?: MerkleTreeWriteOperations,
   ): Promise<BuildBlockResult> {
-    const parentBlockNumber = globalVariables.blockNumber - 1;
+    const parentBlockNumber = BlockNumber(globalVariables.blockNumber - 1);
     const syncTimeout = opts.deadline ? (opts.deadline.getTime() - this.dateProvider.now()) / 1000 : undefined;
     await this.syncToPreviousBlock(parentBlockNumber, syncTimeout);
     const fork = suppliedFork ?? (await this.worldState.fork(parentBlockNumber));
@@ -213,7 +208,7 @@ export class FullNodeBlockBuilder implements IFullNodeBlockBuilder {
     }
   }
 
-  getFork(blockNumber: number): Promise<MerkleTreeWriteOperations> {
+  getFork(blockNumber: BlockNumber): Promise<MerkleTreeWriteOperations> {
     return this.worldState.fork(blockNumber);
   }
 }

package/src/sequencer/config.ts

@@ -1,4 +1,4 @@
-import type { GovernanceProposerContract, RollupContract } from '@aztec/ethereum';
+import type { GovernanceProposerContract, RollupContract } from '@aztec/ethereum/contracts';
 
 export { type SequencerConfig } from '@aztec/stdlib/config';
 

package/src/sequencer/errors.ts

@@ -0,0 +1,21 @@
+import type { SequencerState } from './utils.js';
+
+export class SequencerTooSlowError extends Error {
+  constructor(
+    public readonly proposedState: SequencerState,
+    public readonly maxAllowedTime: number,
+    public readonly currentTime: number,
+  ) {
+    super(
+      `Too far into slot for ${proposedState} (time into slot ${currentTime}s greater than ${maxAllowedTime}s allowance)`,
+    );
+    this.name = 'SequencerTooSlowError';
+  }
+}
+
+export class SequencerInterruptedError extends Error {
+  constructor() {
+    super(`Sequencer was interrupted`);
+    this.name = 'SequencerInterruptedError';
+  }
+}

package/src/sequencer/metrics.ts

@@ -1,22 +1,21 @@
-import type { EthAddress } from '@aztec/aztec.js';
-import type { RollupContract } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import type { RollupContract } from '@aztec/ethereum/contracts';
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import {
   Attributes,
-  type BatchObservableResult,
   type Gauge,
   type Histogram,
   type Meter,
   Metrics,
-  type ObservableGauge,
   type TelemetryClient,
   type Tracer,
   type UpDownCounter,
   ValueType,
 } from '@aztec/telemetry-client';
 
-import { formatUnits } from 'viem';
+import { type Hex, formatUnits } from 'viem';
 
-import { type SequencerState, type SequencerStateCallback, sequencerStateToNumber } from './utils.js';
+import type { SequencerState } from './utils.js';
 
 export class SequencerMetrics {
   public readonly tracer: Tracer;
@@ -26,9 +25,6 @@ export class SequencerMetrics {
   private blockBuildDuration: Histogram;
   private blockBuildManaPerSecond: Gauge;
   private stateTransitionBufferDuration: Histogram;
-  private currentBlockNumber: Gauge;
-  private currentBlockSize: Gauge;
-  private blockBuilderInsertions: Histogram;
 
   // these are gauges because for individual sequencers building a block is not something that happens often enough to warrant a histogram
   private timeToCollectAttestations: Gauge;
@@ -36,18 +32,20 @@ export class SequencerMetrics {
   private requiredAttestions: Gauge;
   private collectedAttestions: Gauge;
 
-  private rewards: ObservableGauge;
+  private rewards: Gauge;
 
   private slots: UpDownCounter;
   private filledSlots: UpDownCounter;
-  private missedSlots: UpDownCounter;
 
-  private lastSeenSlot?: bigint;
+  private blockProposalFailed: UpDownCounter;
+  private blockProposalSuccess: UpDownCounter;
+  private blockProposalPrecheckFailed: UpDownCounter;
+  private slashingAttempts: UpDownCounter;
+
+  private lastSeenSlot?: SlotNumber;
 
   constructor(
     client: TelemetryClient,
-    getState: SequencerStateCallback,
-    private coinbase: EthAddress,
     private rollup: RollupContract,
     name = 'Sequencer',
   ) {
@@ -78,35 +76,7 @@ export class SequencerMetrics {
       },
     );
 
-    const currentState = this.meter.createObservableGauge(Metrics.SEQUENCER_CURRENT_STATE, {
-      description: 'Current state of the sequencer',
-    });
-
-    currentState.addCallback(observer => {
-      observer.observe(sequencerStateToNumber(getState()));
-    });
-
-    this.currentBlockNumber = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_NUMBER, {
-      description: 'Current block number',
-      valueType: ValueType.INT,
-    });
-
-    this.currentBlockSize = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_SIZE, {
-      description: 'Current block size',
-      valueType: ValueType.INT,
-    });
-
-    this.blockBuilderInsertions = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_INSERTION_TIME, {
-      description: 'Timer for tree insertions performed by the block builder',
-      unit: 'us',
-      valueType: ValueType.INT,
-    });
-
     // Init gauges and counters
-    this.setCurrentBlock(0, 0);
-    this.blockCounter.add(0, {
-      [Attributes.STATUS]: 'cancelled',
-    });
     this.blockCounter.add(0, {
       [Attributes.STATUS]: 'failed',
     });
@@ -114,7 +84,7 @@ export class SequencerMetrics {
       [Attributes.STATUS]: 'built',
     });
 
-    this.rewards = this.meter.createObservableGauge(Metrics.SEQUENCER_CURRENT_BLOCK_REWARDS, {
+    this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_REWARDS, {
       valueType: ValueType.DOUBLE,
       description: 'The rewards earned',
     });
@@ -124,16 +94,15 @@ export class SequencerMetrics {
       description: 'The number of slots this sequencer was selected for',
     });
 
+    /**
+     * NOTE: we do not track missed slots as a separate metric. That would be difficult to determine
+     * Instead, use a computed metric, `slots - filledSlots` to get the number of slots a sequencer has missed.
+     */
     this.filledSlots = this.meter.createUpDownCounter(Metrics.SEQUENCER_FILLED_SLOT_COUNT, {
       valueType: ValueType.INT,
       description: 'The number of slots this sequencer has filled',
     });
 
-    this.missedSlots = this.meter.createUpDownCounter(Metrics.SEQUENCER_MISSED_SLOT_COUNT, {
-      valueType: ValueType.INT,
-      description: 'The number of slots this sequencer has missed to fill',
-    });
-
     this.timeToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_DURATION, {
       description: 'The time spent collecting attestations from committee members',
       unit: 'ms',
@@ -158,29 +127,30 @@ export class SequencerMetrics {
       valueType: ValueType.INT,
       description: 'The minimum number of attestations required to publish a block',
     });
-  }
-
-  public setCoinbase(coinbase: EthAddress) {
-    this.coinbase = coinbase;
-  }
 
-  public start() {
-    this.meter.addBatchObservableCallback(this.observe, [this.rewards]);
-  }
+    this.blockProposalFailed = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_FAILED_COUNT, {
+      valueType: ValueType.INT,
+      description: 'The number of times block proposal failed (including validation builds)',
+    });
 
-  public stop() {
-    this.meter.removeBatchObservableCallback(this.observe, [this.rewards]);
-  }
+    this.blockProposalSuccess = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_SUCCESS_COUNT, {
+      valueType: ValueType.INT,
+      description: 'The number of times block proposal succeeded (including validation builds)',
+    });
 
-  private observe = async (observer: BatchObservableResult): Promise<void> => {
-    let rewards = 0n;
-    rewards = await this.rollup.getSequencerRewards(this.coinbase);
+    this.blockProposalPrecheckFailed = this.meter.createUpDownCounter(
+      Metrics.SEQUENCER_BLOCK_PROPOSAL_PRECHECK_FAILED_COUNT,
+      {
+        valueType: ValueType.INT,
+        description: 'The number of times block proposal pre-build checks failed',
+      },
+    );
 
-    const fmt = parseFloat(formatUnits(rewards, 18));
-    observer.observe(this.rewards, fmt, {
-      [Attributes.COINBASE]: this.coinbase.toString(),
+    this.slashingAttempts = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT, {
+      valueType: ValueType.INT,
+      description: 'The number of slashing action attempts',
     });
-  };
+  }
 
   public recordRequiredAttestations(requiredAttestationsCount: number, allowanceMs: number) {
     this.requiredAttestions.record(requiredAttestationsCount);
@@ -196,17 +166,6 @@ export class SequencerMetrics {
     this.timeToCollectAttestations.record(Math.ceil(durationMs));
   }
 
-  recordBlockBuilderTreeInsertions(timeUs: number) {
-    this.blockBuilderInsertions.record(Math.ceil(timeUs));
-  }
-
-  recordCancelledBlock() {
-    this.blockCounter.add(1, {
-      [Attributes.STATUS]: 'cancelled',
-    });
-    this.setCurrentBlock(0, 0);
-  }
-
   recordBuiltBlock(buildDurationMs: number, totalMana: number) {
     this.blockCounter.add(1, {
       [Attributes.STATUS]: 'built',
@@ -219,11 +178,6 @@ export class SequencerMetrics {
     this.blockCounter.add(1, {
       [Attributes.STATUS]: 'failed',
     });
-    this.setCurrentBlock(0, 0);
-  }
-
-  recordNewBlock(blockNumber: number, txCount: number) {
-    this.setCurrentBlock(blockNumber, txCount);
   }
 
   recordStateTransitionBufferMs(durationMs: number, state: SequencerState) {
@@ -232,36 +186,55 @@ export class SequencerMetrics {
     });
   }
 
-  observeSlotChange(slot: bigint | undefined, proposer: string) {
+  incOpenSlot(slot: SlotNumber, proposer: string) {
     // sequencer went through the loop a second time. Noop
     if (slot === this.lastSeenSlot) {
       return;
     }
 
-    if (typeof this.lastSeenSlot === 'bigint') {
-      this.missedSlots.add(1, {
-        [Attributes.BLOCK_PROPOSER]: proposer,
-      });
-    }
-
-    if (typeof slot === 'bigint') {
-      this.slots.add(1, {
-        [Attributes.BLOCK_PROPOSER]: proposer,
-      });
-    }
+    this.slots.add(1, {
+      [Attributes.BLOCK_PROPOSER]: proposer,
+    });
 
     this.lastSeenSlot = slot;
   }
 
-  incFilledSlot(proposer: string) {
+  async incFilledSlot(proposer: string, coinbase: Hex | EthAddress | undefined): Promise<void> {
     this.filledSlots.add(1, {
       [Attributes.BLOCK_PROPOSER]: proposer,
     });
     this.lastSeenSlot = undefined;
+
+    if (coinbase) {
+      try {
+        const rewards = await this.rollup.getSequencerRewards(coinbase);
+        const fmt = parseFloat(formatUnits(rewards, 18));
+        this.rewards.record(fmt, {
+          [Attributes.COINBASE]: coinbase.toString(),
+        });
+      } catch {
+        // no-op
+      }
+    }
+  }
+
+  recordBlockProposalFailed(reason?: string) {
+    this.blockProposalFailed.add(1, {
+      ...(reason && { [Attributes.ERROR_TYPE]: reason }),
+    });
+  }
+
+  recordBlockProposalSuccess() {
+    this.blockProposalSuccess.add(1);
+  }
+
+  recordBlockProposalPrecheckFailed(checkType: string) {
+    this.blockProposalPrecheckFailed.add(1, {
+      [Attributes.ERROR_TYPE]: checkType,
+    });
   }
 
-  private setCurrentBlock(blockNumber: number, txCount: number) {
-    this.currentBlockNumber.record(blockNumber);
-    this.currentBlockSize.record(txCount);
+  recordSlashingAttempt(actionCount: number) {
+    this.slashingAttempts.add(actionCount);
   }
 }