@aztec/stdlib 1.0.0 → 1.1.2

package/src/contract/interfaces/contract_data_source.ts

@@ -2,6 +2,7 @@ import type { Fr } from '@aztec/foundation/fields';
 
 import type { FunctionSelector } from '../../abi/index.js';
 import type { AztecAddress } from '../../aztec-address/index.js';
+import type { UInt64 } from '../../types/shared.js';
 import type { ContractClassPublic } from './contract_class.js';
 import type { ContractInstanceWithAddress } from './contract_instance.js';
 
@@ -23,9 +24,11 @@ export interface ContractDataSource {
   /**
    * Returns a publicly deployed contract instance given its address.
    * @param address - Address of the deployed contract.
-   * @param blockNumber - Block number at which to retrieve the contract instance. If not provided, the latest block should be used.
+   * @param timestamp - Timestamp at which to retrieve the contract instance. If not provided, the latest block should
+   * be used.
+   * TODO(#15170): Fix the implementations ignoring the timestamp param and make timestamp required.
    */
-  getContract(address: AztecAddress, blockNumber?: number): Promise<ContractInstanceWithAddress | undefined>;
+  getContract(address: AztecAddress, timestamp?: UInt64): Promise<ContractInstanceWithAddress | undefined>;
 
   /**
    * Returns the list of all class ids known.

package/src/contract/interfaces/contract_instance_update.ts

@@ -4,6 +4,7 @@ import { z } from 'zod';
 
 import type { AztecAddress } from '../../aztec-address/index.js';
 import { type ZodFor, schemas } from '../../schemas/index.js';
+import type { UInt64 } from '../../types/shared.js';
 
 /**
  * An update to a contract instance, changing its contract class.
@@ -13,8 +14,8 @@ export interface ContractInstanceUpdate {
   prevContractClassId: Fr;
   /** Identifier of the new contract class for this instance. */
   newContractClassId: Fr;
-  /** The block number where the contract class in use will be the new one */
-  blockOfChange: number;
+  /** The timestamp at which the contract class in use will be the new one */
+  timestampOfChange: UInt64;
 }
 
 export type ContractInstanceUpdateWithAddress = ContractInstanceUpdate & { address: AztecAddress };
@@ -22,7 +23,7 @@ export type ContractInstanceUpdateWithAddress = ContractInstanceUpdate & { addre
 export const ContractInstanceUpdateSchema = z.object({
   prevContractClassId: schemas.Fr,
   newContractClassId: schemas.Fr,
-  blockOfChange: z.number().int().nonnegative(),
+  timestampOfChange: schemas.BigInt,
 }) satisfies ZodFor<ContractInstanceUpdate>;
 
 export const ContractInstanceUpdateWithAddressSchema = ContractInstanceUpdateSchema.and(

package/src/hash/hash.ts

@@ -1,4 +1,5 @@
 import { GeneratorIndex } from '@aztec/constants';
+import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
 import { poseidon2Hash, poseidon2HashWithSeparator, sha256ToField } from '@aztec/foundation/crypto';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -7,11 +8,14 @@ import type { AztecAddress } from '../aztec-address/index.js';
 
 /**
  * Computes a hash of a given verification key.
- * @param vkBuf - The verification key as fields.
+ * @param keyAsFields - The verification key as fields.
  * @returns The hash of the verification key.
  */
-export function hashVK(keyAsFields: Fr[]): Promise<Fr> {
-  return poseidon2Hash(keyAsFields);
+export async function hashVK(keyAsFields: Fr[]): Promise<Fr> {
+  // Should match the implementation in barretenberg/cpp/src/barretenberg/flavor/flavor.hpp > hash()
+  const hash = (await poseidon2Hash(keyAsFields)).toBuffer();
+  // Taking the last 16 bytes (128 bits) of the hash.
+  return new Fr(toBigIntBE(hash.subarray(Fr.SIZE_IN_BYTES - 16)));
 }
 
 /**

package/src/interfaces/archiver.ts

@@ -65,7 +65,7 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   getBytecodeCommitment: z.function().args(schemas.Fr).returns(schemas.Fr),
   getContract: z
     .function()
-    .args(schemas.AztecAddress, optional(schemas.Integer))
+    .args(schemas.AztecAddress, optional(schemas.BigInt))
     .returns(ContractInstanceWithAddressSchema.optional()),
   getContractClassIds: z.function().args().returns(z.array(schemas.Fr)),
   registerContractFunctionSignatures: z.function().args(z.array(z.string())).returns(z.void()),

package/src/interfaces/aztec-node.ts

@@ -407,7 +407,7 @@ export interface AztecNode
   /**
    * Returns true if the transaction is valid for inclusion at the current state. Valid transactions can be
    * made invalid by *other* transactions if e.g. they emit the same nullifiers, or come become invalid
-   * due to e.g. the max_block_number property.
+   * due to e.g. the include_by_timestamp property.
    * @param tx - The transaction to validate for correctness.
    * @param isSimulation - True if the transaction is a simulated one without generated proofs. (Optional)
    * @param skipFeeEnforcement - True if the validation of the fee should be skipped. Useful when the simulation is for estimating fee (Optional)

package/src/interfaces/client.ts

@@ -3,3 +3,4 @@ export * from './aztec-node.js';
 export * from './aztec-node-admin.js';
 export * from './private_kernel_prover.js';
 export * from './get_logs_response.js';
+export * from './api_limit.js';

package/src/interfaces/proving-job.ts

@@ -21,6 +21,7 @@ import { BlockMergeRollupInputs } from '../rollup/block_merge_rollup.js';
 import { BlockRootOrBlockMergePublicInputs } from '../rollup/block_root_or_block_merge_public_inputs.js';
 import { BlockRootRollupInputs, SingleTxBlockRootRollupInputs } from '../rollup/block_root_rollup.js';
 import { EmptyBlockRootRollupInputs } from '../rollup/empty_block_root_rollup_inputs.js';
+import { PaddingBlockRootRollupInputs } from '../rollup/index.js';
 import { MergeRollupInputs } from '../rollup/merge_rollup.js';
 import { PrivateBaseRollupInputs } from '../rollup/private_base_rollup_inputs.js';
 import { PublicBaseRollupInputs } from '../rollup/public_base_rollup_inputs.js';
@@ -87,6 +88,8 @@ export function mapProvingRequestTypeToCircuitName(type: ProvingRequestType): Se
       return 'merge-rollup';
     case ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP:
       return 'empty-block-root-rollup';
+    case ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP:
+      return 'padding-block-root-rollup';
     case ProvingRequestType.BLOCK_ROOT_ROLLUP:
       return 'block-root-rollup';
     case ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP:
@@ -121,6 +124,10 @@ export const ProvingJobInputs = z.discriminatedUnion('type', [
     inputs: SingleTxBlockRootRollupInputs.schema,
   }),
   z.object({ type: z.literal(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP), inputs: EmptyBlockRootRollupInputs.schema }),
+  z.object({
+    type: z.literal(ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP),
+    inputs: PaddingBlockRootRollupInputs.schema,
+  }),
   z.object({ type: z.literal(ProvingRequestType.BLOCK_MERGE_ROLLUP), inputs: BlockMergeRollupInputs.schema }),
   z.object({ type: z.literal(ProvingRequestType.ROOT_ROLLUP), inputs: RootRollupInputs.schema }),
   z.object({ type: z.literal(ProvingRequestType.TUBE_PROOF), inputs: TubeInputs.schema }),
@@ -138,6 +145,8 @@ export function getProvingJobInputClassFor(type: ProvingRequestType) {
       return MergeRollupInputs;
     case ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP:
       return EmptyBlockRootRollupInputs;
+    case ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP:
+      return PaddingBlockRootRollupInputs;
     case ProvingRequestType.BLOCK_ROOT_ROLLUP:
       return BlockRootRollupInputs;
     case ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP:
@@ -167,6 +176,7 @@ export type ProvingJobInputsMap = {
   [ProvingRequestType.PUBLIC_BASE_ROLLUP]: PublicBaseRollupInputs;
   [ProvingRequestType.MERGE_ROLLUP]: MergeRollupInputs;
   [ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP]: EmptyBlockRootRollupInputs;
+  [ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP]: PaddingBlockRootRollupInputs;
   [ProvingRequestType.BLOCK_ROOT_ROLLUP]: BlockRootRollupInputs;
   [ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP]: SingleTxBlockRootRollupInputs;
   [ProvingRequestType.BLOCK_MERGE_ROLLUP]: BlockMergeRollupInputs;
@@ -209,6 +219,13 @@ export const ProvingJobResult = z.discriminatedUnion('type', [
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
+  z.object({
+    type: z.literal(ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      BlockRootOrBlockMergePublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
   z.object({
     type: z.literal(ProvingRequestType.BLOCK_ROOT_ROLLUP),
     result: schemaForPublicInputsAndRecursiveProof(
@@ -266,6 +283,10 @@ export type ProvingJobResultsMap = {
     BlockRootOrBlockMergePublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
+  [ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP]: PublicInputsAndRecursiveProof<
+    BlockRootOrBlockMergePublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
   [ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP]: PublicInputsAndRecursiveProof<
     BlockRootOrBlockMergePublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH

package/src/interfaces/server.ts

@@ -19,3 +19,4 @@ export * from './server_circuit_prover.js';
 export * from './service.js';
 export * from './tx-collector.js';
 export * from './world_state.js';
+export * from './api_limit.js';

package/src/interfaces/server_circuit_prover.ts

@@ -15,6 +15,7 @@ import type { BlockMergeRollupInputs } from '../rollup/block_merge_rollup.js';
 import type { BlockRootOrBlockMergePublicInputs } from '../rollup/block_root_or_block_merge_public_inputs.js';
 import type { BlockRootRollupInputs, SingleTxBlockRootRollupInputs } from '../rollup/block_root_rollup.js';
 import type { EmptyBlockRootRollupInputs } from '../rollup/empty_block_root_rollup_inputs.js';
+import type { PaddingBlockRootRollupInputs } from '../rollup/index.js';
 import type { MergeRollupInputs } from '../rollup/merge_rollup.js';
 import type { PrivateBaseRollupInputs } from '../rollup/private_base_rollup_inputs.js';
 import type { PublicBaseRollupInputs } from '../rollup/public_base_rollup_inputs.js';
@@ -121,6 +122,14 @@ export interface ServerCircuitProver {
     PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   >;
 
+  getPaddingBlockRootRollupProof(
+    input: PaddingBlockRootRollupInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  >;
+
   /**
    * Creates a proof for the given input.
    * @param input - Input to the circuit.

package/src/kernel/hints/rollup_validation_requests.ts

@@ -4,17 +4,15 @@ import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { MaxBlockNumber } from '../../tx/max_block_number.js';
+import { IncludeByTimestamp } from '../../tx/include_by_timestamp.js';
 
 /**
  * Validation requests directed at the rollup, accumulated during the execution of the transaction.
  */
 export class RollupValidationRequests {
   constructor(
-    /**
-     * The largest block number in which this transaction can be included.
-     */
-    public maxBlockNumber: MaxBlockNumber,
+    /** The highest timestamp of a block in which this transaction can still be included. */
+    public includeByTimestamp: IncludeByTimestamp,
   ) {}
 
   getSize() {
@@ -22,7 +20,7 @@ export class RollupValidationRequests {
   }
 
   toBuffer() {
-    return serializeToBuffer(this.maxBlockNumber);
+    return serializeToBuffer(this.includeByTimestamp);
   }
 
   toString() {
@@ -30,12 +28,12 @@ export class RollupValidationRequests {
   }
 
   static getFields(fields: FieldsOf<RollupValidationRequests>) {
-    return [fields.maxBlockNumber] as const;
+    return [fields.includeByTimestamp] as const;
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new RollupValidationRequests(MaxBlockNumber.fromFields(reader));
+    return new RollupValidationRequests(IncludeByTimestamp.fromFields(reader));
   }
 
   toFields(): Fr[] {
@@ -55,7 +53,7 @@ export class RollupValidationRequests {
    */
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new RollupValidationRequests(reader.readObject(MaxBlockNumber));
+    return new RollupValidationRequests(reader.readObject(IncludeByTimestamp));
   }
 
   /**
@@ -68,6 +66,6 @@ export class RollupValidationRequests {
   }
 
   static empty() {
-    return new RollupValidationRequests(MaxBlockNumber.empty());
+    return new RollupValidationRequests(IncludeByTimestamp.empty());
   }
 }

package/src/kernel/private_circuit_public_inputs.ts

@@ -30,7 +30,7 @@ import { PrivateLogData } from '../kernel/private_log_data.js';
 import { CountedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { CallContext } from '../tx/call_context.js';
-import { MaxBlockNumber } from '../tx/max_block_number.js';
+import { IncludeByTimestamp } from '../tx/include_by_timestamp.js';
 import { TxContext } from '../tx/tx_context.js';
 import { ReadRequest } from './hints/read_request.js';
 import { NoteHash } from './note_hash.js';
@@ -64,9 +64,9 @@ export class PrivateCircuitPublicInputs {
      */
     public isFeePayer: boolean,
     /**
-     * The maximum block number in which this transaction can be included and be valid.
+     * The highest timestamp of a block in which the transaction can still be included.
      */
-    public maxBlockNumber: MaxBlockNumber,
+    public includeByTimestamp: IncludeByTimestamp,
     /**
      * Read requests created by the corresponding function call.
      */
@@ -158,7 +158,7 @@ export class PrivateCircuitPublicInputs {
       reader.readObject(Fr),
       reader.readObject(Fr),
       reader.readBoolean(),
-      reader.readObject(MaxBlockNumber),
+      reader.readObject(IncludeByTimestamp),
       reader.readArray(MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, ReadRequest),
       reader.readArray(MAX_NULLIFIER_READ_REQUESTS_PER_CALL, ReadRequest),
       reader.readArray(MAX_KEY_VALIDATION_REQUESTS_PER_CALL, KeyValidationRequestAndGenerator),
@@ -185,7 +185,7 @@ export class PrivateCircuitPublicInputs {
       reader.readField(),
       reader.readField(),
       reader.readBoolean(),
-      reader.readObject(MaxBlockNumber),
+      reader.readObject(IncludeByTimestamp),
       reader.readArray(MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, ReadRequest),
       reader.readArray(MAX_NULLIFIER_READ_REQUESTS_PER_CALL, ReadRequest),
       reader.readArray(MAX_KEY_VALIDATION_REQUESTS_PER_CALL, KeyValidationRequestAndGenerator),
@@ -215,7 +215,7 @@ export class PrivateCircuitPublicInputs {
       Fr.ZERO,
       Fr.ZERO,
       false,
-      MaxBlockNumber.empty(),
+      IncludeByTimestamp.empty(),
       makeTuple(MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, ReadRequest.empty),
       makeTuple(MAX_NULLIFIER_READ_REQUESTS_PER_CALL, ReadRequest.empty),
       makeTuple(MAX_KEY_VALIDATION_REQUESTS_PER_CALL, KeyValidationRequestAndGenerator.empty),
@@ -241,7 +241,7 @@ export class PrivateCircuitPublicInputs {
       this.returnsHash.isZero() &&
       this.minRevertibleSideEffectCounter.isZero() &&
       !this.isFeePayer &&
-      this.maxBlockNumber.isEmpty() &&
+      this.includeByTimestamp.isEmpty() &&
       isEmptyArray(this.noteHashReadRequests) &&
       isEmptyArray(this.nullifierReadRequests) &&
       isEmptyArray(this.keyValidationRequestsAndGenerators) &&
@@ -272,7 +272,7 @@ export class PrivateCircuitPublicInputs {
       fields.returnsHash,
       fields.minRevertibleSideEffectCounter,
       fields.isFeePayer,
-      fields.maxBlockNumber,
+      fields.includeByTimestamp,
       fields.noteHashReadRequests,
       fields.nullifierReadRequests,
       fields.keyValidationRequestsAndGenerators,

package/src/proofs/proving_request_type.ts

@@ -5,6 +5,7 @@ export enum ProvingRequestType {
   PUBLIC_BASE_ROLLUP,
   MERGE_ROLLUP,
   EMPTY_BLOCK_ROOT_ROLLUP,
+  PADDING_BLOCK_ROOT_ROLLUP,
   BLOCK_ROOT_ROLLUP,
   SINGLE_TX_BLOCK_ROOT_ROLLUP,
   BLOCK_MERGE_ROLLUP,

package/src/rollup/base_or_merge_rollup_public_inputs.ts

@@ -5,7 +5,6 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { PartialStateReference } from '../tx/partial_state_reference.js';
-import { RollupTypes } from '../types/shared.js';
 import { BlockConstantData } from './block_constant_data.js';
 
 /**
@@ -13,10 +12,6 @@ import { BlockConstantData } from './block_constant_data.js';
  */
 export class BaseOrMergeRollupPublicInputs {
   constructor(
-    /**
-     * Specifies from which type of rollup circuit these inputs are from.
-     */
-    public rollupType: RollupTypes,
     /**
      * Number of txs in this rollup.
      */
@@ -59,7 +54,6 @@ export class BaseOrMergeRollupPublicInputs {
   /** Returns an empty instance. */
   static empty() {
     return new BaseOrMergeRollupPublicInputs(
-      RollupTypes.Base,
       0,
       BlockConstantData.empty(),
       PartialStateReference.empty(),
@@ -81,7 +75,6 @@ export class BaseOrMergeRollupPublicInputs {
   static fromBuffer(buffer: Buffer | BufferReader): BaseOrMergeRollupPublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new BaseOrMergeRollupPublicInputs(
-      reader.readNumber(),
       reader.readNumber(),
       reader.readObject(BlockConstantData),
       reader.readObject(PartialStateReference),
@@ -100,7 +93,6 @@ export class BaseOrMergeRollupPublicInputs {
    */
   toBuffer() {
     return serializeToBuffer(
-      this.rollupType,
       this.numTxs,
       this.constants,
 

package/src/rollup/empty_block_root_rollup_inputs.ts

@@ -13,7 +13,6 @@ export class EmptyBlockRootRollupInputs {
   constructor(
     public readonly data: BlockRootRollupData,
     public readonly constants: BlockConstantData,
-    public readonly isPadding: boolean,
   ) {}
 
   /**
@@ -47,7 +46,7 @@ export class EmptyBlockRootRollupInputs {
    * @returns An array of fields.
    */
   static getFields(fields: FieldsOf<EmptyBlockRootRollupInputs>) {
-    return [fields.data, fields.constants, fields.isPadding] as const;
+    return [fields.data, fields.constants] as const;
   }
 
   /**
@@ -57,11 +56,7 @@ export class EmptyBlockRootRollupInputs {
    */
   static fromBuffer(buffer: Buffer | BufferReader): EmptyBlockRootRollupInputs {
     const reader = BufferReader.asReader(buffer);
-    return new EmptyBlockRootRollupInputs(
-      reader.readObject(BlockRootRollupData),
-      reader.readObject(BlockConstantData),
-      reader.readBoolean(),
-    );
+    return new EmptyBlockRootRollupInputs(reader.readObject(BlockRootRollupData), reader.readObject(BlockConstantData));
   }
 
   /**

package/src/rollup/index.ts

@@ -8,6 +8,7 @@ export * from './empty_block_root_rollup_inputs.js';
 export * from './epoch_constant_data.js';
 export * from './block_root_rollup.js';
 export * from './merge_rollup.js';
+export * from './padding_block_root_rollup_inputs.js';
 export * from './previous_rollup_block_data.js';
 export * from './previous_rollup_data.js';
 export * from './private_base_rollup_inputs.js';

package/src/rollup/padding_block_root_rollup_inputs.ts

@@ -0,0 +1,47 @@
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { EpochConstantData } from './epoch_constant_data.js';
+
+/**
+ * Inputs of the padding block root rollup circuit.
+ */
+export class PaddingBlockRootRollupInputs {
+  constructor(public readonly constants: EpochConstantData) {}
+
+  static from(fields: FieldsOf<PaddingBlockRootRollupInputs>): PaddingBlockRootRollupInputs {
+    return new PaddingBlockRootRollupInputs(...PaddingBlockRootRollupInputs.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PaddingBlockRootRollupInputs>) {
+    return [fields.constants] as const;
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PaddingBlockRootRollupInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PaddingBlockRootRollupInputs(reader.readObject(EpochConstantData));
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...PaddingBlockRootRollupInputs.getFields(this));
+  }
+
+  static fromString(str: string) {
+    return PaddingBlockRootRollupInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /** Returns a buffer representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(PaddingBlockRootRollupInputs);
+  }
+}

package/src/shared_mutable/scheduled_delay_change.ts

@@ -1,17 +1,17 @@
-import type { UInt32 } from '../types/shared.js';
+import type { UInt64 } from '../types/shared.js';
 
 export class ScheduledDelayChange {
   constructor(
-    public pre: UInt32 | undefined,
-    public post: UInt32 | undefined,
-    public blockOfChange: UInt32,
+    public pre: UInt64 | undefined,
+    public post: UInt64 | undefined,
+    public timestampOfChange: UInt64,
   ) {}
 
   static empty() {
-    return new this(undefined, undefined, 0);
+    return new this(undefined, undefined, 0n);
   }
 
   isEmpty(): boolean {
-    return this.pre === undefined && this.post === undefined && this.blockOfChange === 0;
+    return this.pre === undefined && this.post === undefined && this.timestampOfChange === 0n;
   }
 }

package/src/shared_mutable/scheduled_value_change.ts

@@ -1,10 +1,12 @@
 import { Fr } from '@aztec/foundation/fields';
 
+import type { UInt64 } from '../types/shared.js';
+
 export class ScheduledValueChange {
   constructor(
     public previous: Fr[],
     public post: Fr[],
-    public blockOfChange: number,
+    public timestampOfChange: UInt64,
   ) {
     if (this.previous.length !== this.post.length) {
       throw new Error('Previous and post must have the same length');
@@ -12,15 +14,15 @@ export class ScheduledValueChange {
   }
 
   static empty(valueSize: number) {
-    return new this(Array(valueSize).fill(new Fr(0)), Array(valueSize).fill(new Fr(0)), 0);
+    return new this(Array(valueSize).fill(new Fr(0)), Array(valueSize).fill(new Fr(0)), 0n);
   }
 
   isEmpty(): boolean {
-    return this.previous.every(v => v.isZero()) && this.post.every(v => v.isZero()) && this.blockOfChange === 0;
+    return this.previous.every(v => v.isZero()) && this.post.every(v => v.isZero()) && this.timestampOfChange === 0n;
   }
 
-  getCurrentAt(blockNumber: number) {
-    if (blockNumber < this.blockOfChange) {
+  getCurrentAt(timestamp: UInt64) {
+    if (timestamp < this.timestampOfChange) {
       return this.previous;
     } else {
       return this.post;

package/src/shared_mutable/shared_mutable_values.ts

@@ -22,20 +22,20 @@ export class SharedMutableValues {
     // Extract fields for ScheduledValueChange
     const svcPre = reader.readFieldArray(UPDATES_VALUE_SIZE);
     const svcPost = reader.readFieldArray(UPDATES_VALUE_SIZE);
-    const svcBlockOfChange = firstField & 0xffffffffn;
-    const svc = new ScheduledValueChange(svcPre, svcPost, Number(svcBlockOfChange));
+    const svcTimestampOfChange = firstField & 0xffffffffn;
+    const svc = new ScheduledValueChange(svcPre, svcPost, svcTimestampOfChange);
 
     // Extract fields for ScheduledDelayChange from first field
-    const sdcBlockOfChange = (firstField >> 32n) & 0xffffffffn;
+    const sdcTimestampOfChange = (firstField >> 32n) & 0xffffffffn;
     const sdcIsPostSome = (firstField >> 64n) & 1n;
     const sdcPost = (firstField >> 72n) & 0xffffffffn;
     const sdcIsPreSome = (firstField >> 104n) & 1n;
     const sdcPre = (firstField >> 112n) & 0xffffffffn;
 
     const sdc = new ScheduledDelayChange(
-      sdcIsPreSome ? Number(sdcPre) : undefined,
-      sdcIsPostSome ? Number(sdcPost) : undefined,
-      Number(sdcBlockOfChange),
+      sdcIsPreSome ? sdcPre : undefined,
+      sdcIsPostSome ? sdcPost : undefined,
+      sdcTimestampOfChange,
     );
 
     return new this(svc, sdc);
@@ -43,9 +43,9 @@ export class SharedMutableValues {
 
   toFields(): Fr[] {
     // Pack format matches Noir implementation:
-    // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.block_of_change: u32 | svc.block_of_change: u32 ]
-    let firstField = BigInt(this.svc.blockOfChange);
-    firstField |= BigInt(this.sdc.blockOfChange) << 32n;
+    // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.timestamp_of_change: u32 | svc.timestamp_of_change: u32 ]
+    let firstField = this.svc.timestampOfChange;
+    firstField |= this.sdc.timestampOfChange << 32n;
     firstField |= (this.sdc.post === undefined ? 0n : 1n) << 64n;
     firstField |= BigInt(this.sdc.post || 0) << 72n;
     firstField |= (this.sdc.pre === undefined ? 0n : 1n) << 104n;

package/src/stats/stats.ts

@@ -92,6 +92,7 @@ export type ServerCircuitName =
   | 'block-root-rollup'
   | 'single-tx-block-root-rollup'
   | 'empty-block-root-rollup'
+  | 'padding-block-root-rollup'
   | 'block-merge-rollup'
   | 'root-rollup'
   | 'avm-circuit'

package/src/tests/factories.ts

@@ -165,7 +165,7 @@ import { CallContext } from '../tx/call_context.js';
 import { ContentCommitment } from '../tx/content_commitment.js';
 import { FunctionData } from '../tx/function_data.js';
 import { GlobalVariables } from '../tx/global_variables.js';
-import { MaxBlockNumber } from '../tx/max_block_number.js';
+import { IncludeByTimestamp } from '../tx/include_by_timestamp.js';
 import { PartialStateReference } from '../tx/partial_state_reference.js';
 import { makeProcessedTxFromPrivateOnlyTx, makeProcessedTxFromTxWithPublicCalls } from '../tx/processed_tx.js';
 import { PublicCallRequestWithCalldata } from '../tx/public_call_request_with_calldata.js';
@@ -174,7 +174,7 @@ import { TreeSnapshots } from '../tx/tree_snapshots.js';
 import { TxConstantData } from '../tx/tx_constant_data.js';
 import { TxContext } from '../tx/tx_context.js';
 import { TxRequest } from '../tx/tx_request.js';
-import { RollupTypes, Vector } from '../types/index.js';
+import { Vector } from '../types/index.js';
 import { VkData } from '../vks/index.js';
 import { VerificationKey, VerificationKeyAsFields, VerificationKeyData } from '../vks/verification_key.js';
 import { mockTx } from './mocks.js';
@@ -308,7 +308,7 @@ export function makeContractStorageRead(seed = 1): ContractStorageRead {
 }
 
 export function makeRollupValidationRequests(seed = 1) {
-  return new RollupValidationRequests(new MaxBlockNumber(true, seed + 0x31415));
+  return new RollupValidationRequests(new IncludeByTimestamp(true, BigInt(seed + 0x31415)));
 }
 
 function makeTxConstantData(seed = 1) {
@@ -567,7 +567,7 @@ export function makeTxRequest(seed = 1): TxRequest {
  */
 export function makePrivateCircuitPublicInputs(seed = 0): PrivateCircuitPublicInputs {
   return PrivateCircuitPublicInputs.from({
-    maxBlockNumber: new MaxBlockNumber(true, seed + 0x31415),
+    includeByTimestamp: new IncludeByTimestamp(true, BigInt(seed + 0x31415)),
     callContext: makeCallContext(seed, { isStaticCall: true }),
     argsHash: fr(seed + 0x100),
     returnsHash: fr(seed + 0x200),
@@ -684,7 +684,6 @@ export function makeBaseOrMergeRollupPublicInputs(
   globalVariables: GlobalVariables | undefined = undefined,
 ): BaseOrMergeRollupPublicInputs {
   return new BaseOrMergeRollupPublicInputs(
-    RollupTypes.Base,
     1,
     makeBlockConstantData(seed + 0x200, globalVariables),
     makePartialStateReference(seed + 0x300),
@@ -833,7 +832,6 @@ export function makeEmptyBlockRootRollupInputs(
   return new EmptyBlockRootRollupInputs(
     makeBlockRootRollupData(seed + 0x1000),
     makeBlockConstantData(0x2500, globalVariables),
-    true,
   );
 }