@aztec/stdlib 3.0.0-nightly.20251127 → 3.0.0-nightly.20251201.2

package/src/kernel/private_call_data.ts

@@ -1,12 +1,27 @@
-import { FUNCTION_TREE_HEIGHT, PUBLIC_DATA_TREE_HEIGHT, UPDATES_VALUE_SIZE } from '@aztec/constants';
+import {
+  FUNCTION_TREE_HEIGHT,
+  MAX_CONTRACT_CLASS_LOGS_PER_CALL,
+  MAX_ENQUEUED_CALLS_PER_CALL,
+  MAX_L2_TO_L1_MSGS_PER_CALL,
+  MAX_NOTE_HASHES_PER_CALL,
+  MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+  MAX_NULLIFIERS_PER_CALL,
+  MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
+  MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,
+  MAX_PRIVATE_LOGS_PER_CALL,
+  PUBLIC_DATA_TREE_HEIGHT,
+  TOTAL_COUNTED_SIDE_EFFECTS_PER_CALL,
+  UPDATES_VALUE_SIZE,
+} from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { DelayedPublicMutableValues } from '../delayed_public_mutable/delayed_public_mutable_values.js';
 import { PublicKeys } from '../keys/public_keys.js';
 import { PublicDataTreeLeafPreimage } from '../trees/index.js';
+import type { UInt32 } from '../types/shared.js';
 import { VerificationKeyAsFields } from '../vks/verification_key.js';
 import { PrivateCircuitPublicInputs } from './private_circuit_public_inputs.js';
 
@@ -29,6 +44,11 @@ export class PrivateCallData {
      * Hints for the validation of the vk
      */
     public verificationKeyHints: PrivateVerificationKeyHints,
+
+    /**
+     * Hints for validating the uniqueness of the side effects.
+     */
+    public sideEffectUniquenessHints: SideEffectUniquenessHints,
   ) {}
 
   /**
@@ -37,7 +57,7 @@ export class PrivateCallData {
    * @returns The array.
    */
   static getFields(fields: FieldsOf<PrivateCallData>) {
-    return [fields.publicInputs, fields.vk, fields.verificationKeyHints] as const;
+    return [fields.publicInputs, fields.vk, fields.verificationKeyHints, fields.sideEffectUniquenessHints] as const;
   }
 
   static from(fields: FieldsOf<PrivateCallData>): PrivateCallData {
@@ -63,6 +83,7 @@ export class PrivateCallData {
       reader.readObject(PrivateCircuitPublicInputs),
       reader.readObject(VerificationKeyAsFields),
       reader.readObject(PrivateVerificationKeyHints),
+      reader.readObject(SideEffectUniquenessHints),
     );
   }
 }
@@ -180,3 +201,109 @@ export class UpdatedClassIdHints {
     );
   }
 }
+
+export class SideEffectUniquenessHints {
+  constructor(
+    public sideEffectRanges: Tuple<SideEffectCounterRange, typeof TOTAL_COUNTED_SIDE_EFFECTS_PER_CALL>,
+    public noteHashReadRequestIndices: Tuple<UInt32, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,
+    public nullifierReadRequestIndices: Tuple<UInt32, typeof MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,
+    public noteHashesIndices: Tuple<UInt32, typeof MAX_NOTE_HASHES_PER_CALL>,
+    public nullifiersIndices: Tuple<UInt32, typeof MAX_NULLIFIERS_PER_CALL>,
+    public privateCallRequestsIndices: Tuple<UInt32, typeof MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,
+    public publicCallRequestsIndices: Tuple<UInt32, typeof MAX_ENQUEUED_CALLS_PER_CALL>,
+    public l2ToL1MsgsIndices: Tuple<UInt32, typeof MAX_L2_TO_L1_MSGS_PER_CALL>,
+    public privateLogsIndices: Tuple<UInt32, typeof MAX_PRIVATE_LOGS_PER_CALL>,
+    public contractClassLogsHashesIndices: Tuple<UInt32, typeof MAX_CONTRACT_CLASS_LOGS_PER_CALL>,
+  ) {}
+
+  /**
+   * Serialize into a field array. Low-level utility.
+   * @param fields - Object with fields.
+   * @returns The array.
+   */
+  static getFields(fields: FieldsOf<SideEffectUniquenessHints>) {
+    return [
+      fields.sideEffectRanges,
+      fields.noteHashReadRequestIndices,
+      fields.nullifierReadRequestIndices,
+      fields.noteHashesIndices,
+      fields.nullifiersIndices,
+      fields.privateCallRequestsIndices,
+      fields.publicCallRequestsIndices,
+      fields.l2ToL1MsgsIndices,
+      fields.privateLogsIndices,
+      fields.contractClassLogsHashesIndices,
+    ] as const;
+  }
+
+  static from(fields: FieldsOf<SideEffectUniquenessHints>): SideEffectUniquenessHints {
+    return new SideEffectUniquenessHints(...SideEffectUniquenessHints.getFields(fields));
+  }
+
+  /**
+   * Serialize this as a buffer.
+   * @returns The buffer.
+   */
+  toBuffer(): Buffer {
+    return serializeToBuffer(...SideEffectUniquenessHints.getFields(this));
+  }
+
+  /**
+   * Deserializes from a buffer or reader.
+   * @param buffer - Buffer or reader to read from.
+   * @returns The deserialized instance.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): SideEffectUniquenessHints {
+    const reader = BufferReader.asReader(buffer);
+    return new SideEffectUniquenessHints(
+      reader.readArray(TOTAL_COUNTED_SIDE_EFFECTS_PER_CALL, SideEffectCounterRange),
+      reader.readNumbers(MAX_NOTE_HASH_READ_REQUESTS_PER_CALL),
+      reader.readNumbers(MAX_NULLIFIER_READ_REQUESTS_PER_CALL),
+      reader.readNumbers(MAX_NOTE_HASHES_PER_CALL),
+      reader.readNumbers(MAX_NULLIFIERS_PER_CALL),
+      reader.readNumbers(MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL),
+      reader.readNumbers(MAX_ENQUEUED_CALLS_PER_CALL),
+      reader.readNumbers(MAX_L2_TO_L1_MSGS_PER_CALL),
+      reader.readNumbers(MAX_PRIVATE_LOGS_PER_CALL),
+      reader.readNumbers(MAX_CONTRACT_CLASS_LOGS_PER_CALL),
+    );
+  }
+}
+
+export class SideEffectCounterRange {
+  constructor(
+    public start: UInt32,
+    public end: UInt32,
+    public sideEffectGlobalIndex: UInt32,
+  ) {}
+
+  static getFields(fields: FieldsOf<SideEffectCounterRange>) {
+    return [fields.start, fields.end, fields.sideEffectGlobalIndex] as const;
+  }
+
+  static from(fields: FieldsOf<SideEffectCounterRange>): SideEffectCounterRange {
+    return new SideEffectCounterRange(...SideEffectCounterRange.getFields(fields));
+  }
+
+  static empty(): SideEffectCounterRange {
+    return new SideEffectCounterRange(0, 0, 0);
+  }
+
+  /**
+   * Serialize this as a buffer.
+   * @returns The buffer.
+   */
+  toBuffer(): Buffer {
+    return serializeToBuffer(...SideEffectCounterRange.getFields(this));
+  }
+
+  /**
+   * Deserializes from a buffer or reader.
+   * @param buffer - Buffer or reader to read from.
+   * @returns The deserialized instance.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): SideEffectCounterRange {
+    const reader = BufferReader.asReader(buffer);
+    return new SideEffectCounterRange(reader.readNumber(), reader.readNumber(), reader.readNumber());
+  }
+}

package/src/p2p/block_attestation.ts

@@ -1,3 +1,4 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { keccak256, tryRecoverAddress } from '@aztec/foundation/crypto';
 import type { EthAddress } from '@aztec/foundation/eth-address';
@@ -62,7 +63,7 @@ export class BlockAttestation extends Gossipable {
     return this.payload.archive;
   }
 
-  get slotNumber(): Fr {
+  get slotNumber(): SlotNumber {
     return this.payload.header.slotNumber;
   }
 

package/src/p2p/block_proposal.ts

@@ -1,3 +1,4 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { keccak256, tryRecoverAddress } from '@aztec/foundation/crypto';
 import type { EthAddress } from '@aztec/foundation/eth-address';
@@ -65,13 +66,13 @@ export class BlockProposal extends Gossipable {
     return this.payload.archive;
   }
 
-  get slotNumber(): Fr {
+  get slotNumber(): SlotNumber {
     return this.payload.header.slotNumber;
   }
 
   toBlockInfo(): Omit<L2BlockInfo, 'blockNumber'> {
     return {
-      slotNumber: this.slotNumber.toNumber(),
+      slotNumber: this.slotNumber,
       lastArchive: this.payload.header.lastArchiveRoot,
       timestamp: this.payload.header.timestamp,
       archive: this.archive,

package/src/p2p/consensus_payload.ts

@@ -8,8 +8,8 @@ import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
 
 import type { L2Block } from '../block/l2_block.js';
+import type { Checkpoint } from '../checkpoint/checkpoint.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
-import { StateReference } from '../tx/state_reference.js';
 import type { Signable, SignatureDomainSeparator } from './signature_utils.js';
 
 export class ConsensusPayload implements Signable {
@@ -20,8 +20,6 @@ export class ConsensusPayload implements Signable {
     public readonly header: CheckpointHeader,
     /** The archive root after the block is added */
     public readonly archive: Fr,
-    /** The state reference after the block is added */
-    public readonly stateReference: StateReference,
   ) {}
 
   static get schema() {
@@ -29,13 +27,12 @@ export class ConsensusPayload implements Signable {
       .object({
         header: CheckpointHeader.schema,
         archive: schemas.Fr,
-        stateReference: StateReference.schema,
       })
-      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.stateReference));
+      .transform(obj => new ConsensusPayload(obj.header, obj.archive));
   }
 
   static getFields(fields: FieldsOf<ConsensusPayload>) {
-    return [fields.header, fields.archive, fields.stateReference] as const;
+    return [fields.header, fields.archive] as const;
   }
 
   getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
@@ -43,59 +40,53 @@ export class ConsensusPayload implements Signable {
       'uint8, ' + //domainSeperator
         '(' +
         'bytes32, ' + // archive
-        '((bytes32,uint32),((bytes32,uint32),(bytes32,uint32),(bytes32,uint32))), ' + // stateReference
         '(int256), ' + // oracleInput
         'bytes32' + // headerHash
         ')',
     );
     const archiveRoot = this.archive.toString();
-    const stateReference = this.stateReference.toAbi();
 
     const headerHash = this.header.hash().toString();
     const encodedData = encodeAbiParameters(abi, [
       domainSeparator,
-      [archiveRoot, stateReference, [0n] /* @todo See #9963 */, headerHash],
+      [archiveRoot, [0n] /* @todo See #9963 */, headerHash],
     ] as const);
 
     return hexToBuffer(encodedData);
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer([this.header, this.archive, this.stateReference]);
+    return serializeToBuffer([this.header, this.archive]);
   }
 
   public equals(other: ConsensusPayload): boolean {
-    return (
-      this.header.equals(other.header) &&
-      this.archive.equals(other.archive) &&
-      this.stateReference.equals(other.stateReference)
-    );
+    return this.header.equals(other.header) && this.archive.equals(other.archive);
   }
 
   static fromBuffer(buf: Buffer | BufferReader): ConsensusPayload {
     const reader = BufferReader.asReader(buf);
-    const payload = new ConsensusPayload(
-      reader.readObject(CheckpointHeader),
-      reader.readObject(Fr),
-      reader.readObject(StateReference),
-    );
+    const payload = new ConsensusPayload(reader.readObject(CheckpointHeader), reader.readObject(Fr));
     return payload;
   }
 
   static fromFields(fields: FieldsOf<ConsensusPayload>): ConsensusPayload {
-    return new ConsensusPayload(fields.header, fields.archive, fields.stateReference);
+    return new ConsensusPayload(fields.header, fields.archive);
   }
 
   static fromBlock(block: L2Block): ConsensusPayload {
-    return new ConsensusPayload(block.header.toCheckpointHeader(), block.archive.root, block.header.state);
+    return new ConsensusPayload(block.header.toCheckpointHeader(), block.archive.root);
+  }
+
+  static fromCheckpoint(checkpoint: Checkpoint): ConsensusPayload {
+    return new ConsensusPayload(checkpoint.header, checkpoint.archive.root);
   }
 
   static empty(): ConsensusPayload {
-    return new ConsensusPayload(CheckpointHeader.empty(), Fr.ZERO, StateReference.empty());
+    return new ConsensusPayload(CheckpointHeader.empty(), Fr.ZERO);
   }
 
   static random(): ConsensusPayload {
-    return new ConsensusPayload(CheckpointHeader.random(), Fr.random(), StateReference.random());
+    return new ConsensusPayload(CheckpointHeader.random(), Fr.random());
   }
 
   /**
@@ -115,11 +106,10 @@ export class ConsensusPayload implements Signable {
     return {
       header: this.header.toInspect(),
       archive: this.archive.toString(),
-      stateReference: this.stateReference.toInspect(),
     };
   }
 
   toString() {
-    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}`;
+    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}}`;
   }
 }

package/src/rollup/checkpoint_constant_data.ts

@@ -1,3 +1,4 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
@@ -24,7 +25,7 @@ export class CheckpointConstantData {
     /** Identifier of the prover. */
     public proverId: Fr,
     /** Slot number of the checkpoint. */
-    public slotNumber: Fr,
+    public slotNumber: SlotNumber,
     /** Coinbase address of the rollup. */
     public coinbase: EthAddress,
     /** Address to receive fees. */
@@ -58,7 +59,7 @@ export class CheckpointConstantData {
       Fr.ZERO,
       Fr.ZERO,
       Fr.ZERO,
-      Fr.ZERO,
+      SlotNumber.ZERO,
       EthAddress.ZERO,
       AztecAddress.ZERO,
       GasFees.empty(),
@@ -66,7 +67,17 @@ export class CheckpointConstantData {
   }
 
   toBuffer() {
-    return serializeToBuffer(...CheckpointConstantData.getFields(this));
+    return serializeToBuffer(
+      this.chainId,
+      this.version,
+      this.vkTreeRoot,
+      this.protocolContractsHash,
+      this.proverId,
+      new Fr(this.slotNumber),
+      this.coinbase,
+      this.feeRecipient,
+      this.gasFees,
+    );
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
@@ -77,13 +88,21 @@ export class CheckpointConstantData {
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
+      SlotNumber(Fr.fromBuffer(reader).toNumber()),
       reader.readObject(EthAddress),
       reader.readObject(AztecAddress),
       reader.readObject(GasFees),
     );
   }
 
+  /**
+   * Returns the slot number as a SlotNumber branded type.
+   * @deprecated Use slotNumber directly instead.
+   */
+  getSlotNumber(): SlotNumber {
+    return this.slotNumber;
+  }
+
   toInspect() {
     return {
       chainId: this.chainId.toNumber(),
@@ -91,7 +110,7 @@ export class CheckpointConstantData {
       vkTreeRoot: this.vkTreeRoot.toString(),
       protocolContractsHash: this.protocolContractsHash.toString(),
       proverId: this.proverId.toString(),
-      slotNumber: this.slotNumber.toNumber(),
+      slotNumber: this.slotNumber,
       coinbase: this.coinbase.toString(),
       feeRecipient: this.feeRecipient.toString(),
       gasFees: this.gasFees.toInspect(),

package/src/rollup/checkpoint_header.ts

@@ -1,4 +1,5 @@
 import type { ViemHeader } from '@aztec/ethereum';
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { sha256ToField } from '@aztec/foundation/crypto';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -25,7 +26,7 @@ export class CheckpointHeader {
     /** Content commitment of the L2 block. */
     public contentCommitment: ContentCommitment,
     /** Slot number of the L2 block */
-    public slotNumber: Fr,
+    public slotNumber: SlotNumber,
     /** Timestamp of the L2 block. */
     public timestamp: UInt64,
     /** Recipient of block reward. */
@@ -44,7 +45,7 @@ export class CheckpointHeader {
         lastArchiveRoot: schemas.Fr,
         blockHeadersHash: schemas.Fr,
         contentCommitment: ContentCommitment.schema,
-        slotNumber: schemas.Fr,
+        slotNumber: schemas.SlotNumber,
         timestamp: schemas.BigInt,
         coinbase: schemas.EthAddress,
         feeRecipient: schemas.AztecAddress,
@@ -79,7 +80,7 @@ export class CheckpointHeader {
       reader.readObject(Fr),
       reader.readObject(Fr),
       reader.readObject(ContentCommitment),
-      Fr.fromBuffer(reader),
+      SlotNumber(Fr.fromBuffer(reader).toNumber()),
       reader.readUInt64(),
       reader.readObject(EthAddress),
       reader.readObject(AztecAddress),
@@ -93,7 +94,7 @@ export class CheckpointHeader {
       this.lastArchiveRoot.equals(other.lastArchiveRoot) &&
       this.blockHeadersHash.equals(other.blockHeadersHash) &&
       this.contentCommitment.equals(other.contentCommitment) &&
-      this.slotNumber.equals(other.slotNumber) &&
+      this.slotNumber === other.slotNumber &&
       this.timestamp === other.timestamp &&
       this.coinbase.equals(other.coinbase) &&
       this.feeRecipient.equals(other.feeRecipient) &&
@@ -108,7 +109,7 @@ export class CheckpointHeader {
       this.lastArchiveRoot,
       this.blockHeadersHash,
       this.contentCommitment,
-      this.slotNumber,
+      new Fr(this.slotNumber),
       bigintToUInt64BE(this.timestamp),
       this.coinbase,
       this.feeRecipient,
@@ -126,7 +127,7 @@ export class CheckpointHeader {
       lastArchiveRoot: Fr.ZERO,
       blockHeadersHash: Fr.ZERO,
       contentCommitment: ContentCommitment.empty(),
-      slotNumber: Fr.ZERO,
+      slotNumber: SlotNumber.ZERO,
       timestamp: 0n,
       coinbase: EthAddress.ZERO,
       feeRecipient: AztecAddress.ZERO,
@@ -136,18 +137,19 @@ export class CheckpointHeader {
     });
   }
 
-  static random(): CheckpointHeader {
-    return new CheckpointHeader(
-      Fr.random(),
-      Fr.random(),
-      ContentCommitment.random(),
-      new Fr(BigInt(Math.floor(Math.random() * 1000) + 1)),
-      BigInt(Math.floor(Date.now() / 1000)),
-      EthAddress.random(),
-      new AztecAddress(Fr.random()),
-      GasFees.random(),
-      new Fr(BigInt(Math.floor(Math.random() * 1000000))),
-    );
+  static random(overrides: Partial<FieldsOf<CheckpointHeader>> = {}): CheckpointHeader {
+    return CheckpointHeader.from({
+      lastArchiveRoot: Fr.random(),
+      blockHeadersHash: Fr.random(),
+      contentCommitment: ContentCommitment.random(),
+      slotNumber: SlotNumber(Math.floor(Math.random() * 1000) + 1),
+      timestamp: BigInt(Math.floor(Date.now() / 1000)),
+      coinbase: EthAddress.random(),
+      feeRecipient: new AztecAddress(Fr.random()),
+      gasFees: GasFees.random(),
+      totalManaUsed: new Fr(BigInt(Math.floor(Math.random() * 1000000))),
+      ...overrides,
+    });
   }
 
   isEmpty(): boolean {
@@ -155,7 +157,7 @@ export class CheckpointHeader {
       this.lastArchiveRoot.isZero() &&
       this.blockHeadersHash.isZero() &&
       this.contentCommitment.isEmpty() &&
-      this.slotNumber.isZero() &&
+      this.slotNumber === 0 &&
       this.timestamp === 0n &&
       this.coinbase.isZero() &&
       this.feeRecipient.isZero() &&
@@ -181,7 +183,7 @@ export class CheckpointHeader {
       Fr.fromString(header.lastArchiveRoot),
       Fr.fromString(header.blockHeadersHash),
       ContentCommitment.fromViem(header.contentCommitment),
-      new Fr(header.slotNumber),
+      SlotNumber.fromBigInt(header.slotNumber),
       header.timestamp,
       new EthAddress(hexToBuffer(header.coinbase)),
       new AztecAddress(hexToBuffer(header.feeRecipient)),
@@ -190,12 +192,20 @@ export class CheckpointHeader {
     );
   }
 
+  /**
+   * Returns the slot number as a SlotNumber branded type.
+   * @deprecated Use slotNumber directly instead.
+   */
+  getSlotNumber(): SlotNumber {
+    return this.slotNumber;
+  }
+
   toViem(): ViemHeader {
     return {
       lastArchiveRoot: this.lastArchiveRoot.toString(),
       blockHeadersHash: this.blockHeadersHash.toString(),
       contentCommitment: this.contentCommitment.toViem(),
-      slotNumber: this.slotNumber.toBigInt(),
+      slotNumber: BigInt(this.slotNumber),
       timestamp: this.timestamp,
       coinbase: this.coinbase.toString(),
       feeRecipient: `0x${this.feeRecipient.toBuffer().toString('hex').padStart(64, '0')}`,
@@ -212,7 +222,7 @@ export class CheckpointHeader {
       lastArchive: this.lastArchiveRoot.toString(),
       blockHeadersHash: this.blockHeadersHash.toString(),
       contentCommitment: this.contentCommitment.toInspect(),
-      slotNumber: this.slotNumber.toBigInt(),
+      slotNumber: this.slotNumber,
       timestamp: this.timestamp,
       coinbase: this.coinbase.toString(),
       feeRecipient: this.feeRecipient.toString(),
@@ -227,7 +237,7 @@ export class CheckpointHeader {
   lastArchiveRoot: ${this.lastArchiveRoot.toString()},
   blockHeadersHash: ${this.blockHeadersHash.toString()},
   contentCommitment: ${inspect(this.contentCommitment)},
-  slotNumber: ${this.slotNumber.toBigInt()},
+  slotNumber: ${this.slotNumber},
   timestamp: ${this.timestamp},
   coinbase: ${this.coinbase.toString()},
   feeRecipient: ${this.feeRecipient.toString()},

package/src/schemas/schemas.ts

@@ -1,3 +1,4 @@
+import type { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import type { Buffer32 } from '@aztec/foundation/buffer';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { Fq, Fr, Point } from '@aztec/foundation/fields';
@@ -65,6 +66,12 @@ export const schemas = {
   /** Accepts a hex string. */
   EventSelector: EventSelector.schema,
 
+  /** Accepts a number, bigint, or string and coerces to SlotNumber. */
+  SlotNumber: foundationSchemas.SlotNumber as ZodFor<SlotNumber>,
+
+  /** Accepts a number, bigint, or string and coerces to EpochNumber. */
+  EpochNumber: foundationSchemas.EpochNumber as ZodFor<EpochNumber>,
+
   GasUsed: z.object({
     totalGas: Gas.schema,
     teardownGas: Gas.schema,

package/src/slashing/empire.ts

@@ -1,3 +1,5 @@
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+
 import { getRoundForSlot, getRoundsForEpoch } from './helpers.js';
 import type { Offense, OffenseIdentifier, SlashPayload, SlashPayloadRound, ValidatorSlash } from './types.js';
 import { OffenseType } from './types.js';
@@ -66,7 +68,7 @@ export function getFirstEligibleRoundForOffense(
     // Inactivity is detected at the end of the epoch, so we flag it as detected in the first fresh round for the next epoch
     case OffenseType.INACTIVITY: {
       const epoch = offense.epochOrSlot;
-      const detectedEpoch = epoch + 1n;
+      const detectedEpoch = EpochNumber.fromBigInt(epoch + 1n);
       return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
     }
     // These offenses are detected once an epoch is pruned, which happens after the proof submission window
@@ -74,7 +76,7 @@ export function getFirstEligibleRoundForOffense(
     case OffenseType.DATA_WITHHOLDING: {
       // TODO(palla/slash): Check for off-by-ones especially here
       const epoch = offense.epochOrSlot;
-      const detectedEpoch = epoch + BigInt(constants.proofSubmissionEpochs);
+      const detectedEpoch = EpochNumber.fromBigInt(epoch + BigInt(constants.proofSubmissionEpochs));
       return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
     }
     // These offenses are detected immediately in the slot they occur, so we assume they are detected in the first round for the following slot
@@ -83,13 +85,13 @@ export function getFirstEligibleRoundForOffense(
     case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
     case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL: {
       const slot = offense.epochOrSlot;
-      const detectedSlot = slot + 1n;
+      const detectedSlot = SlotNumber.fromBigInt(slot + 1n);
       return getRoundForSlot(detectedSlot, constants).round + 1n;
     }
     // Assume these are epoch-based offenses, even though we should never have to process these
     case OffenseType.UNKNOWN: {
       const epoch = offense.epochOrSlot;
-      const detectedEpoch = epoch + 1n;
+      const detectedEpoch = EpochNumber.fromBigInt(epoch + 1n);
       return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
     }
     default: {

package/src/slashing/helpers.ts

@@ -1,21 +1,24 @@
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+
 import { type L1RollupConstants, getEpochAtSlot, getSlotRangeForEpoch } from '../epoch-helpers/index.js';
 import type { SlasherConfig } from '../interfaces/slasher.js';
 import { type Offense, OffenseType } from './types.js';
 
 /** Returns the voting round number and voting slot within the round for a given L2 slot. */
 export function getRoundForSlot(
-  slot: bigint,
+  slot: SlotNumber,
   constants: { slashingRoundSize: number },
-): { round: bigint; votingSlot: bigint } {
+): { round: bigint; votingSlot: SlotNumber } {
   const roundSize = BigInt(constants.slashingRoundSize);
-  const round = slot / roundSize;
-  const votingSlot = slot % roundSize;
+  const slotBigInt = BigInt(slot);
+  const round = slotBigInt / roundSize;
+  const votingSlot = SlotNumber.fromBigInt(slotBigInt % roundSize);
   return { round, votingSlot };
 }
 
 /** Returns the voting round(s) lower and upper bounds (inclusive) covered by the given epoch */
 export function getRoundsForEpoch(
-  epoch: bigint,
+  epoch: EpochNumber,
   constants: { slashingRoundSize: number; epochDuration: number },
 ): [bigint, bigint] {
   const [start, end] = getSlotRangeForEpoch(epoch, constants);
@@ -28,13 +31,13 @@ export function getRoundsForEpoch(
 export function getEpochsForRound(
   round: bigint,
   constants: { slashingRoundSize: number; epochDuration: number },
-): bigint[] {
-  const epochs: bigint[] = [];
-  const firstSlot = round * BigInt(constants.slashingRoundSize);
-  const lastSlot = firstSlot + BigInt(constants.slashingRoundSize) - 1n;
+): EpochNumber[] {
+  const epochs: EpochNumber[] = [];
+  const firstSlot = SlotNumber.fromBigInt(round * BigInt(constants.slashingRoundSize));
+  const lastSlot = SlotNumber(firstSlot + constants.slashingRoundSize - 1);
   const startEpoch = getEpochAtSlot(firstSlot, constants);
   const endEpoch = getEpochAtSlot(lastSlot, constants);
-  for (let epoch = startEpoch; epoch <= endEpoch; epoch++) {
+  for (let epoch = startEpoch; epoch <= endEpoch; epoch = EpochNumber(epoch + 1)) {
     epochs.push(epoch);
   }
   return epochs;
@@ -101,9 +104,11 @@ export function getTimeUnitForOffense(offense: OffenseType): 'epoch' | 'slot' {
 export function getSlotForOffense(
   offense: Pick<Offense, 'epochOrSlot' | 'offenseType'>,
   constants: Pick<L1RollupConstants, 'epochDuration'>,
-): bigint {
+): SlotNumber {
   const { epochOrSlot, offenseType } = offense;
-  return getTimeUnitForOffense(offenseType) === 'epoch' ? epochOrSlot * BigInt(constants.epochDuration) : epochOrSlot;
+  return getTimeUnitForOffense(offenseType) === 'epoch'
+    ? SlotNumber.fromBigInt(epochOrSlot * BigInt(constants.epochDuration))
+    : SlotNumber.fromBigInt(epochOrSlot);
 }
 
 /** Returns the epoch for a given offense. If the offense type or epoch is not defined, returns undefined. */

package/src/slashing/interfaces.ts

@@ -1,3 +1,5 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+
 import type { ProposerSlashAction } from './types.js';
 
 export interface ProposerSlashActionProvider {
@@ -7,5 +9,5 @@ export interface ProposerSlashActionProvider {
    * @param slotNumber - The current slot number
    * @returns The actions to take
    */
-  getProposerActions(slotNumber: bigint): Promise<ProposerSlashAction[]>;
+  getProposerActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]>;
 }