@aztec/sequencer-client 2.0.3-rc.16 → 2.0.3-rc.18

package/src/publisher/sequencer-publisher.ts

@@ -28,7 +28,7 @@ import { sumBigint } from '@aztec/foundation/bigint';
 import { toHex as toPaddedHex } from '@aztec/foundation/bigint-buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import { bufferToHex } from '@aztec/foundation/string';
 import { DateProvider, Timer } from '@aztec/foundation/timer';
 import { EmpireBaseAbi, ErrorsAbi, RollupAbi } from '@aztec/l1-artifacts';
@@ -62,11 +62,6 @@ type L1ProcessArgs = {
   attestations?: CommitteeAttestation[];
 };
 
-export enum SignalType {
-  GOVERNANCE,
-  SLASHING,
-}
-
 export const Actions = [
   'invalidate-by-invalid-attestation',
   'invalidate-by-insufficient-attestations',
@@ -78,8 +73,11 @@ export const Actions = [
   'vote-offenses',
   'execute-slash',
 ] as const;
+
 export type Action = (typeof Actions)[number];
 
+type GovernanceSignalAction = Extract<Action, 'governance-signal' | 'empire-slashing-signal'>;
+
 // Sorting for actions such that invalidations go before proposals, and proposals go before votes
 export const compareActions = (a: Action, b: Action) => Actions.indexOf(a) - Actions.indexOf(b);
 
@@ -104,6 +102,7 @@ interface RequestWithExpiry {
 }
 
 export class SequencerPublisher {
+  private enabled: boolean;
   private interrupted = false;
   private metrics: SequencerPublisherMetrics;
   public epochCache: EpochCache;
@@ -111,12 +110,9 @@ export class SequencerPublisher {
   protected governanceLog = createLogger('sequencer:publisher:governance');
   protected slashingLog = createLogger('sequencer:publisher:slashing');
 
-  private myLastSignals: Record<SignalType, bigint> = {
-    [SignalType.GOVERNANCE]: 0n,
-    [SignalType.SLASHING]: 0n,
-  };
+  protected lastActions: Partial<Record<Action, bigint>> = {};
 
-  protected log = createLogger('sequencer:publisher');
+  protected log: Logger;
   protected ethereumSlotDuration: bigint;
 
   private blobSinkClient: BlobSinkClientInterface;
@@ -152,10 +148,15 @@ export class SequencerPublisher {
       epochCache: EpochCache;
       dateProvider: DateProvider;
       metrics: SequencerPublisherMetrics;
+      lastActions: Partial<Record<Action, bigint>>;
+      log?: Logger;
     },
   ) {
+    this.enabled = config.publisherEnabled ?? true;
+    this.log = deps.log ?? createLogger('sequencer:publisher');
     this.ethereumSlotDuration = BigInt(config.ethereumSlotDuration);
     this.epochCache = deps.epochCache;
+    this.lastActions = deps.lastActions;
 
     this.blobSinkClient =
       deps.blobSinkClient ?? createBlobSinkClient(config, { logger: createLogger('sequencer:blob-sink:client') });
@@ -201,6 +202,14 @@ export class SequencerPublisher {
    * - undefined if no valid requests are found OR the tx failed to send.
    */
   public async sendRequests() {
+    if (!this.enabled) {
+      this.log.warn(`Sending L1 txs is disabled`, {
+        requestsDiscarded: this.requests.map(r => r.action),
+      });
+      this.requests = [];
+      return undefined;
+    }
+
     const requestsToProcess = [...this.requests];
     this.requests = [];
     if (this.interrupted) {
@@ -528,13 +537,14 @@ export class SequencerPublisher {
   private async enqueueCastSignalHelper(
     slotNumber: bigint,
     timestamp: bigint,
-    signalType: SignalType,
+    signalType: GovernanceSignalAction,
     payload: EthAddress,
     base: IEmpireBase,
     signerAddress: EthAddress,
     signer: (msg: TypedDataDefinition) => Promise<`0x${string}`>,
   ): Promise<boolean> {
-    if (this.myLastSignals[signalType] >= slotNumber) {
+    if (this.lastActions[signalType] && this.lastActions[signalType] === slotNumber) {
+      this.log.debug(`Skipping duplicate vote cast signal ${signalType} for slot ${slotNumber}`);
       return false;
     }
     if (payload.equals(EthAddress.ZERO)) {
@@ -551,10 +561,9 @@ export class SequencerPublisher {
       return false;
     }
 
-    const cachedLastVote = this.myLastSignals[signalType];
-    this.myLastSignals[signalType] = slotNumber;
-
-    const action = signalType === SignalType.GOVERNANCE ? 'governance-signal' : 'empire-slashing-signal';
+    const cachedLastVote = this.lastActions[signalType];
+    this.lastActions[signalType] = slotNumber;
+    const action = signalType;
 
     const request = await base.createSignalRequestWithSignature(
       payload.toString(),
@@ -597,7 +606,7 @@ export class SequencerPublisher {
             `Signaling in [${action}] for ${payload} at slot ${slotNumber} in round ${round} failed`,
             logData,
           );
-          this.myLastSignals[signalType] = cachedLastVote;
+          this.lastActions[signalType] = cachedLastVote;
           return false;
         } else {
           this.log.info(
@@ -627,7 +636,7 @@ export class SequencerPublisher {
     return this.enqueueCastSignalHelper(
       slotNumber,
       timestamp,
-      SignalType.GOVERNANCE,
+      'governance-signal',
       governancePayload,
       this.govProposerContract,
       signerAddress,
@@ -661,7 +670,7 @@ export class SequencerPublisher {
           await this.enqueueCastSignalHelper(
             slotNumber,
             timestamp,
-            SignalType.SLASHING,
+            'empire-slashing-signal',
             action.payload,
             this.slashingProposerContract,
             signerAddress,
@@ -842,16 +851,24 @@ export class SequencerPublisher {
   }
 
   private async simulateAndEnqueueRequest(
-    action: RequestWithExpiry['action'],
+    action: Action,
     request: L1TxRequest,
     checkSuccess: (receipt: TransactionReceipt) => boolean | undefined,
     slotNumber: bigint,
     timestamp: bigint,
   ) {
     const logData = { slotNumber, timestamp, gasLimit: undefined as bigint | undefined };
-    let gasUsed: bigint;
+    if (this.lastActions[action] && this.lastActions[action] === slotNumber) {
+      this.log.debug(`Skipping duplicate action ${action} for slot ${slotNumber}`);
+      return false;
+    }
 
-    this.log.debug(`Simulating ${action}`, logData);
+    const cachedLastActionSlot = this.lastActions[action];
+    this.lastActions[action] = slotNumber;
+
+    this.log.debug(`Simulating ${action} for slot ${slotNumber}`, logData);
+
+    let gasUsed: bigint;
     try {
       ({ gasUsed } = await this.l1TxUtils.simulate(request, { time: timestamp }, [], ErrorsAbi)); // TODO(palla/slash): Check the timestamp logic
       this.log.verbose(`Simulation for ${action} succeeded`, { ...logData, request, gasUsed });
@@ -875,6 +892,7 @@ export class SequencerPublisher {
         const success = result && result.receipt && result.receipt.status === 'success' && checkSuccess(result.receipt);
         if (!success) {
           this.log.warn(`Action ${action} at ${slotNumber} failed`, { ...result, ...logData });
+          this.lastActions[action] = cachedLastActionSlot;
         } else {
           this.log.info(`Action ${action} at ${slotNumber} succeeded`, { ...result, ...logData });
         }

package/src/sequencer/metrics.ts

@@ -2,21 +2,19 @@ import type { EthAddress } from '@aztec/aztec.js';
 import type { RollupContract } from '@aztec/ethereum';
 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 +24,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 +31,15 @@ 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;
 
   constructor(
     client: TelemetryClient,
-    getState: SequencerStateCallback,
-    private coinbase: EthAddress,
     private rollup: RollupContract,
     name = 'Sequencer',
   ) {
@@ -78,35 +70,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 +78,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 +88,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',
@@ -160,28 +123,6 @@ export class SequencerMetrics {
     });
   }
 
-  public setCoinbase(coinbase: EthAddress) {
-    this.coinbase = coinbase;
-  }
-
-  public start() {
-    this.meter.addBatchObservableCallback(this.observe, [this.rewards]);
-  }
-
-  public stop() {
-    this.meter.removeBatchObservableCallback(this.observe, [this.rewards]);
-  }
-
-  private observe = async (observer: BatchObservableResult): Promise<void> => {
-    let rewards = 0n;
-    rewards = await this.rollup.getSequencerRewards(this.coinbase);
-
-    const fmt = parseFloat(formatUnits(rewards, 18));
-    observer.observe(this.rewards, fmt, {
-      [Attributes.COINBASE]: this.coinbase.toString(),
-    });
-  };
-
   public recordRequiredAttestations(requiredAttestationsCount: number, allowanceMs: number) {
     this.requiredAttestions.record(requiredAttestationsCount);
     this.allowanceToCollectAttestations.record(Math.ceil(allowanceMs));
@@ -196,17 +137,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 +149,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 +157,35 @@ export class SequencerMetrics {
     });
   }
 
-  observeSlotChange(slot: bigint | undefined, proposer: string) {
+  incOpenSlot(slot: bigint, 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;
-  }
 
-  private setCurrentBlock(blockNumber: number, txCount: number) {
-    this.currentBlockNumber.record(blockNumber);
-    this.currentBlockSize.record(txCount);
+    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
+      }
+    }
   }
 }

package/src/sequencer/sequencer.ts

@@ -1,5 +1,5 @@
 import type { L2Block } from '@aztec/aztec.js';
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import type { EpochCache } from '@aztec/epoch-cache';
 import { FormattedViemError, NoCommitteeError, type RollupContract } from '@aztec/ethereum';
 import { omit, pick } from '@aztec/foundation/collection';
@@ -127,15 +127,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
   ) {
     super();
 
-    // Set an initial coinbase for metrics purposes, but this will potentially change with each block.
-    const validatorAddresses = this.validatorClient?.getValidatorAddresses() ?? [];
-    const coinbase =
-      validatorAddresses.length === 0
-        ? EthAddress.ZERO
-        : (this.validatorClient?.getCoinbaseForAttestor(validatorAddresses[0]) ?? EthAddress.ZERO);
-
-    this.metrics = new SequencerMetrics(telemetry, () => this.state, coinbase, this.rollupContract, 'Sequencer');
-
+    this.metrics = new SequencerMetrics(telemetry, this.rollupContract, 'Sequencer');
     // Initialize config
     this.updateConfig(this.config);
   }
@@ -220,7 +212,6 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
    * Starts the sequencer and moves to IDLE state.
    */
   public start() {
-    this.metrics.start();
     this.runningPromise = new RunningPromise(this.work.bind(this), this.log, this.pollingIntervalMs);
     this.setState(SequencerState.IDLE, undefined, { force: true });
     this.runningPromise.start();
@@ -232,7 +223,6 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
    */
   public async stop(): Promise<void> {
     this.log.info(`Stopping sequencer`);
-    this.metrics.stop();
     this.publisher?.interrupt();
     await this.validatorClient?.stop();
     await this.runningPromise?.stop();
@@ -361,8 +351,6 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     const coinbase = this.validatorClient!.getCoinbaseForAttestor(attestorAddress);
     const feeRecipient = this.validatorClient!.getFeeRecipientForAttestor(attestorAddress);
 
-    this.metrics.setCoinbase(coinbase);
-
     // Prepare invalidation request if the pending chain is invalid (returns undefined if no need)
     const invalidateBlock = await publisher.simulateInvalidateBlock(syncedTo.pendingChainValidationStatus);
     const canProposeCheck = await publisher.canProposeAtNextEthBlock(
@@ -435,6 +423,8 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     }
 
     this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
+
+    this.metrics.incOpenSlot(slot, proposerAddressInNextSlot.toString());
     this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
       proposer: proposerInNextSlot?.toString(),
       coinbase,
@@ -494,7 +484,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     if (proposedBlock) {
       this.lastBlockPublished = block;
       this.emit('block-published', { blockNumber: newBlockNumber, slot: Number(slot) });
-      this.metrics.incFilledSlot(publisher.getSenderAddress().toString());
+      await this.metrics.incFilledSlot(publisher.getSenderAddress().toString(), coinbase);
     } else if (block) {
       this.emit('block-publish-failed', l1Response ?? {});
     }
@@ -584,6 +574,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       maxTransactions: this.maxTxsPerBlock,
       maxBlockSize: this.maxBlockSizeInBytes,
       maxBlockGas: this.maxBlockGas,
+      maxBlobFields: BLOBS_PER_BLOCK * FIELDS_PER_BLOB,
       deadline,
     };
   }
@@ -616,7 +607,6 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     const slot = proposalHeader.slotNumber.toBigInt();
     const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
 
-    // this.metrics.recordNewBlock(blockNumber, validTxs.length);
     const workTimer = new Timer();
     this.setState(SequencerState.CREATING_BLOCK, slot);