@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.d1f2d6c

package/src/contract/contract_instance.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 

package/src/contract/contract_instance_update.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 

package/src/contract/deployment_info.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { CompleteAddress } from './complete_address.js';
 

package/src/contract/index.ts

@@ -1,10 +1,9 @@
 export * from './artifact_hash.js';
 export * from './contract_address.js';
 export * from './contract_class.js';
-export * from './contract_class_metadata.js';
 export * from './contract_class_id.js';
+export * from './contract_deployment_data.js';
 export * from './contract_instance.js';
-export * from './contract_metadata.js';
 export * from './contract_instance_update.js';
 export * from './private_function.js';
 export * from './private_function_membership_proof.js';

package/src/contract/interfaces/contract_class.ts

@@ -1,5 +1,5 @@
-import type { Fr } from '@aztec/foundation/fields';
-import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { schemas, zodFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
@@ -35,10 +35,12 @@ export interface PrivateFunction {
   vkHash: Fr;
 }
 
-const PrivateFunctionSchema = z.object({
-  selector: FunctionSelector.schema,
-  vkHash: schemas.Fr,
-}) satisfies ZodFor<PrivateFunction>;
+const PrivateFunctionSchema = zodFor<PrivateFunction>()(
+  z.object({
+    selector: FunctionSelector.schema,
+    vkHash: schemas.Fr,
+  }),
+);
 
 /** Private function definition with executable bytecode. */
 export interface ExecutablePrivateFunction extends PrivateFunction {
@@ -46,9 +48,9 @@ export interface ExecutablePrivateFunction extends PrivateFunction {
   bytecode: Buffer;
 }
 
-const ExecutablePrivateFunctionSchema = PrivateFunctionSchema.and(
-  z.object({ bytecode: schemas.Buffer }),
-) satisfies ZodFor<ExecutablePrivateFunction>;
+const ExecutablePrivateFunctionSchema = zodFor<ExecutablePrivateFunction>()(
+  PrivateFunctionSchema.and(z.object({ bytecode: schemas.Buffer })),
+);
 
 /** Utility function definition. */
 export interface UtilityFunction {
@@ -58,11 +60,12 @@ export interface UtilityFunction {
   bytecode: Buffer;
 }
 
-const UtilityFunctionSchema = z.object({
-  /** lala */
-  selector: FunctionSelector.schema,
-  bytecode: schemas.Buffer,
-}) satisfies ZodFor<UtilityFunction>;
+const UtilityFunctionSchema = zodFor<UtilityFunction>()(
+  z.object({
+    selector: FunctionSelector.schema,
+    bytecode: schemas.Buffer,
+  }),
+);
 
 /** Sibling paths and sibling commitments for proving membership of a private function within a contract class. */
 export type PrivateFunctionMembershipProof = {
@@ -75,15 +78,17 @@ export type PrivateFunctionMembershipProof = {
   artifactTreeLeafIndex: number;
 };
 
-const PrivateFunctionMembershipProofSchema = z.object({
-  artifactMetadataHash: schemas.Fr,
-  functionMetadataHash: schemas.Fr,
-  utilityFunctionsTreeRoot: schemas.Fr,
-  privateFunctionTreeSiblingPath: z.array(schemas.Fr),
-  privateFunctionTreeLeafIndex: schemas.Integer,
-  artifactTreeSiblingPath: z.array(schemas.Fr),
-  artifactTreeLeafIndex: schemas.Integer,
-}) satisfies ZodFor<PrivateFunctionMembershipProof>;
+const PrivateFunctionMembershipProofSchema = zodFor<PrivateFunctionMembershipProof>()(
+  z.object({
+    artifactMetadataHash: schemas.Fr,
+    functionMetadataHash: schemas.Fr,
+    utilityFunctionsTreeRoot: schemas.Fr,
+    privateFunctionTreeSiblingPath: z.array(schemas.Fr),
+    privateFunctionTreeLeafIndex: schemas.Integer,
+    artifactTreeSiblingPath: z.array(schemas.Fr),
+    artifactTreeLeafIndex: schemas.Integer,
+  }),
+);
 
 /** A private function with a membership proof. */
 export type ExecutablePrivateFunctionWithMembershipProof = ExecutablePrivateFunction & PrivateFunctionMembershipProof;
@@ -97,23 +102,27 @@ export type UtilityFunctionMembershipProof = {
   artifactTreeLeafIndex: number;
 };
 
-const UtilityFunctionMembershipProofSchema = z.object({
-  artifactMetadataHash: schemas.Fr,
-  functionMetadataHash: schemas.Fr,
-  privateFunctionsArtifactTreeRoot: schemas.Fr,
-  artifactTreeSiblingPath: z.array(schemas.Fr),
-  artifactTreeLeafIndex: schemas.Integer,
-}) satisfies ZodFor<UtilityFunctionMembershipProof>;
+const UtilityFunctionMembershipProofSchema = zodFor<UtilityFunctionMembershipProof>()(
+  z.object({
+    artifactMetadataHash: schemas.Fr,
+    functionMetadataHash: schemas.Fr,
+    privateFunctionsArtifactTreeRoot: schemas.Fr,
+    artifactTreeSiblingPath: z.array(schemas.Fr),
+    artifactTreeLeafIndex: schemas.Integer,
+  }),
+);
 
 /** A utility function with a membership proof. */
 export type UtilityFunctionWithMembershipProof = UtilityFunction & UtilityFunctionMembershipProof;
 
-export const ContractClassSchema = z.object({
-  version: z.literal(VERSION),
-  artifactHash: schemas.Fr,
-  privateFunctions: z.array(PrivateFunctionSchema),
-  packedBytecode: schemas.Buffer,
-}) satisfies ZodFor<ContractClass>;
+export const ContractClassSchema = zodFor<ContractClass>()(
+  z.object({
+    version: z.literal(VERSION),
+    artifactHash: schemas.Fr,
+    privateFunctions: z.array(PrivateFunctionSchema),
+    packedBytecode: schemas.Buffer,
+  }),
+);
 
 /** Commitments to fields of a contract class. */
 interface ContractClassCommitments {
@@ -128,9 +137,11 @@ interface ContractClassCommitments {
 /** A contract class with its precomputed id. */
 export type ContractClassWithId = ContractClass & Pick<ContractClassCommitments, 'id'>;
 
-export const ContractClassWithIdSchema = ContractClassSchema.extend({
-  id: schemas.Fr,
-}) satisfies ZodFor<ContractClassWithId>;
+export const ContractClassWithIdSchema = zodFor<ContractClassWithId>()(
+  ContractClassSchema.extend({
+    id: schemas.Fr,
+  }),
+);
 
 /** A contract class with public bytecode information, and optional private and utility functions. */
 export type ContractClassPublic = {
@@ -142,14 +153,34 @@ export type ContractClassPublic = {
 export type ContractClassPublicWithCommitment = ContractClassPublic &
   Pick<ContractClassCommitments, 'publicBytecodeCommitment'>;
 
-export const ContractClassPublicSchema = z
-  .object({
-    id: schemas.Fr,
-    privateFunctionsRoot: schemas.Fr,
-    privateFunctions: z.array(ExecutablePrivateFunctionSchema.and(PrivateFunctionMembershipProofSchema)),
-    utilityFunctions: z.array(UtilityFunctionSchema.and(UtilityFunctionMembershipProofSchema)),
-  })
-  .and(ContractClassSchema.omit({ privateFunctions: true })) satisfies ZodFor<ContractClassPublic>;
+export const ContractClassPublicSchema = zodFor<ContractClassPublic>()(
+  z
+    .object({
+      id: schemas.Fr,
+      privateFunctionsRoot: schemas.Fr,
+      privateFunctions: z.array(ExecutablePrivateFunctionSchema.and(PrivateFunctionMembershipProofSchema)),
+      utilityFunctions: z.array(UtilityFunctionSchema.and(UtilityFunctionMembershipProofSchema)),
+    })
+    .and(ContractClassSchema.omit({ privateFunctions: true })),
+);
 
 /** The contract class with the block it was initially deployed at */
 export type ContractClassPublicWithBlockNumber = { l2BlockNumber: number } & ContractClassPublic;
+
+/**
+ * Creates a ContractClassPublic from a plain object without Zod validation.
+ * Suitable for deserializing trusted data (e.g., from C++ via MessagePack).
+ * Note: privateFunctions and utilityFunctions are set to empty arrays since
+ * C++ does not provide them.
+ */
+export function contractClassPublicFromPlainObject(obj: any): ContractClassPublic {
+  return {
+    id: Fr.fromPlainObject(obj.id),
+    version: 1,
+    artifactHash: Fr.fromPlainObject(obj.artifactHash),
+    privateFunctionsRoot: Fr.fromPlainObject(obj.privateFunctionsRoot),
+    privateFunctions: [],
+    utilityFunctions: [],
+    packedBytecode: obj.packedBytecode instanceof Buffer ? obj.packedBytecode : Buffer.from(obj.packedBytecode),
+  };
+}

package/src/contract/interfaces/contract_data_source.ts

@@ -1,4 +1,5 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { FunctionSelector } from '../../abi/index.js';
 import type { AztecAddress } from '../../aztec-address/index.js';
@@ -11,7 +12,7 @@ export interface ContractDataSource {
    * Gets the number of the latest L2 block processed by the implementation.
    * @returns The number of the latest L2 block processed by the implementation.
    */
-  getBlockNumber(): Promise<number>;
+  getBlockNumber(): Promise<BlockNumber>;
 
   /**
    * Returns the contract class for a given contract class id, or undefined if not found.

package/src/contract/interfaces/contract_instance.ts

@@ -1,10 +1,10 @@
-import type { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import { z } from 'zod';
 
-import type { AztecAddress } from '../../aztec-address/index.js';
+import { AztecAddress } from '../../aztec-address/index.js';
 import { PublicKeys } from '../../keys/public_keys.js';
-import { type ZodFor, schemas } from '../../schemas/index.js';
+import { schemas, zodFor } from '../../schemas/index.js';
 
 const VERSION = 1 as const;
 
@@ -32,16 +32,48 @@ export interface ContractInstance {
 
 export type ContractInstanceWithAddress = ContractInstance & { address: AztecAddress };
 
-export const ContractInstanceSchema = z.object({
-  version: z.literal(VERSION),
-  salt: schemas.Fr,
-  deployer: schemas.AztecAddress,
-  currentContractClassId: schemas.Fr,
-  originalContractClassId: schemas.Fr,
-  initializationHash: schemas.Fr,
-  publicKeys: PublicKeys.schema,
-}) satisfies ZodFor<ContractInstance>;
-
-export const ContractInstanceWithAddressSchema = ContractInstanceSchema.and(
-  z.object({ address: schemas.AztecAddress }),
-) satisfies ZodFor<ContractInstanceWithAddress>;
+export const ContractInstanceSchema = zodFor<ContractInstance>()(
+  z.object({
+    version: z.literal(VERSION),
+    salt: schemas.Fr,
+    deployer: schemas.AztecAddress,
+    currentContractClassId: schemas.Fr,
+    originalContractClassId: schemas.Fr,
+    initializationHash: schemas.Fr,
+    publicKeys: PublicKeys.schema,
+  }),
+);
+
+export const ContractInstanceWithAddressSchema = zodFor<ContractInstanceWithAddress>()(
+  ContractInstanceSchema.and(z.object({ address: schemas.AztecAddress })),
+);
+
+/**
+ * Creates a ContractInstance from a plain object without Zod validation.
+ * Suitable for deserializing trusted data (e.g., from C++ via MessagePack).
+ */
+export function contractInstanceFromPlainObject(obj: any): ContractInstance {
+  return {
+    version: 1,
+    salt: Fr.fromPlainObject(obj.salt),
+    deployer: AztecAddress.fromPlainObject(obj.deployer),
+    currentContractClassId: Fr.fromPlainObject(obj.currentContractClassId),
+    originalContractClassId: Fr.fromPlainObject(obj.originalContractClassId),
+    initializationHash: Fr.fromPlainObject(obj.initializationHash),
+    publicKeys: PublicKeys.fromPlainObject(obj.publicKeys),
+  };
+}
+
+/**
+ * Creates a ContractInstanceWithAddress from a plain object without Zod validation.
+ * Suitable for deserializing trusted data (e.g., from C++ via MessagePack).
+ */
+export function contractInstanceWithAddressFromPlainObject(
+  address: AztecAddress,
+  obj: any,
+): ContractInstanceWithAddress {
+  return {
+    ...contractInstanceFromPlainObject(obj),
+    address,
+  };
+}

package/src/contract/interfaces/contract_instance_update.ts

@@ -1,9 +1,9 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import { z } from 'zod';
 
 import type { AztecAddress } from '../../aztec-address/index.js';
-import { type ZodFor, schemas } from '../../schemas/index.js';
+import { schemas, zodFor } from '../../schemas/index.js';
 import type { UInt64 } from '../../types/shared.js';
 
 /**
@@ -20,12 +20,14 @@ export interface ContractInstanceUpdate {
 
 export type ContractInstanceUpdateWithAddress = ContractInstanceUpdate & { address: AztecAddress };
 
-export const ContractInstanceUpdateSchema = z.object({
-  prevContractClassId: schemas.Fr,
-  newContractClassId: schemas.Fr,
-  timestampOfChange: schemas.BigInt,
-}) satisfies ZodFor<ContractInstanceUpdate>;
+export const ContractInstanceUpdateSchema = zodFor<ContractInstanceUpdate>()(
+  z.object({
+    prevContractClassId: schemas.Fr,
+    newContractClassId: schemas.Fr,
+    timestampOfChange: schemas.BigInt,
+  }),
+);
 
-export const ContractInstanceUpdateWithAddressSchema = ContractInstanceUpdateSchema.and(
-  z.object({ address: schemas.AztecAddress }),
-) satisfies ZodFor<ContractInstanceUpdateWithAddress>;
+export const ContractInstanceUpdateWithAddressSchema = zodFor<ContractInstanceUpdateWithAddress>()(
+  ContractInstanceUpdateSchema.and(z.object({ address: schemas.AztecAddress })),
+);

package/src/contract/partial_address.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 /**
  * A type which along with public key forms a preimage of a contract address. See the link below for more details

package/src/contract/private_function.ts

@@ -1,6 +1,6 @@
 import { FUNCTION_TREE_HEIGHT, GeneratorIndex } from '@aztec/constants';
-import { pedersenHash, poseidon2Hash, poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { poseidon2Hash, poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type MerkleTree, MerkleTreeCalculator } from '@aztec/foundation/trees';
 
 import type { PrivateFunction } from './interfaces/contract_class.js';
@@ -37,7 +37,7 @@ export async function computePrivateFunctionLeaf(fn: PrivateFunction): Promise<B
 async function getPrivateFunctionTreeCalculator(): Promise<MerkleTreeCalculator> {
   if (!privateFunctionTreeCalculator) {
     const functionTreeZeroLeaf = (
-      await pedersenHash(new Array(PRIVATE_FUNCTION_SIZE).fill(0))
+      await poseidon2Hash(new Array(PRIVATE_FUNCTION_SIZE).fill(0))
     ).toBuffer() as Buffer<ArrayBuffer>;
     privateFunctionTreeCalculator = await MerkleTreeCalculator.create(
       FUNCTION_TREE_HEIGHT,

package/src/contract/private_function_membership_proof.ts

@@ -1,5 +1,5 @@
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { computeRootFromSiblingPath } from '@aztec/foundation/trees';
 
@@ -101,7 +101,7 @@ export async function createPrivateFunctionMembershipProof(
  * // Compute function leaf and assert it belongs to the private functions tree
  * function_leaf = pedersen([selector as Field, vk_hash], GENERATOR__FUNCTION_LEAF)
  * computed_private_function_tree_root = compute_root(function_leaf, private_function_tree_sibling_path)
- * assert computed_private_function_tree_root == contract_class.private_function_root
+ * assert computed_private_function_tree_root == contract_class.private_functions_root
  *
  * // Compute artifact leaf and assert it belongs to the artifact
  * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))

package/src/contract/utility_function_membership_proof.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { computeRootFromSiblingPath } from '@aztec/foundation/trees';
 

package/src/delayed_public_mutable/delayed_public_mutable_values.ts

@@ -1,6 +1,6 @@
 import { UPDATES_VALUE_SIZE } from '@aztec/constants';
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { ScheduledDelayChange } from './scheduled_delay_change.js';
@@ -68,23 +68,22 @@ export class DelayedPublicMutableValues {
   }
 
   static async readFromTree(delayedPublicMutableSlot: Fr, readStorage: (storageSlot: Fr) => Promise<Fr>) {
-    const fields = [];
-    for (let i = 0; i < DELAYED_PUBLIC_MUTABLE_VALUES_LEN; i++) {
-      fields.push(await readStorage(delayedPublicMutableSlot.add(new Fr(i))));
-    }
-    return DelayedPublicMutableValues.fromFields(fields);
+    const fieldPromises = Array.from({ length: DELAYED_PUBLIC_MUTABLE_VALUES_LEN }).map((_, i) =>
+      readStorage(delayedPublicMutableSlot.add(new Fr(i))),
+    );
+    return DelayedPublicMutableValues.fromFields(await Promise.all(fieldPromises));
   }
 
   isEmpty(): boolean {
     return this.svc.isEmpty() && this.sdc.isEmpty();
   }
 
-  async writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
-    const fields = this.toFields();
+  writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
+    const fieldPromises = this.toFields().map((field, i) =>
+      storageWrite(delayedPublicMutableSlot.add(new Fr(i)), field),
+    );
 
-    for (let i = 0; i < fields.length; i++) {
-      await storageWrite(delayedPublicMutableSlot.add(new Fr(i)), fields[i]);
-    }
+    return Promise.all(fieldPromises);
   }
 
   async hash(): Promise<Fr> {

package/src/delayed_public_mutable/delayed_public_mutable_values_with_hash.ts

@@ -1,5 +1,5 @@
 import { UPDATED_CLASS_IDS_SLOT } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 import { deriveStorageSlotInMap } from '../hash/map_slot.js';

package/src/delayed_public_mutable/scheduled_value_change.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { UInt64 } from '../types/shared.js';
 

package/src/deserialization/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Constants for deserialization bounds checking.
+ * These constants define maximum allowed sizes during deserialization
+ * to prevent DoS attacks via maliciously crafted messages.
+ */
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB } from '@aztec/constants';
+
+/** Max transactions per block for deserialization validation */
+export const MAX_TXS_PER_BLOCK = 2 ** 16;
+
+/** Max committee size - theoretical max from bitmap design (256 bytes × 8 bits) */
+export const MAX_COMMITTEE_SIZE = 2048;
+
+/** Max blocks per checkpoint */
+export const MAX_BLOCKS_PER_CHECKPOINT = 72;
+
+/** Max tx effects per body (based on blob capacity per checkpoint) */
+export const MAX_TX_EFFECTS_PER_BODY = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB;
+
+/** Max block hash string length (hex: 0x + 64 chars, with generous headroom) */
+export const MAX_BLOCK_HASH_STRING_LENGTH = 128;

package/src/epoch-helpers/index.ts

@@ -1,6 +1,8 @@
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+
 import { z } from 'zod';
 
-import { type ZodFor, schemas } from '../schemas/index.js';
+import { schemas, zodFor } from '../schemas/index.js';
 
 export type L1RollupConstants = {
   l1StartBlock: bigint;
@@ -20,48 +22,55 @@ export const EmptyL1RollupConstants: L1RollupConstants = {
   proofSubmissionEpochs: 1,
 };
 
-export const L1RollupConstantsSchema = z.object({
-  l1StartBlock: schemas.BigInt,
-  l1GenesisTime: schemas.BigInt,
-  slotDuration: z.number(),
-  epochDuration: z.number(),
-  ethereumSlotDuration: z.number(),
-  proofSubmissionEpochs: z.number(),
-}) satisfies ZodFor<L1RollupConstants>;
+export const L1RollupConstantsSchema = zodFor<L1RollupConstants>()(
+  z.object({
+    l1StartBlock: schemas.BigInt,
+    l1GenesisTime: schemas.BigInt,
+    slotDuration: z.number(),
+    epochDuration: z.number(),
+    ethereumSlotDuration: z.number(),
+    proofSubmissionEpochs: z.number(),
+  }),
+);
 
 /** Returns the timestamp for a given L2 slot. */
 export function getTimestampForSlot(
-  slot: bigint,
+  slot: SlotNumber,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>,
 ) {
-  return constants.l1GenesisTime + slot * BigInt(constants.slotDuration);
+  return constants.l1GenesisTime + BigInt(slot) * BigInt(constants.slotDuration);
 }
 
 /** Returns the slot number for a given timestamp. */
-export function getSlotAtTimestamp(ts: bigint, constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>) {
-  return ts < constants.l1GenesisTime ? 0n : (ts - constants.l1GenesisTime) / BigInt(constants.slotDuration);
+export function getSlotAtTimestamp(
+  ts: bigint,
+  constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>,
+): SlotNumber {
+  return ts < constants.l1GenesisTime
+    ? SlotNumber.ZERO
+    : SlotNumber.fromBigInt((ts - constants.l1GenesisTime) / BigInt(constants.slotDuration));
 }
 
 /** Returns the epoch number for a given timestamp. */
 export function getEpochNumberAtTimestamp(
   ts: bigint,
   constants: Pick<L1RollupConstants, 'epochDuration' | 'slotDuration' | 'l1GenesisTime'>,
-) {
+): EpochNumber {
   return getEpochAtSlot(getSlotAtTimestamp(ts, constants), constants);
 }
 
 /** Returns the epoch number for a given slot. */
-export function getEpochAtSlot(slot: bigint, constants: Pick<L1RollupConstants, 'epochDuration'>) {
-  return slot / BigInt(constants.epochDuration);
+export function getEpochAtSlot(slot: SlotNumber, constants: Pick<L1RollupConstants, 'epochDuration'>): EpochNumber {
+  return EpochNumber.fromBigInt(BigInt(slot) / BigInt(constants.epochDuration));
 }
 
 /** Returns the range of L2 slots (inclusive) for a given epoch number. */
 export function getSlotRangeForEpoch(
-  epochNumber: bigint,
+  epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'epochDuration'>,
-): [bigint, bigint] {
-  const startSlot = epochNumber * BigInt(constants.epochDuration);
-  return [startSlot, startSlot + BigInt(constants.epochDuration) - 1n];
+): [SlotNumber, SlotNumber] {
+  const startSlot = SlotNumber(Number(epochNumber) * constants.epochDuration);
+  return [startSlot, SlotNumber(startSlot + constants.epochDuration - 1)];
 }
 
 /**
@@ -69,15 +78,15 @@ export function getSlotRangeForEpoch(
  * Note that the endTimestamp is the start timestamp of the last L1 slot for the epoch.
  */
 export function getTimestampRangeForEpoch(
-  epochNumber: bigint,
+  epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration' | 'ethereumSlotDuration'>,
 ): [bigint, bigint] {
   const [startSlot, endSlot] = getSlotRangeForEpoch(epochNumber, constants);
   const ethereumSlotsPerL2Slot = constants.slotDuration / constants.ethereumSlotDuration;
   return [
-    constants.l1GenesisTime + startSlot * BigInt(constants.slotDuration),
+    constants.l1GenesisTime + BigInt(startSlot) * BigInt(constants.slotDuration),
     constants.l1GenesisTime +
-      endSlot * BigInt(constants.slotDuration) +
+      BigInt(endSlot) * BigInt(constants.slotDuration) +
       BigInt((ethereumSlotsPerL2Slot - 1) * constants.ethereumSlotDuration),
   ];
 }
@@ -86,7 +95,7 @@ export function getTimestampRangeForEpoch(
  * Returns the start timestamp for a given epoch number.
  */
 export function getStartTimestampForEpoch(
-  epochNumber: bigint,
+  epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration'>,
 ) {
   const [startSlot] = getSlotRangeForEpoch(epochNumber, constants);
@@ -98,10 +107,10 @@ export function getStartTimestampForEpoch(
  * See l1-contracts/src/core/libraries/TimeLib.sol
  */
 export function getProofSubmissionDeadlineEpoch(
-  epochNumber: bigint,
+  epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'proofSubmissionEpochs'>,
-) {
-  return epochNumber + BigInt(constants.proofSubmissionEpochs + 1);
+): EpochNumber {
+  return EpochNumber(epochNumber + constants.proofSubmissionEpochs + 1);
 }
 
 /**
@@ -109,7 +118,7 @@ export function getProofSubmissionDeadlineEpoch(
  * Computed as the start of the given epoch plus the proof submission window.
  */
 export function getProofSubmissionDeadlineTimestamp(
-  epochNumber: bigint,
+  epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration' | 'proofSubmissionEpochs'>,
 ) {
   // See l1-contracts/src/core/libraries/TimeLib.sol:
@@ -121,8 +130,8 @@ export function getProofSubmissionDeadlineTimestamp(
 
 /** Returns the timestamp to start building a block for a given L2 slot. Computed as the start timestamp of the slot minus one L1 slot duration. */
 export function getSlotStartBuildTimestamp(
-  slotNumber: number | bigint,
+  slotNumber: SlotNumber,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'ethereumSlotDuration'>,
 ): number {
-  return Number(constants.l1GenesisTime) + Number(slotNumber) * constants.slotDuration - constants.ethereumSlotDuration;
+  return Number(constants.l1GenesisTime) + slotNumber * constants.slotDuration - constants.ethereumSlotDuration;
 }

package/src/errors/simulation_error.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import { z } from 'zod';
 

package/src/fees/transaction_fee.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import { strict as assert } from 'assert';