@aztec/sequencer-client 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/src/sequencer/timetable.ts

@@ -1,188 +0,0 @@
-import { createLogger } from '@aztec/aztec.js/log';
-
-import { DEFAULT_ATTESTATION_PROPAGATION_TIME } from '../config.js';
-import { SequencerTooSlowError } from './errors.js';
-import type { SequencerMetrics } from './metrics.js';
-import { SequencerState } from './utils.js';
-
-const MIN_EXECUTION_TIME = 1;
-const BLOCK_PREPARE_TIME = 1;
-const BLOCK_VALIDATION_TIME = 1;
-
-export class SequencerTimetable {
-  /**
-   * How late into the slot can we be to start working. Computed as the total time needed for assembling and publishing a block,
-   * assuming an execution time equal to `minExecutionTime`, subtracted from the slot duration. This means that, if the proposer
-   * starts building at this time, and all times hold, it will have at least `minExecutionTime` to execute txs for the block.
-   */
-  public readonly initializeDeadline: number;
-
-  /**
-   * How long it takes to get a published block into L1. L1 builders typically accept txs up to 4 seconds into their slot,
-   * but we'll timeout sooner to give it more time to propagate (remember we also have blobs!). Still, when working in anvil,
-   * we can just post in the very last second of the L1 slot and still expect the tx to be accepted.
-   */
-  public readonly l1PublishingTime;
-
-  /** What's the minimum time we want to leave available for execution and reexecution (used to derive init deadline) */
-  public readonly minExecutionTime: number = MIN_EXECUTION_TIME;
-
-  /** How long it takes to get ready to start building */
-  public readonly blockPrepareTime: number = BLOCK_PREPARE_TIME;
-
-  /** How long it takes to for proposals and attestations to travel across the p2p layer (one-way) */
-  public readonly attestationPropagationTime: number;
-
-  /** How much time we spend validating and processing a block after building it, and assembling the proposal to send to attestors */
-  public readonly blockValidationTime: number = BLOCK_VALIDATION_TIME;
-
-  /** Ethereum slot duration in seconds */
-  public readonly ethereumSlotDuration: number;
-
-  /** Aztec slot duration in seconds (must be multiple of ethereum slot duration) */
-  public readonly aztecSlotDuration: number;
-
-  /** How late into an L1 slot we can send a tx to make sure it gets included in the immediate next block. Complement of l1PublishingTime. */
-  public readonly maxL1TxInclusionTimeIntoSlot: number;
-
-  /** Whether assertTimeLeft will throw if not enough time. */
-  public readonly enforce: boolean;
-
-  constructor(
-    opts: {
-      ethereumSlotDuration: number;
-      aztecSlotDuration: number;
-      maxL1TxInclusionTimeIntoSlot: number;
-      attestationPropagationTime?: number;
-      enforce: boolean;
-    },
-    private readonly metrics?: SequencerMetrics,
-    private readonly log = createLogger('sequencer:timetable'),
-  ) {
-    this.ethereumSlotDuration = opts.ethereumSlotDuration;
-    this.aztecSlotDuration = opts.aztecSlotDuration;
-    this.maxL1TxInclusionTimeIntoSlot = opts.maxL1TxInclusionTimeIntoSlot;
-    this.attestationPropagationTime = opts.attestationPropagationTime ?? DEFAULT_ATTESTATION_PROPAGATION_TIME;
-    this.l1PublishingTime = this.ethereumSlotDuration - this.maxL1TxInclusionTimeIntoSlot;
-    this.enforce = opts.enforce;
-
-    // Assume zero-cost propagation time and faster runs in test environments where L1 slot duration is shortened
-    if (this.ethereumSlotDuration < 8) {
-      this.attestationPropagationTime = 0;
-      this.blockValidationTime = 0.5;
-      this.blockPrepareTime = 0.5;
-    }
-
-    const allWorkToDo =
-      this.blockPrepareTime +
-      this.minExecutionTime * 2 +
-      this.attestationPropagationTime * 2 +
-      this.blockValidationTime +
-      this.l1PublishingTime;
-
-    const initializeDeadline = this.aztecSlotDuration - allWorkToDo;
-    this.initializeDeadline = initializeDeadline;
-
-    this.log.verbose(`Sequencer timetable initialized (${this.enforce ? 'enforced' : 'not enforced'})`, {
-      ethereumSlotDuration: this.ethereumSlotDuration,
-      aztecSlotDuration: this.aztecSlotDuration,
-      maxL1TxInclusionTimeIntoSlot: this.maxL1TxInclusionTimeIntoSlot,
-      l1PublishingTime: this.l1PublishingTime,
-      minExecutionTime: this.minExecutionTime,
-      blockPrepareTime: this.blockPrepareTime,
-      attestationPropagationTime: this.attestationPropagationTime,
-      blockValidationTime: this.blockValidationTime,
-      initializeDeadline: this.initializeDeadline,
-      enforce: this.enforce,
-      allWorkToDo,
-    });
-
-    if (initializeDeadline <= 0) {
-      throw new Error(
-        `Block proposal initialize deadline cannot be negative (got ${initializeDeadline} from total time needed ${allWorkToDo} and a slot duration of ${this.aztecSlotDuration}).`,
-      );
-    }
-  }
-
-  private get afterBlockBuildingTimeNeededWithoutReexec() {
-    return this.blockValidationTime + this.attestationPropagationTime * 2 + this.l1PublishingTime;
-  }
-
-  public getBlockProposalExecTimeEnd(secondsIntoSlot: number): number {
-    // We are N seconds into the slot. We need to account for `afterBlockBuildingTimeNeededWithoutReexec` seconds,
-    // send then split the remaining time between the re-execution and the block building.
-    const maxAllowed = this.aztecSlotDuration - this.afterBlockBuildingTimeNeededWithoutReexec;
-    const available = maxAllowed - secondsIntoSlot;
-    const executionTimeEnd = secondsIntoSlot + available / 2;
-    this.log.debug(`Block proposal execution time deadline is ${executionTimeEnd}`, {
-      secondsIntoSlot,
-      maxAllowed,
-      available,
-      executionTimeEnd,
-    });
-    return executionTimeEnd;
-  }
-
-  private get afterBlockReexecTimeNeeded() {
-    return this.attestationPropagationTime + this.l1PublishingTime;
-  }
-
-  public getValidatorReexecTimeEnd(secondsIntoSlot?: number): number {
-    // We need to leave for `afterBlockReexecTimeNeeded` seconds available.
-    const validationTimeEnd = this.aztecSlotDuration - this.afterBlockReexecTimeNeeded;
-    this.log.debug(`Validator re-execution time deadline is ${validationTimeEnd}`, {
-      secondsIntoSlot,
-      validationTimeEnd,
-    });
-    return validationTimeEnd;
-  }
-
-  public getMaxAllowedTime(
-    state: Extract<SequencerState, SequencerState.STOPPED | SequencerState.IDLE | SequencerState.SYNCHRONIZING>,
-  ): undefined;
-  public getMaxAllowedTime(
-    state: Exclude<SequencerState, SequencerState.STOPPED | SequencerState.IDLE | SequencerState.SYNCHRONIZING>,
-  ): number;
-  public getMaxAllowedTime(state: SequencerState): number | undefined;
-  public getMaxAllowedTime(state: SequencerState): number | undefined {
-    switch (state) {
-      case SequencerState.STOPPED:
-      case SequencerState.STOPPING:
-      case SequencerState.IDLE:
-      case SequencerState.SYNCHRONIZING:
-        return; // We don't really care about times for this states
-      case SequencerState.PROPOSER_CHECK:
-      case SequencerState.INITIALIZING_PROPOSAL:
-        return this.initializeDeadline;
-      case SequencerState.CREATING_BLOCK:
-        return this.initializeDeadline + this.blockPrepareTime;
-      case SequencerState.COLLECTING_ATTESTATIONS:
-        return this.aztecSlotDuration - this.l1PublishingTime - 2 * this.attestationPropagationTime;
-      case SequencerState.PUBLISHING_BLOCK:
-        return this.aztecSlotDuration - this.l1PublishingTime;
-      default: {
-        const _exhaustiveCheck: never = state;
-        throw new Error(`Unexpected state: ${state}`);
-      }
-    }
-  }
-
-  public assertTimeLeft(newState: SequencerState, secondsIntoSlot: number) {
-    if (!this.enforce) {
-      return;
-    }
-
-    const maxAllowedTime = this.getMaxAllowedTime(newState);
-    if (maxAllowedTime === undefined) {
-      return;
-    }
-
-    const bufferSeconds = maxAllowedTime - secondsIntoSlot;
-    if (bufferSeconds < 0) {
-      throw new SequencerTooSlowError(newState, maxAllowedTime, secondsIntoSlot);
-    }
-
-    this.metrics?.recordStateTransitionBufferMs(Math.floor(bufferSeconds * 1000), newState);
-    this.log.trace(`Enough time to transition to ${newState}`, { maxAllowedTime, secondsIntoSlot });
-  }
-}

package/src/tx_validator/nullifier_cache.ts

@@ -1,30 +0,0 @@
-import type { NullifierSource } from '@aztec/p2p';
-import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
-
-/**
- * Implements a nullifier source by checking a DB and an in-memory collection.
- * Intended for validating transactions as they are added to a block.
- */
-export class NullifierCache implements NullifierSource {
-  nullifiers: Set<string>;
-
-  constructor(private db: MerkleTreeReadOperations) {
-    this.nullifiers = new Set();
-  }
-
-  public async nullifiersExist(nullifiers: Buffer[]): Promise<boolean[]> {
-    const cacheResults = nullifiers.map(n => this.nullifiers.has(n.toString()));
-    const toCheckDb = nullifiers.filter((_n, index) => !cacheResults[index]);
-    const dbHits = await this.db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, toCheckDb);
-
-    let dbIndex = 0;
-    return nullifiers.map((_n, index) => cacheResults[index] || dbHits[dbIndex++] !== undefined);
-  }
-
-  public addNullifiers(nullifiers: Buffer[]) {
-    for (const nullifier of nullifiers) {
-      this.nullifiers.add(nullifier.toString());
-    }
-  }
-}

package/src/tx_validator/tx_validator_factory.ts

@@ -1,132 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import {
-  AggregateTxValidator,
-  ArchiveCache,
-  BlockHeaderTxValidator,
-  DataTxValidator,
-  DoubleSpendTxValidator,
-  GasTxValidator,
-  MetadataTxValidator,
-  PhasesTxValidator,
-  TimestampTxValidator,
-  TxPermittedValidator,
-  TxProofValidator,
-} from '@aztec/p2p';
-import { ProtocolContractAddress, protocolContractsHash } from '@aztec/protocol-contracts';
-import type { ContractDataSource } from '@aztec/stdlib/contract';
-import type { GasFees } from '@aztec/stdlib/gas';
-import type {
-  AllowedElement,
-  ClientProtocolCircuitVerifier,
-  MerkleTreeReadOperations,
-  PublicProcessorValidator,
-} from '@aztec/stdlib/interfaces/server';
-import { DatabasePublicStateSource, type PublicStateSource } from '@aztec/stdlib/trees';
-import { GlobalVariables, type Tx, type TxValidator } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
-
-import { NullifierCache } from './nullifier_cache.js';
-
-export function createValidatorForAcceptingTxs(
-  db: MerkleTreeReadOperations,
-  contractDataSource: ContractDataSource,
-  verifier: ClientProtocolCircuitVerifier | undefined,
-  {
-    l1ChainId,
-    rollupVersion,
-    setupAllowList,
-    gasFees,
-    skipFeeEnforcement,
-    timestamp,
-    blockNumber,
-    txsPermitted,
-  }: {
-    l1ChainId: number;
-    rollupVersion: number;
-    setupAllowList: AllowedElement[];
-    gasFees: GasFees;
-    skipFeeEnforcement?: boolean;
-    timestamp: UInt64;
-    blockNumber: number;
-    txsPermitted: boolean;
-  },
-): TxValidator<Tx> {
-  const validators: TxValidator<Tx>[] = [
-    new TxPermittedValidator(txsPermitted),
-    new DataTxValidator(),
-    new MetadataTxValidator({
-      l1ChainId: new Fr(l1ChainId),
-      rollupVersion: new Fr(rollupVersion),
-      protocolContractsHash,
-      vkTreeRoot: getVKTreeRoot(),
-    }),
-    new TimestampTxValidator({
-      timestamp,
-      blockNumber,
-    }),
-    new DoubleSpendTxValidator(new NullifierCache(db)),
-    new PhasesTxValidator(contractDataSource, setupAllowList, timestamp),
-    new BlockHeaderTxValidator(new ArchiveCache(db)),
-  ];
-
-  if (!skipFeeEnforcement) {
-    validators.push(new GasTxValidator(new DatabasePublicStateSource(db), ProtocolContractAddress.FeeJuice, gasFees));
-  }
-
-  if (verifier) {
-    validators.push(new TxProofValidator(verifier));
-  }
-
-  return new AggregateTxValidator(...validators);
-}
-
-export function createValidatorForBlockBuilding(
-  db: MerkleTreeReadOperations,
-  contractDataSource: ContractDataSource,
-  globalVariables: GlobalVariables,
-  setupAllowList: AllowedElement[],
-): PublicProcessorValidator {
-  const nullifierCache = new NullifierCache(db);
-  const archiveCache = new ArchiveCache(db);
-  const publicStateSource = new DatabasePublicStateSource(db);
-
-  return {
-    preprocessValidator: preprocessValidator(
-      nullifierCache,
-      archiveCache,
-      publicStateSource,
-      contractDataSource,
-      globalVariables,
-      setupAllowList,
-    ),
-    nullifierCache,
-  };
-}
-
-function preprocessValidator(
-  nullifierCache: NullifierCache,
-  archiveCache: ArchiveCache,
-  publicStateSource: PublicStateSource,
-  contractDataSource: ContractDataSource,
-  globalVariables: GlobalVariables,
-  setupAllowList: AllowedElement[],
-): TxValidator<Tx> {
-  // We don't include the TxProofValidator nor the DataTxValidator here because they are already checked by the time we get to block building.
-  return new AggregateTxValidator(
-    new MetadataTxValidator({
-      l1ChainId: globalVariables.chainId,
-      rollupVersion: globalVariables.version,
-      protocolContractsHash,
-      vkTreeRoot: getVKTreeRoot(),
-    }),
-    new TimestampTxValidator({
-      timestamp: globalVariables.timestamp,
-      blockNumber: globalVariables.blockNumber,
-    }),
-    new DoubleSpendTxValidator(nullifierCache),
-    new PhasesTxValidator(contractDataSource, setupAllowList, globalVariables.timestamp),
-    new GasTxValidator(publicStateSource, ProtocolContractAddress.FeeJuice, globalVariables.gasFees),
-    new BlockHeaderTxValidator(archiveCache),
-  );
-}