@aztec/stdlib 0.0.1-commit.d1da697d6 → 0.0.1-commit.d20b825a7

package/src/timetable/index.ts

@@ -25,6 +25,219 @@ export const DEFAULT_L1_PUBLISHING_TIME = 12;
 /** Minimum execution time for building a block in seconds */
 export const MIN_EXECUTION_TIME = 2;
 
+export type CheckpointTimingConfig = {
+  aztecSlotDuration: number;
+  ethereumSlotDuration?: number;
+  blockDuration?: number;
+  checkpointAssembleTime?: number;
+  checkpointInitializationTime?: number;
+  l1PublishingTime?: number;
+  minExecutionTime?: number;
+  p2pPropagationTime?: number;
+  pipelining?: boolean;
+};
+
+export interface CheckpointTiming {
+  readonly aztecSlotDuration: number;
+  readonly blockDuration: number | undefined;
+  readonly checkpointAssembleTime: number;
+  readonly checkpointInitializationTime: number;
+  readonly l1PublishingTime: number;
+  readonly minExecutionTime: number;
+  readonly p2pPropagationTime: number;
+  readonly checkpointFinalizationTime: number;
+  readonly pipeliningAttestationGracePeriod: number;
+  readonly timeReservedAtEnd: number;
+  readonly minimumBuildSlotWork: number;
+  readonly initializeDeadline: number;
+  readonly checkpointAssemblyDeadline: number;
+  readonly checkpointAttestationStartDeadline: number;
+  readonly checkpointAttestationDeadline: number;
+  readonly checkpointPublishingDeadline: number;
+
+  calculateMaxBlocksPerSlot(): number;
+}
+
+export interface PipelinedCheckpointTiming extends CheckpointTiming {
+  readonly proposalWindowIntoTargetSlot: number;
+  readonly attestationWindowIntoTargetSlot: number;
+}
+
+/**
+ * Shared base for checkpoint timing implementations.
+ *
+ * This class owns the common inputs and formulas used by both pipelined and
+ * non-pipelined scheduling. Variant-specific deadline math is delegated to the
+ * concrete subclasses below.
+ */
+abstract class BaseCheckpointTiming implements CheckpointTiming {
+  public readonly aztecSlotDuration: number;
+  public readonly blockDuration: number | undefined;
+  public readonly checkpointAssembleTime: number;
+  public readonly checkpointInitializationTime: number;
+  public readonly l1PublishingTime: number;
+  public readonly minExecutionTime: number;
+  public readonly p2pPropagationTime: number;
+
+  constructor(opts: CheckpointTimingConfig) {
+    this.aztecSlotDuration = opts.aztecSlotDuration;
+    this.blockDuration = opts.blockDuration;
+
+    this.checkpointAssembleTime = opts.checkpointAssembleTime ?? CHECKPOINT_ASSEMBLE_TIME;
+    this.checkpointInitializationTime = opts.checkpointInitializationTime ?? CHECKPOINT_INITIALIZATION_TIME;
+    this.l1PublishingTime = opts.l1PublishingTime ?? DEFAULT_L1_PUBLISHING_TIME;
+    this.minExecutionTime = opts.minExecutionTime ?? MIN_EXECUTION_TIME;
+    this.p2pPropagationTime = opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME;
+  }
+
+  public get checkpointFinalizationTime(): number {
+    // Allow enough time to
+    // - build the checkpoint
+    // - Round-trip over p2p
+    // - Publish to L1
+    return this.checkpointAssembleTime + this.p2pPropagationTime * 2 + this.l1PublishingTime;
+  }
+
+  public get pipeliningAttestationGracePeriod(): number {
+    // Allow enough time to
+    // - build the block
+    // - pass it back over p2p
+    return (this.blockDuration ?? 0) + this.p2pPropagationTime;
+  }
+
+  public abstract get timeReservedAtEnd(): number;
+  public abstract get minimumBuildSlotWork(): number;
+
+  public get initializeDeadline(): number {
+    return this.aztecSlotDuration - this.minimumBuildSlotWork;
+  }
+
+  public abstract get checkpointAssemblyDeadline(): number;
+
+  public get checkpointAttestationStartDeadline(): number {
+    return this.checkpointAssemblyDeadline;
+  }
+
+  public abstract get checkpointAttestationDeadline(): number;
+  public abstract get checkpointPublishingDeadline(): number;
+
+  public calculateMaxBlocksPerSlot(): number {
+    if (!this.blockDuration) {
+      return 1;
+    }
+
+    const timeAvailableForBlocks = this.aztecSlotDuration - this.checkpointInitializationTime - this.timeReservedAtEnd;
+    return Math.floor(timeAvailableForBlocks / this.blockDuration);
+  }
+}
+
+/**
+ * Checkpoint timing model for the non-pipelined sequencer flow.
+ *
+ * In this mode, checkpoint assembly, attestation collection, and L1 publishing
+ * must all complete within the current Aztec slot.
+ */
+class StandardCheckpointTimingModel extends BaseCheckpointTiming {
+  public get timeReservedAtEnd(): number {
+    return (this.blockDuration ?? 0) + this.checkpointFinalizationTime;
+  }
+
+  public get minimumBuildSlotWork(): number {
+    return this.checkpointInitializationTime + this.minExecutionTime * 2 + this.checkpointFinalizationTime;
+  }
+
+  public get checkpointAssemblyDeadline(): number {
+    return this.aztecSlotDuration - this.l1PublishingTime - 2 * this.p2pPropagationTime;
+  }
+
+  public get checkpointAttestationDeadline(): number {
+    return this.aztecSlotDuration - this.l1PublishingTime;
+  }
+
+  public get checkpointPublishingDeadline(): number {
+    return this.aztecSlotDuration - this.l1PublishingTime;
+  }
+}
+
+/**
+ * Checkpoint timing model for proposer pipelining.
+ *
+ * In this mode, the build work still starts in the current slot, but checkpoint
+ * assembly and attestation collection can extend into the target slot. The extra
+ * target-slot window getters are intended for consumers such as P2P validators
+ * that need to validate pipelined messages against wallclock time.
+ */
+class PipelinedCheckpointTimingModel extends BaseCheckpointTiming implements PipelinedCheckpointTiming {
+  public get proposalWindowIntoTargetSlot(): number {
+    // Allow the p2p propagation time to receive a checkpoint proposal from leader
+    return this.p2pPropagationTime;
+  }
+
+  public get attestationWindowIntoTargetSlot(): number {
+    return this.aztecSlotDuration - this.l1PublishingTime;
+  }
+
+  public get timeReservedAtEnd(): number {
+    return this.checkpointAssembleTime + this.p2pPropagationTime;
+  }
+
+  public get minimumBuildSlotWork(): number {
+    return this.checkpointInitializationTime + this.minExecutionTime * 2;
+  }
+
+  public get checkpointAssemblyDeadline(): number {
+    // Allow enough time to
+    // - build all blocks
+    // - receive attestations
+    return this.aztecSlotDuration + this.pipeliningAttestationGracePeriod;
+  }
+
+  public get checkpointAttestationDeadline(): number {
+    // Allowed to be into the next wallclock slot minus the allocated l1 publishing time
+    return this.aztecSlotDuration * 2 - this.l1PublishingTime;
+  }
+
+  public get checkpointPublishingDeadline(): number {
+    // Allowed to be into the next wallclock slot minus the allocated l1 Publishing time
+    return this.aztecSlotDuration * 2 - this.l1PublishingTime;
+  }
+}
+
+/**
+ * Creates a checkpoint timing model for the requested scheduling mode.
+ *
+ * Most callers should use this factory and depend only on the shared
+ * `CheckpointTiming` interface. The returned implementation is selected from
+ * `opts.pipelining`.
+ */
+export function createCheckpointTimingModel(opts: CheckpointTimingConfig): CheckpointTiming {
+  validateCheckpointTimingConfig(opts);
+  const normalizedOpts = normalizeCheckpointTimingConfig(opts);
+
+  const timing = normalizedOpts.pipelining
+    ? new PipelinedCheckpointTimingModel(normalizedOpts)
+    : new StandardCheckpointTimingModel(normalizedOpts);
+  validateCheckpointTimingModel(timing);
+  return timing;
+}
+
+/**
+ * Creates a pipelined checkpoint timing model with target-slot window accessors.
+ *
+ * Use this when the caller specifically needs the pipelined-only timing surface,
+ * such as proposal or attestation acceptance windows into the target slot.
+ */
+export function createPipelinedCheckpointTimingModel(
+  opts: Omit<CheckpointTimingConfig, 'pipelining'>,
+): PipelinedCheckpointTiming {
+  validateCheckpointTimingConfig(opts);
+  const normalizedOpts = normalizeCheckpointTimingConfig(opts);
+
+  const timing = new PipelinedCheckpointTimingModel(normalizedOpts);
+  validateCheckpointTimingModel(timing);
+  return timing;
+}
+
 /**
  * Calculates the maximum number of blocks that can be built in a slot.
  * Used by both the sequencer timetable and p2p gossipsub scoring.
@@ -42,25 +255,92 @@ export function calculateMaxBlocksPerSlot(
     checkpointAssembleTime?: number;
     p2pPropagationTime?: number;
     l1PublishingTime?: number;
+    pipelining?: boolean;
   } = {},
 ): number {
-  if (!blockDurationSec) {
-    return 1; // Single block per slot
+  return createCheckpointTimingModel({
+    aztecSlotDuration: aztecSlotDurationSec,
+    blockDuration: blockDurationSec,
+    checkpointAssembleTime: opts.checkpointAssembleTime,
+    checkpointInitializationTime: opts.checkpointInitializationTime,
+    l1PublishingTime: opts.l1PublishingTime,
+    p2pPropagationTime: opts.p2pPropagationTime,
+    pipelining: opts.pipelining,
+  }).calculateMaxBlocksPerSlot();
+}
+
+function assertNonNegative(name: string, value: number): void {
+  if (value < 0) {
+    throw new Error(`${name} must be non-negative (got ${value})`);
   }
+}
 
-  const initOffset = opts.checkpointInitializationTime ?? CHECKPOINT_INITIALIZATION_TIME;
-  const assembleTime = opts.checkpointAssembleTime ?? CHECKPOINT_ASSEMBLE_TIME;
-  const p2pTime = opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME;
-  const l1Time = opts.l1PublishingTime ?? DEFAULT_L1_PUBLISHING_TIME;
+function validateCheckpointTimingConfig(opts: CheckpointTimingConfig): void {
+  if (opts.aztecSlotDuration <= 0) {
+    throw new Error(`aztecSlotDuration must be positive (got ${opts.aztecSlotDuration})`);
+  }
 
-  // Calculate checkpoint finalization time (assembly + round-trip propagation + L1 publishing)
-  const checkpointFinalizationTime = assembleTime + p2pTime * 2 + l1Time;
+  if (opts.ethereumSlotDuration !== undefined && opts.ethereumSlotDuration <= 0) {
+    throw new Error(`ethereumSlotDuration must be positive when provided (got ${opts.ethereumSlotDuration})`);
+  }
 
-  // Time reserved at end for last sub-slot (validator re-execution) + finalization
-  const timeReservedAtEnd = blockDurationSec + checkpointFinalizationTime;
+  if (opts.blockDuration !== undefined && opts.blockDuration <= 0) {
+    throw new Error(`blockDuration must be positive when provided (got ${opts.blockDuration})`);
+  }
 
-  // Time available for building blocks
-  const timeAvailableForBlocks = aztecSlotDurationSec - initOffset - timeReservedAtEnd;
+  if (opts.minExecutionTime !== undefined && opts.minExecutionTime <= 0) {
+    throw new Error(`minExecutionTime must be positive when provided (got ${opts.minExecutionTime})`);
+  }
 
-  return Math.max(1, Math.floor(timeAvailableForBlocks / blockDurationSec));
+  if (opts.checkpointAssembleTime !== undefined) {
+    assertNonNegative('checkpointAssembleTime', opts.checkpointAssembleTime);
+  }
+  if (opts.checkpointInitializationTime !== undefined) {
+    assertNonNegative('checkpointInitializationTime', opts.checkpointInitializationTime);
+  }
+  if (opts.l1PublishingTime !== undefined) {
+    assertNonNegative('l1PublishingTime', opts.l1PublishingTime);
+  }
+  if (opts.p2pPropagationTime !== undefined) {
+    assertNonNegative('p2pPropagationTime', opts.p2pPropagationTime);
+  }
+}
+
+function normalizeCheckpointTimingConfig(opts: CheckpointTimingConfig): CheckpointTimingConfig {
+  let checkpointAssembleTime = opts.checkpointAssembleTime ?? CHECKPOINT_ASSEMBLE_TIME;
+  let checkpointInitializationTime = opts.checkpointInitializationTime ?? CHECKPOINT_INITIALIZATION_TIME;
+  let minExecutionTime = opts.minExecutionTime ?? MIN_EXECUTION_TIME;
+  let p2pPropagationTime = opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME;
+
+  if (opts.ethereumSlotDuration !== undefined && opts.ethereumSlotDuration < 8) {
+    p2pPropagationTime = 0;
+    checkpointAssembleTime = 0.5;
+    checkpointInitializationTime = 0.5;
+    minExecutionTime = 1;
+  }
+
+  if (opts.blockDuration !== undefined && minExecutionTime > opts.blockDuration) {
+    minExecutionTime = opts.blockDuration;
+  }
+
+  return {
+    ...opts,
+    checkpointAssembleTime,
+    checkpointInitializationTime,
+    minExecutionTime,
+    p2pPropagationTime,
+  };
+}
+
+function validateCheckpointTimingModel(model: CheckpointTiming): void {
+  if (model.blockDuration === undefined) {
+    return;
+  }
+
+  const timeAvailableForBlocks = model.aztecSlotDuration - model.checkpointInitializationTime - model.timeReservedAtEnd;
+  if (timeAvailableForBlocks < model.blockDuration) {
+    throw new Error(
+      `Invalid timing configuration: only ${timeAvailableForBlocks}s available for block building, which is less than one blockDuration (${model.blockDuration}s).`,
+    );
+  }
 }

package/src/trees/nullifier_leaf.ts

@@ -86,6 +86,10 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
     ];
   }
 
+  isEmpty(): boolean {
+    return this.leaf.isEmpty() && this.nextKey.isZero() && this.nextIndex === 0n;
+  }
+
   toFields(): Fr[] {
     return this.toHashInputs().map(buf => Fr.fromBuffer(buf));
   }

package/src/tx/block_header.ts

@@ -172,8 +172,8 @@ export class BlockHeader {
   }
 
   /** Manually set the hash for this block header if already computed */
-  setHash(hashed: Fr) {
-    this._cachedHash = Promise.resolve(new BlockHash(hashed));
+  setHash(hashed: BlockHash) {
+    this._cachedHash = Promise.resolve(hashed);
   }
 
   /** Recomputes the cached hash. Used for testing when header fields are mutated via unfreeze. */

package/src/tx/fee_provider.ts

@@ -0,0 +1,10 @@
+import type { ManaUsageEstimate } from '../gas/fee_math.js';
+import type { GasFees } from '../gas/gas_fees.js';
+
+/** Provides current and predicted fee information for transaction pricing. */
+export interface FeeProvider {
+  /** Returns the current minimum fees for inclusion in the next block. */
+  getCurrentMinFees(): Promise<GasFees>;
+  /** Returns predicted min fees for each slot in the prediction window. */
+  getPredictedMinFees(manaUsage?: ManaUsageEstimate): Promise<GasFees[]>;
+}

package/src/tx/global_variable_builder.ts

@@ -1,31 +1,15 @@
-import type { FeeHeader } from '@aztec/ethereum/contracts';
-import type { CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { SimulationOverridesPlan } from '@aztec/ethereum/contracts';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { SlotNumber } from '@aztec/foundation/schemas';
 
 import type { AztecAddress } from '../aztec-address/index.js';
-import type { GasFees } from '../gas/gas_fees.js';
 import type { UInt32 } from '../types/index.js';
 import type { CheckpointGlobalVariables, GlobalVariables } from './global_variables.js';
 
-/** Fee header fields needed for pipelining overrides. */
-export type ForceProposedFeeHeader = {
-  checkpointNumber: CheckpointNumber;
-  feeHeader: FeeHeader;
-};
-
-/** Options for building checkpoint global variables during pipelining. */
-export type BuildCheckpointGlobalVariablesOpts = {
-  forcePendingCheckpointNumber?: CheckpointNumber;
-  forceProposedFeeHeader?: ForceProposedFeeHeader;
-};
-
 /**
  * Interface for building global variables for Aztec blocks.
  */
 export interface GlobalVariableBuilder {
-  getCurrentMinFees(): Promise<GasFees>;
-
   /**
    * Builds global variables for a given block.
    * @param blockNumber - The block number to build global variables for.
@@ -46,6 +30,6 @@ export interface GlobalVariableBuilder {
     coinbase: EthAddress,
     feeRecipient: AztecAddress,
     slotNumber: SlotNumber,
-    opts?: BuildCheckpointGlobalVariablesOpts,
+    simulationOverridesPlan?: SimulationOverridesPlan,
   ): Promise<CheckpointGlobalVariables>;
 }

package/src/tx/index.ts

@@ -24,6 +24,7 @@ export * from './validator/tx_validator.js';
 export * from './validator/empty_validator.js';
 export * from './validator/error_texts.js';
 export * from './capsule.js';
+export * from './fee_provider.js';
 export * from './global_variable_builder.js';
 export * from './hashed_values.js';
 export * from './indexed_tx_effect.js';

package/src/tx/indexed_tx_effect.ts

@@ -1,5 +1,4 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
@@ -27,7 +26,7 @@ export function serializeIndexedTxEffect(effect: IndexedTxEffect): Buffer {
 export function deserializeIndexedTxEffect(buffer: Buffer): IndexedTxEffect {
   const reader = BufferReader.asReader(buffer);
 
-  const l2BlockHash = new BlockHash(reader.readObject(Fr));
+  const l2BlockHash = BlockHash.fromBuffer(reader);
   const l2BlockNumber = BlockNumber(reader.readNumber());
   const txIndexInBlock = reader.readNumber();
   const data = reader.readObject(TxEffect);

package/src/tx/simulated_tx.ts

@@ -161,7 +161,7 @@ export class TxSimulationResult {
 }
 
 /**
- * Recursively accummulate the return values of a call result and its nested executions,
+ * Recursively accumulate the return values of a call result and its nested executions,
  * so they can be retrieved in order.
  * @param executionResult
  * @returns

package/src/tx/tx.ts

@@ -1,5 +1,5 @@
 import { DA_GAS_PER_FIELD, TX_DA_GAS_OVERHEAD } from '@aztec/constants';
-import { Buffer32 } from '@aztec/foundation/buffer';
+import { type BaseBuffer32, Buffer32 } from '@aztec/foundation/buffer';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ZodFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeArrayOfBufferableToVector, serializeToBuffer } from '@aztec/foundation/serialize';
@@ -64,7 +64,7 @@ export class Tx extends Gossipable {
   // docs:end:tx_class
 
   // Gossipable method
-  override generateP2PMessageIdentifier(): Promise<Buffer32> {
+  override generateP2PMessageIdentifier(): Promise<BaseBuffer32> {
     return Promise.resolve(new Buffer32(this.getTxHash().toBuffer()));
   }
 

package/src/types/shared.ts

@@ -34,13 +34,3 @@ export type UInt64 = bigint;
  * A type alias for a 128-bit unsigned integer.
  */
 export type UInt128 = bigint;
-
-/**
- * CircuitType replaces ComposerType for now. When using Plonk, CircuitType is equivalent to the information of the proving system that will be used
- * to construct a proof. In the future Aztec zk stack, more information must be specified (e.g., the curve over which circuits are  constructed;
- * Plonk vs Honk; zk-SNARK or just SNARK; etc).
- */
-export enum CircuitType {
-  STANDARD = 0,
-  ULTRA = 1,
-}