@aztec/sequencer-client 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/sequencer/block_builder.ts

@@ -0,0 +1,218 @@
+import { MerkleTreeId } from '@aztec/aztec.js/trees';
+import { merge, pick } from '@aztec/foundation/collection';
+import type { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+import { bufferToHex } from '@aztec/foundation/string';
+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,
+} from '@aztec/simulator/server';
+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,
+  PublicProcessorValidator,
+  WorldStateSynchronizer,
+} from '@aztec/stdlib/interfaces/server';
+import { GlobalVariables, Tx } from '@aztec/stdlib/tx';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { createValidatorForBlockBuilding } from '../tx_validator/tx_validator_factory.js';
+
+const log = createLogger('block-builder');
+
+export async function buildBlock(
+  pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
+  l1ToL2Messages: Fr[],
+  newGlobalVariables: GlobalVariables,
+  opts: PublicProcessorLimits = {},
+  worldStateFork: MerkleTreeWriteOperations,
+  processor: PublicProcessor,
+  validator: PublicProcessorValidator,
+  l1Constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>,
+  dateProvider: DateProvider,
+  telemetryClient: TelemetryClient = getTelemetryClient(),
+): Promise<BuildBlockResult> {
+  const blockBuildingTimer = new Timer();
+  const blockNumber = newGlobalVariables.blockNumber;
+  const slot = newGlobalVariables.slotNumber.toBigInt();
+  const msgCount = l1ToL2Messages.length;
+  const stateReference = await worldStateFork.getStateReference();
+  const archiveTree = await worldStateFork.getTreeInfo(MerkleTreeId.ARCHIVE);
+
+  log.verbose(`Building block ${blockNumber} for slot ${slot}`, {
+    slot,
+    slotStart: new Date(Number(getTimestampForSlot(slot, l1Constants)) * 1000),
+    now: new Date(dateProvider.now()),
+    blockNumber,
+    msgCount,
+    initialStateReference: stateReference.toInspect(),
+    initialArchiveRoot: bufferToHex(archiveTree.root),
+    opts,
+  });
+  const blockFactory = new LightweightBlockFactory(worldStateFork, telemetryClient);
+  await blockFactory.startNewBlock(newGlobalVariables, l1ToL2Messages);
+
+  const [publicProcessorDuration, [processedTxs, failedTxs, usedTxs]] = await elapsed(() =>
+    processor.process(pendingTxs, opts, validator),
+  );
+
+  // All real transactions have been added, set the block as full and pad if needed
+  await blockFactory.addTxs(processedTxs);
+  const block = await blockFactory.setBlockCompleted();
+
+  // How much public gas was processed
+  const publicGas = processedTxs.reduce((acc, tx) => acc.add(tx.gasUsed.publicGas), Gas.empty());
+
+  const res = {
+    block,
+    publicGas,
+    publicProcessorDuration,
+    numMsgs: l1ToL2Messages.length,
+    numTxs: processedTxs.length,
+    failedTxs: failedTxs,
+    blockBuildingTimer,
+    usedTxs,
+  };
+  log.trace('Built block', res.block.header);
+  return res;
+}
+
+const FullNodeBlockBuilderConfigKeys = [
+  'l1GenesisTime',
+  'slotDuration',
+  'l1ChainId',
+  'rollupVersion',
+  'txPublicSetupAllowList',
+  'fakeProcessingDelayPerTxMs',
+] as const;
+
+export class FullNodeBlockBuilder implements IFullNodeBlockBuilder {
+  constructor(
+    private config: FullNodeBlockBuilderConfig,
+    private worldState: WorldStateSynchronizer,
+    private contractDataSource: ContractDataSource,
+    private dateProvider: DateProvider,
+    private telemetryClient: TelemetryClient = getTelemetryClient(),
+  ) {}
+
+  public getConfig(): FullNodeBlockBuilderConfig {
+    return pick(this.config, ...FullNodeBlockBuilderConfigKeys);
+  }
+
+  public updateConfig(config: Partial<FullNodeBlockBuilderConfig>) {
+    this.config = merge(this.config, pick(config, ...FullNodeBlockBuilderConfigKeys));
+  }
+
+  public async makeBlockBuilderDeps(globalVariables: GlobalVariables, fork: MerkleTreeWriteOperations) {
+    const txPublicSetupAllowList = this.config.txPublicSetupAllowList ?? (await getDefaultAllowedSetupFunctions());
+    const contractsDB = new PublicContractsDB(this.contractDataSource);
+    const guardedFork = new GuardedMerkleTreeOperations(fork);
+
+    const publicTxSimulator = new TelemetryPublicTxSimulator(
+      guardedFork,
+      contractsDB,
+      globalVariables,
+      this.telemetryClient,
+      {
+        doMerkleOperations: true,
+        skipFeeEnforcement: true,
+        clientInitiatedSimulation: false,
+      },
+    );
+
+    const processor = new PublicProcessor(
+      globalVariables,
+      guardedFork,
+      contractsDB,
+      publicTxSimulator,
+      this.dateProvider,
+      this.telemetryClient,
+      undefined,
+      this.config,
+    );
+
+    const validator = createValidatorForBlockBuilding(
+      fork,
+      this.contractDataSource,
+      globalVariables,
+      txPublicSetupAllowList,
+    );
+
+    return {
+      processor,
+      validator,
+    };
+  }
+
+  private async syncToPreviousBlock(parentBlockNumber: number, timeout: number | undefined) {
+    await retryUntil(
+      () => this.worldState.syncImmediate(parentBlockNumber, true).then(syncedTo => syncedTo >= parentBlockNumber),
+      'sync to previous block',
+      timeout,
+      0.1,
+    );
+    log.debug(`Synced to previous block ${parentBlockNumber}`);
+  }
+
+  async buildBlock(
+    pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
+    l1ToL2Messages: Fr[],
+    globalVariables: GlobalVariables,
+    opts: PublicProcessorLimits,
+    suppliedFork?: MerkleTreeWriteOperations,
+  ): Promise<BuildBlockResult> {
+    const parentBlockNumber = 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));
+
+    try {
+      const { processor, validator } = await this.makeBlockBuilderDeps(globalVariables, fork);
+      const res = await buildBlock(
+        pendingTxs,
+        l1ToL2Messages,
+        globalVariables,
+        opts,
+        fork,
+        processor,
+        validator,
+        this.config,
+        this.dateProvider,
+        this.telemetryClient,
+      );
+      return res;
+    } finally {
+      // If the fork was supplied, we don't close it.
+      // Otherwise, we wait a bit to close the fork we just created,
+      // since the processor may still be working on a dangling tx
+      // which was interrupted due to the processingDeadline being hit.
+      if (!suppliedFork) {
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        setTimeout(async () => {
+          try {
+            await fork.close();
+          } catch (err) {
+            // This can happen if the sequencer is stopped before we hit this timeout.
+            log.warn(`Error closing forks for block processing`, err);
+          }
+        }, 5000);
+      }
+    }
+  }
+
+  getFork(blockNumber: number): Promise<MerkleTreeWriteOperations> {
+    return this.worldState.fork(blockNumber);
+  }
+}

package/src/sequencer/config.ts

@@ -1 +1,8 @@
+import type { GovernanceProposerContract, RollupContract } from '@aztec/ethereum';
+
 export { type SequencerConfig } from '@aztec/stdlib/config';
+
+export type SequencerContracts = {
+  rollupContract: RollupContract;
+  governanceProposerContract: GovernanceProposerContract;
+};

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/index.ts

@@ -1,3 +1,3 @@
+export * from './block_builder.js';
 export * from './config.js';
 export * from './sequencer.js';
-export * from './allowed.js';

package/src/sequencer/metrics.ts

@@ -1,7 +1,10 @@
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import type { RollupContract } from '@aztec/ethereum';
 import {
   Attributes,
   type Gauge,
   type Histogram,
+  type Meter,
   Metrics,
   type TelemetryClient,
   type Tracer,
@@ -9,100 +12,129 @@ import {
   ValueType,
 } from '@aztec/telemetry-client';
 
-import { type SequencerState, type SequencerStateCallback, sequencerStateToNumber } from './utils.js';
+import { type Hex, formatUnits } from 'viem';
+
+import type { SequencerState } from './utils.js';
 
 export class SequencerMetrics {
   public readonly tracer: Tracer;
+  private meter: Meter;
 
   private blockCounter: UpDownCounter;
   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;
+  private allowanceToCollectAttestations: Gauge;
+  private requiredAttestions: Gauge;
+  private collectedAttestions: Gauge;
+
+  private rewards: Gauge;
+
+  private slots: UpDownCounter;
+  private filledSlots: UpDownCounter;
+
+  private lastSeenSlot?: bigint;
 
-  constructor(client: TelemetryClient, getState: SequencerStateCallback, name = 'Sequencer') {
-    const meter = client.getMeter(name);
+  constructor(
+    client: TelemetryClient,
+    private rollup: RollupContract,
+    name = 'Sequencer',
+  ) {
+    this.meter = client.getMeter(name);
     this.tracer = client.getTracer(name);
 
-    this.blockCounter = meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_COUNT);
+    this.blockCounter = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_COUNT);
 
-    this.blockBuildDuration = meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION, {
+    this.blockBuildDuration = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION, {
       unit: 'ms',
       description: 'Duration to build a block',
       valueType: ValueType.INT,
     });
 
-    this.blockBuildManaPerSecond = meter.createGauge(Metrics.SEQUENCER_BLOCK_BUILD_MANA_PER_SECOND, {
+    this.blockBuildManaPerSecond = this.meter.createGauge(Metrics.SEQUENCER_BLOCK_BUILD_MANA_PER_SECOND, {
       unit: 'mana/s',
       description: 'Mana per second when building a block',
       valueType: ValueType.INT,
     });
 
-    this.stateTransitionBufferDuration = meter.createHistogram(Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION, {
-      unit: 'ms',
-      description:
-        'The time difference between when the sequencer needed to transition to a new state and when it actually did.',
-      valueType: ValueType.INT,
+    this.stateTransitionBufferDuration = this.meter.createHistogram(
+      Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION,
+      {
+        unit: 'ms',
+        description:
+          'The time difference between when the sequencer needed to transition to a new state and when it actually did.',
+        valueType: ValueType.INT,
+      },
+    );
+
+    // Init gauges and counters
+    this.blockCounter.add(0, {
+      [Attributes.STATUS]: 'failed',
     });
-
-    const currentState = meter.createObservableGauge(Metrics.SEQUENCER_CURRENT_STATE, {
-      description: 'Current state of the sequencer',
+    this.blockCounter.add(0, {
+      [Attributes.STATUS]: 'built',
     });
 
-    currentState.addCallback(observer => {
-      observer.observe(sequencerStateToNumber(getState()));
+    this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_REWARDS, {
+      valueType: ValueType.DOUBLE,
+      description: 'The rewards earned',
     });
 
-    this.currentBlockNumber = meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_NUMBER, {
-      description: 'Current block number',
+    this.slots = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLOT_COUNT, {
       valueType: ValueType.INT,
+      description: 'The number of slots this sequencer was selected for',
     });
 
-    this.currentBlockSize = meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_SIZE, {
-      description: 'Current block size',
+    /**
+     * 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.timeToCollectAttestations = meter.createGauge(Metrics.SEQUENCER_TIME_TO_COLLECT_ATTESTATIONS, {
+    this.timeToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_DURATION, {
       description: 'The time spent collecting attestations from committee members',
+      unit: 'ms',
       valueType: ValueType.INT,
     });
 
-    this.blockBuilderInsertions = meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_INSERTION_TIME, {
-      description: 'Timer for tree insertions performed by the block builder',
-      unit: 'us',
+    this.allowanceToCollectAttestations = this.meter.createGauge(
+      Metrics.SEQUENCER_COLLECT_ATTESTATIONS_TIME_ALLOWANCE,
+      {
+        description: 'Maximum amount of time to collect attestations',
+        unit: 'ms',
+        valueType: ValueType.INT,
+      },
+    );
+
+    this.requiredAttestions = this.meter.createGauge(Metrics.SEQUENCER_REQUIRED_ATTESTATIONS_COUNT, {
       valueType: ValueType.INT,
+      description: 'The minimum number of attestations required to publish a block',
     });
 
-    this.setCurrentBlock(0, 0);
-  }
-
-  startCollectingAttestationsTimer(): () => void {
-    const startTime = Date.now();
-    const stop = () => {
-      const duration = Date.now() - startTime;
-      this.recordTimeToCollectAttestations(duration);
-    };
-    return stop.bind(this);
+    this.collectedAttestions = this.meter.createGauge(Metrics.SEQUENCER_COLLECTED_ATTESTATIONS_COUNT, {
+      valueType: ValueType.INT,
+      description: 'The minimum number of attestations required to publish a block',
+    });
   }
 
-  recordTimeToCollectAttestations(time: number) {
-    this.timeToCollectAttestations.record(time);
-  }
+  public recordRequiredAttestations(requiredAttestationsCount: number, allowanceMs: number) {
+    this.requiredAttestions.record(requiredAttestationsCount);
+    this.allowanceToCollectAttestations.record(Math.ceil(allowanceMs));
 
-  recordBlockBuilderTreeInsertions(timeUs: number) {
-    this.blockBuilderInsertions.record(Math.ceil(timeUs));
+    // reset
+    this.collectedAttestions.record(0);
+    this.timeToCollectAttestations.record(0);
   }
 
-  recordCancelledBlock() {
-    this.blockCounter.add(1, {
-      [Attributes.STATUS]: 'cancelled',
-    });
-    this.setCurrentBlock(0, 0);
+  public recordCollectedAttestations(count: number, durationMs: number) {
+    this.collectedAttestions.record(count);
+    this.timeToCollectAttestations.record(Math.ceil(durationMs));
   }
 
   recordBuiltBlock(buildDurationMs: number, totalMana: number) {
@@ -117,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) {
@@ -130,8 +157,35 @@ export class SequencerMetrics {
     });
   }
 
-  private setCurrentBlock(blockNumber: number, txCount: number) {
-    this.currentBlockNumber.record(blockNumber);
-    this.currentBlockSize.record(txCount);
+  incOpenSlot(slot: bigint, proposer: string) {
+    // sequencer went through the loop a second time. Noop
+    if (slot === this.lastSeenSlot) {
+      return;
+    }
+
+    this.slots.add(1, {
+      [Attributes.BLOCK_PROPOSER]: proposer,
+    });
+
+    this.lastSeenSlot = slot;
+  }
+
+  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
+      }
+    }
   }
 }