@aztec/sequencer-client 2.0.3 → 2.1.0-rc.2

package/src/publisher/sequencer-publisher.ts

@@ -5,12 +5,11 @@ import type { EpochCache } from '@aztec/epoch-cache';
 import {
   type EmpireSlashingProposerContract,
   FormattedViemError,
-  type GasPrice,
   type GovernanceProposerContract,
   type IEmpireBase,
   type L1BlobInputs,
   type L1ContractsConfig,
-  type L1GasConfig,
+  type L1TxConfig,
   type L1TxRequest,
   MULTI_CALL_3_ADDRESS,
   Multicall3,
@@ -27,20 +26,19 @@ import type { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs'
 import { sumBigint } from '@aztec/foundation/bigint';
 import { toHex as toPaddedHex } from '@aztec/foundation/bigint-buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature, type ViemSignature } from '@aztec/foundation/eth-signature';
 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';
 import { type ProposerSlashAction, encodeSlashConsensusVotes } from '@aztec/slasher';
-import { CommitteeAttestation, type ValidateBlockResult } from '@aztec/stdlib/block';
+import { CommitteeAttestation, CommitteeAttestationsAndSigners, type ValidateBlockResult } from '@aztec/stdlib/block';
 import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
-import { ConsensusPayload, SignatureDomainSeparator, getHashedSignaturePayload } from '@aztec/stdlib/p2p';
 import type { L1PublishBlockStats } from '@aztec/stdlib/stats';
-import { type ProposedBlockHeader, StateReference, TxHash } from '@aztec/stdlib/tx';
+import { type ProposedBlockHeader, StateReference } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
-import pick from 'lodash.pick';
 import { type TransactionReceipt, type TypedDataDefinition, encodeFunctionData, toHex } from 'viem';
 
 import type { PublisherConfig, TxSenderConfig } from './config.js';
@@ -56,17 +54,12 @@ type L1ProcessArgs = {
   stateReference: StateReference;
   /** L2 block blobs containing all tx effects. */
   blobs: Blob[];
-  /** L2 block tx hashes */
-  txHashes: TxHash[];
   /** Attestations */
-  attestations?: CommitteeAttestation[];
+  attestationsAndSigners: CommitteeAttestationsAndSigners;
+  /** Attestations and signers signature */
+  attestationsAndSignersSignature: Signature;
 };
 
-export enum SignalType {
-  GOVERNANCE,
-  SLASHING,
-}
-
 export const Actions = [
   'invalidate-by-invalid-attestation',
   'invalidate-by-insufficient-attestations',
@@ -78,8 +71,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);
 
@@ -95,11 +91,11 @@ interface RequestWithExpiry {
   action: Action;
   request: L1TxRequest;
   lastValidL2Slot: bigint;
-  gasConfig?: Pick<L1GasConfig, 'txTimeoutAt' | 'gasLimit'>;
+  gasConfig?: Pick<L1TxConfig, 'txTimeoutAt' | 'gasLimit'>;
   blobConfig?: L1BlobInputs;
   checkSuccess: (
     request: L1TxRequest,
-    result?: { receipt: TransactionReceipt; gasPrice: GasPrice; stats?: TransactionStats; errorMsg?: string },
+    result?: { receipt: TransactionReceipt; stats?: TransactionStats; errorMsg?: string },
   ) => boolean;
 }
 
@@ -111,12 +107,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 +145,14 @@ export class SequencerPublisher {
       epochCache: EpochCache;
       dateProvider: DateProvider;
       metrics: SequencerPublisherMetrics;
+      lastActions: Partial<Record<Action, bigint>>;
+      log?: Logger;
     },
   ) {
+    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') });
@@ -249,18 +246,21 @@ export class SequencerPublisher {
     const gasLimit = gasLimits.length > 0 ? sumBigint(gasLimits) : undefined; // sum
     const txTimeoutAts = gasConfigs.map(g => g?.txTimeoutAt).filter((g): g is Date => g !== undefined);
     const txTimeoutAt = txTimeoutAts.length > 0 ? new Date(Math.min(...txTimeoutAts.map(g => g.getTime()))) : undefined; // earliest
-    const gasConfig: RequestWithExpiry['gasConfig'] = { gasLimit, txTimeoutAt };
+    const txConfig: RequestWithExpiry['gasConfig'] = { gasLimit, txTimeoutAt };
 
     // Sort the requests so that proposals always go first
     // This ensures the committee gets precomputed correctly
     validRequests.sort((a, b) => compareActions(a.action, b.action));
 
     try {
-      this.log.debug('Forwarding transactions', { validRequests: validRequests.map(request => request.action) });
+      this.log.debug('Forwarding transactions', {
+        validRequests: validRequests.map(request => request.action),
+        txConfig,
+      });
       const result = await Multicall3.forward(
         validRequests.map(request => request.request),
         this.l1TxUtils,
-        gasConfig,
+        txConfig,
         blobConfig,
         this.rollupContract.address,
         this.log,
@@ -285,7 +285,7 @@ export class SequencerPublisher {
 
   private callbackBundledTransactions(
     requests: RequestWithExpiry[],
-    result?: { receipt: TransactionReceipt; gasPrice: GasPrice } | FormattedViemError,
+    result?: { receipt: TransactionReceipt } | FormattedViemError,
   ) {
     const actionsListStr = requests.map(r => r.action).join(', ');
     if (result instanceof FormattedViemError) {
@@ -346,8 +346,9 @@ export class SequencerPublisher {
 
     const args = [
       header.toViem(),
-      RollupContract.packAttestations([]),
+      CommitteeAttestationsAndSigners.empty().getPackedAttestations(),
       [], // no signers
+      Signature.empty().toViemSignature(),
       `0x${'0'.repeat(64)}`, // 32 empty bytes
       header.contentCommitment.blobsHash.toString(),
       flags,
@@ -446,17 +447,19 @@ export class SequencerPublisher {
     const logData = { ...block, reason };
     this.log.debug(`Simulating invalidate block ${block.blockNumber}`, logData);
 
+    const attestationsAndSigners = new CommitteeAttestationsAndSigners(attestations).getPackedAttestations();
+
     if (reason === 'invalid-attestation') {
       return this.rollupContract.buildInvalidateBadAttestationRequest(
         block.blockNumber,
-        attestations.map(a => a.toViem()),
+        attestationsAndSigners,
         committee,
         validationResult.invalidIndex,
       );
     } else if (reason === 'insufficient-attestations') {
       return this.rollupContract.buildInvalidateInsufficientAttestationsRequest(
         block.blockNumber,
-        attestations.map(a => a.toViem()),
+        attestationsAndSigners,
         committee,
       );
     } else {
@@ -476,24 +479,22 @@ export class SequencerPublisher {
    */
   public async validateBlockForSubmission(
     block: L2Block,
-    attestationData: { digest: Buffer; attestations: CommitteeAttestation[] } = {
-      digest: Buffer.alloc(32),
-      attestations: [],
-    },
+    attestationsAndSigners: CommitteeAttestationsAndSigners,
+    attestationsAndSignersSignature: Signature,
     options: { forcePendingBlockNumber?: number },
   ): Promise<bigint> {
     const ts = BigInt((await this.l1TxUtils.getBlock()).timestamp + this.ethereumSlotDuration);
 
     // If we have no attestations, we still need to provide the empty attestations
     // so that the committee is recalculated correctly
-    const ignoreSignatures = attestationData.attestations.length === 0;
+    const ignoreSignatures = attestationsAndSigners.attestations.length === 0;
     if (ignoreSignatures) {
       const { committee } = await this.epochCache.getCommittee(block.header.globalVariables.slotNumber.toBigInt());
       if (!committee) {
         this.log.warn(`No committee found for slot ${block.header.globalVariables.slotNumber.toBigInt()}`);
         throw new Error(`No committee found for slot ${block.header.globalVariables.slotNumber.toBigInt()}`);
       }
-      attestationData.attestations = committee.map(committeeMember =>
+      attestationsAndSigners.attestations = committee.map(committeeMember =>
         CommitteeAttestation.fromAddress(committeeMember),
       );
     }
@@ -501,23 +502,18 @@ export class SequencerPublisher {
     const blobs = await Blob.getBlobsPerBlock(block.body.toBlobFields());
     const blobInput = Blob.getPrefixedEthBlobCommitments(blobs);
 
-    const formattedAttestations = attestationData.attestations.map(attest => attest.toViem());
-    const signers = attestationData.attestations
-      .filter(attest => !attest.signature.isEmpty())
-      .map(attest => attest.address.toString());
-
     const args = [
       {
         header: block.header.toPropose().toViem(),
         archive: toHex(block.archive.root.toBuffer()),
         stateReference: block.header.state.toViem(),
-        txHashes: block.body.txEffects.map(txEffect => txEffect.txHash.toString()),
         oracleInput: {
           feeAssetPriceModifier: 0n,
         },
       },
-      RollupContract.packAttestations(formattedAttestations),
-      signers,
+      attestationsAndSigners.getPackedAttestations(),
+      attestationsAndSigners.getSigners().map(signer => signer.toString()),
+      attestationsAndSignersSignature.toViemSignature(),
       blobInput,
     ] as const;
 
@@ -528,13 +524,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 +548,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 +593,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 +623,7 @@ export class SequencerPublisher {
     return this.enqueueCastSignalHelper(
       slotNumber,
       timestamp,
-      SignalType.GOVERNANCE,
+      'governance-signal',
       governancePayload,
       this.govProposerContract,
       signerAddress,
@@ -661,7 +657,7 @@ export class SequencerPublisher {
           await this.enqueueCastSignalHelper(
             slotNumber,
             timestamp,
-            SignalType.SLASHING,
+            'empire-slashing-signal',
             action.payload,
             this.slashingProposerContract,
             signerAddress,
@@ -766,15 +762,12 @@ export class SequencerPublisher {
    */
   public async enqueueProposeL2Block(
     block: L2Block,
-    attestations?: CommitteeAttestation[],
-    txHashes?: TxHash[],
+    attestationsAndSigners: CommitteeAttestationsAndSigners,
+    attestationsAndSignersSignature: Signature,
     opts: { txTimeoutAt?: Date; forcePendingBlockNumber?: number } = {},
   ): Promise<boolean> {
     const proposedBlockHeader = block.header.toPropose();
 
-    const consensusPayload = ConsensusPayload.fromBlock(block);
-    const digest = getHashedSignaturePayload(consensusPayload, SignatureDomainSeparator.blockAttestation);
-
     const blobs = await Blob.getBlobsPerBlock(block.body.toBlobFields());
     const proposeTxArgs = {
       header: proposedBlockHeader,
@@ -782,8 +775,8 @@ export class SequencerPublisher {
       stateReference: block.header.state,
       body: block.body.toBuffer(),
       blobs,
-      attestations,
-      txHashes: txHashes ?? [],
+      attestationsAndSigners,
+      attestationsAndSignersSignature,
     };
 
     let ts: bigint;
@@ -793,9 +786,8 @@ export class SequencerPublisher {
       //        This means that we can avoid the simulation issues in later checks.
       //        By simulation issue, I mean the fact that the block.timestamp is equal to the last block, not the next, which
       //        make time consistency checks break.
-      const attestationData = { digest: digest.toBuffer(), attestations: attestations ?? [] };
       // TODO(palla): Check whether we're validating twice, once here and once within addProposeTx, since we call simulateProposeTx in both places.
-      ts = await this.validateBlockForSubmission(block, attestationData, opts);
+      ts = await this.validateBlockForSubmission(block, attestationsAndSigners, attestationsAndSignersSignature, opts);
     } catch (err: any) {
       this.log.error(`Block validation failed. ${err instanceof Error ? err.message : 'No error message'}`, err, {
         ...block.getStats(),
@@ -818,7 +810,8 @@ export class SequencerPublisher {
     // We issued the simulation against the rollup contract, so we need to account for the overhead of the multicall3
     const gasLimit = this.l1TxUtils.bumpGasLimit(BigInt(Math.ceil((Number(request.gasUsed) * 64) / 63)));
 
-    const logData = { ...pick(request, 'gasUsed', 'blockNumber'), gasLimit, opts };
+    const { gasUsed, blockNumber } = request;
+    const logData = { gasUsed, blockNumber, gasLimit, opts };
     this.log.verbose(`Enqueuing invalidate block request`, logData);
     this.addRequest({
       action: `invalidate-by-${request.reason}`,
@@ -842,16 +835,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;
+    }
+
+    const cachedLastActionSlot = this.lastActions[action];
+    this.lastActions[action] = slotNumber;
 
-    this.log.debug(`Simulating ${action}`, logData);
+    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 +876,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 });
         }
@@ -932,12 +934,7 @@ export class SequencerPublisher {
         throw new Error('Failed to validate blobs');
       });
 
-    const attestations = encodedData.attestations ? encodedData.attestations.map(attest => attest.toViem()) : [];
-    const txHashes = encodedData.txHashes ? encodedData.txHashes.map(txHash => txHash.toString()) : [];
-
-    const signers = encodedData.attestations
-      ?.filter(attest => !attest.signature.isEmpty())
-      .map(attest => attest.address.toString());
+    const signers = encodedData.attestationsAndSigners.getSigners().map(signer => signer.toString());
 
     const args = [
       {
@@ -948,10 +945,10 @@ export class SequencerPublisher {
           // We are currently not modifying these. See #9963
           feeAssetPriceModifier: 0n,
         },
-        txHashes,
       },
-      RollupContract.packAttestations(attestations),
-      signers ?? [],
+      encodedData.attestationsAndSigners.getPackedAttestations(),
+      signers,
+      encodedData.attestationsAndSignersSignature.toViemSignature(),
       blobInput,
     ] as const;
 
@@ -972,13 +969,13 @@ export class SequencerPublisher {
         readonly header: ViemHeader;
         readonly archive: `0x${string}`;
         readonly stateReference: ViemStateReference;
-        readonly txHashes: `0x${string}`[];
         readonly oracleInput: {
           readonly feeAssetPriceModifier: 0n;
         };
       },
       ViemCommitteeAttestations,
-      `0x${string}`[],
+      `0x${string}`[], // Signers
+      ViemSignature,
       `0x${string}`,
     ],
     timestamp: bigint,
@@ -1084,13 +1081,16 @@ export class SequencerPublisher {
         if (success) {
           const endBlock = receipt.blockNumber;
           const inclusionBlocks = Number(endBlock - startBlock);
+          const { calldataGas, calldataSize, sender } = stats!;
           const publishStats: L1PublishBlockStats = {
             gasPrice: receipt.effectiveGasPrice,
             gasUsed: receipt.gasUsed,
             blobGasUsed: receipt.blobGasUsed ?? 0n,
             blobDataGas: receipt.blobGasPrice ?? 0n,
             transactionHash: receipt.transactionHash,
-            ...pick(stats!, 'calldataGas', 'calldataSize', 'sender'),
+            calldataGas,
+            calldataSize,
+            sender,
             ...block.getStats(),
             eventName: 'rollup-published-to-l1',
             blobCount: encodedData.blobs.length,

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

@@ -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
+      }
+    }
   }
 }