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

package/src/rollup/checkpoint_header.ts

@@ -1,7 +1,8 @@
-import type { ViemHeader } from '@aztec/ethereum';
-import { sha256ToField } from '@aztec/foundation/crypto';
+import type { ViemHeader } from '@aztec/ethereum/contracts';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { sha256ToField } from '@aztec/foundation/crypto/sha256';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import type { ZodFor } from '@aztec/foundation/schemas';
 import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -13,17 +14,34 @@ import { z } from 'zod';
 import { AztecAddress } from '../aztec-address/index.js';
 import { GasFees } from '../gas/index.js';
 import { schemas } from '../schemas/index.js';
-import { ContentCommitment } from '../tx/content_commitment.js';
+import type { GlobalVariables } from '../tx/global_variables.js';
 import type { UInt64 } from '../types/shared.js';
 
+/**
+ * Header of a checkpoint. A checkpoint is a collection of blocks submitted to L1 all within the same slot.
+ * TODO(palla/mbps): Should this include chainId and version as well? Is this used just in circuits?
+ * TODO(palla/mbps): What about CheckpointNumber?
+ */
 export class CheckpointHeader {
   constructor(
     /** Root of the archive tree before this block is added. */
     public lastArchiveRoot: Fr,
-    /** Content commitment of the L2 block. */
-    public contentCommitment: ContentCommitment,
+    /** Hash of the headers of all blocks in this checkpoint. */
+    public blockHeadersHash: Fr,
+    /** Hash of the blobs in the checkpoint. */
+    public blobsHash: Fr,
+    /** Root of the l1 to l2 messages subtree. */
+    public inHash: Fr,
+    /**
+     * The root of the epoch out hash balanced tree. The out hash of the first checkpoint in the epoch is inserted at
+     * index 0, the second at index 1, and so on.
+     * Note: This is not necessarily the final epoch out hash. It includes only the out hashes of checkpoints up to and
+     * including the current checkpoint. Any subsequent checkpoints added to the same epoch are not reflected in this
+     * value.
+     */
+    public epochOutHash: Fr,
     /** Slot number of the L2 block */
-    public slotNumber: Fr,
+    public slotNumber: SlotNumber,
     /** Timestamp of the L2 block. */
     public timestamp: UInt64,
     /** Recipient of block reward. */
@@ -40,8 +58,11 @@ export class CheckpointHeader {
     return z
       .object({
         lastArchiveRoot: schemas.Fr,
-        contentCommitment: ContentCommitment.schema,
-        slotNumber: schemas.Fr,
+        blockHeadersHash: schemas.Fr,
+        blobsHash: schemas.Fr,
+        inHash: schemas.Fr,
+        epochOutHash: schemas.Fr,
+        slotNumber: schemas.SlotNumber,
         timestamp: schemas.BigInt,
         coinbase: schemas.EthAddress,
         feeRecipient: schemas.AztecAddress,
@@ -54,7 +75,10 @@ export class CheckpointHeader {
   static getFields(fields: FieldsOf<CheckpointHeader>) {
     return [
       fields.lastArchiveRoot,
-      fields.contentCommitment,
+      fields.blockHeadersHash,
+      fields.blobsHash,
+      fields.inHash,
+      fields.epochOutHash,
       fields.slotNumber,
       fields.timestamp,
       fields.coinbase,
@@ -73,8 +97,11 @@ export class CheckpointHeader {
 
     return new CheckpointHeader(
       reader.readObject(Fr),
-      reader.readObject(ContentCommitment),
-      Fr.fromBuffer(reader),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      SlotNumber(Fr.fromBuffer(reader).toNumber()),
       reader.readUInt64(),
       reader.readObject(EthAddress),
       reader.readObject(AztecAddress),
@@ -86,8 +113,11 @@ export class CheckpointHeader {
   equals(other: CheckpointHeader) {
     return (
       this.lastArchiveRoot.equals(other.lastArchiveRoot) &&
-      this.contentCommitment.equals(other.contentCommitment) &&
-      this.slotNumber.equals(other.slotNumber) &&
+      this.blockHeadersHash.equals(other.blockHeadersHash) &&
+      this.blobsHash.equals(other.blobsHash) &&
+      this.inHash.equals(other.inHash) &&
+      this.epochOutHash.equals(other.epochOutHash) &&
+      this.slotNumber === other.slotNumber &&
       this.timestamp === other.timestamp &&
       this.coinbase.equals(other.coinbase) &&
       this.feeRecipient.equals(other.feeRecipient) &&
@@ -96,12 +126,26 @@ export class CheckpointHeader {
     );
   }
 
+  /** Returns true if the global variables match those in the checkpoint header. */
+  matchesGlobalVariables(other: GlobalVariables) {
+    return (
+      this.coinbase.equals(other.coinbase) &&
+      this.feeRecipient.equals(other.feeRecipient) &&
+      this.gasFees.equals(other.gasFees) &&
+      this.slotNumber === other.slotNumber &&
+      this.timestamp === other.timestamp
+    );
+  }
+
   toBuffer() {
     // Note: The order here must match the order in the ProposedHeaderLib solidity library.
     return serializeToBuffer([
       this.lastArchiveRoot,
-      this.contentCommitment,
-      this.slotNumber,
+      this.blockHeadersHash,
+      this.blobsHash,
+      this.inHash,
+      this.epochOutHash,
+      new Fr(this.slotNumber),
       bigintToUInt64BE(this.timestamp),
       this.coinbase,
       this.feeRecipient,
@@ -117,8 +161,11 @@ export class CheckpointHeader {
   static empty(fields: Partial<FieldsOf<CheckpointHeader>> = {}) {
     return CheckpointHeader.from({
       lastArchiveRoot: Fr.ZERO,
-      contentCommitment: ContentCommitment.empty(),
-      slotNumber: Fr.ZERO,
+      blockHeadersHash: Fr.ZERO,
+      blobsHash: Fr.ZERO,
+      inHash: Fr.ZERO,
+      epochOutHash: Fr.ZERO,
+      slotNumber: SlotNumber.ZERO,
       timestamp: 0n,
       coinbase: EthAddress.ZERO,
       feeRecipient: AztecAddress.ZERO,
@@ -128,24 +175,31 @@ export class CheckpointHeader {
     });
   }
 
-  static random(): CheckpointHeader {
-    return new CheckpointHeader(
-      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(),
+      blobsHash: Fr.random(),
+      inHash: Fr.random(),
+      epochOutHash: Fr.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 {
     return (
       this.lastArchiveRoot.isZero() &&
-      this.contentCommitment.isEmpty() &&
-      this.slotNumber.isZero() &&
+      this.blockHeadersHash.isZero() &&
+      this.blobsHash.isZero() &&
+      this.inHash.isZero() &&
+      this.epochOutHash.isZero() &&
+      this.slotNumber === 0 &&
       this.timestamp === 0n &&
       this.coinbase.isZero() &&
       this.feeRecipient.isZero() &&
@@ -169,8 +223,11 @@ export class CheckpointHeader {
   static fromViem(header: ViemHeader) {
     return new CheckpointHeader(
       Fr.fromString(header.lastArchiveRoot),
-      ContentCommitment.fromViem(header.contentCommitment),
-      new Fr(header.slotNumber),
+      Fr.fromString(header.blockHeadersHash),
+      Fr.fromString(header.blobsHash),
+      Fr.fromString(header.inHash),
+      Fr.fromString(header.outHash),
+      SlotNumber.fromBigInt(header.slotNumber),
       header.timestamp,
       new EthAddress(hexToBuffer(header.coinbase)),
       new AztecAddress(hexToBuffer(header.feeRecipient)),
@@ -179,11 +236,22 @@ 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(),
-      contentCommitment: this.contentCommitment.toViem(),
-      slotNumber: this.slotNumber.toBigInt(),
+      blockHeadersHash: this.blockHeadersHash.toString(),
+      blobsHash: this.blobsHash.toString(),
+      inHash: this.inHash.toString(),
+      outHash: this.epochOutHash.toString(),
+      slotNumber: BigInt(this.slotNumber),
       timestamp: this.timestamp,
       coinbase: this.coinbase.toString(),
       feeRecipient: `0x${this.feeRecipient.toBuffer().toString('hex').padStart(64, '0')}`,
@@ -198,8 +266,11 @@ export class CheckpointHeader {
   toInspect() {
     return {
       lastArchive: this.lastArchiveRoot.toString(),
-      contentCommitment: this.contentCommitment.toInspect(),
-      slotNumber: this.slotNumber.toBigInt(),
+      blockHeadersHash: this.blockHeadersHash.toString(),
+      blobsHash: this.blobsHash.toString(),
+      inHash: this.inHash.toString(),
+      epochOutHash: this.epochOutHash.toString(),
+      slotNumber: this.slotNumber,
       timestamp: this.timestamp,
       coinbase: this.coinbase.toString(),
       feeRecipient: this.feeRecipient.toString(),
@@ -209,15 +280,17 @@ export class CheckpointHeader {
   }
 
   [inspect.custom]() {
-    const gasfees = `da:${this.gasFees.feePerDaGas}, l2:${this.gasFees.feePerL2Gas}`;
     return `Header {
   lastArchiveRoot: ${this.lastArchiveRoot.toString()},
-  contentCommitment: ${inspect(this.contentCommitment)},
-  slotNumber: ${this.slotNumber.toBigInt()},
+  blockHeadersHash: ${this.blockHeadersHash.toString()},
+  blobsHash: ${inspect(this.blobsHash)},
+  inHash: ${inspect(this.inHash)},
+  epochOutHash: ${inspect(this.epochOutHash)},
+  slotNumber: ${this.slotNumber},
   timestamp: ${this.timestamp},
   coinbase: ${this.coinbase.toString()},
   feeRecipient: ${this.feeRecipient.toString()},
-  gasFees: ${gasfees},
+  gasFees: { da:${this.gasFees.feePerDaGas}, l2:${this.gasFees.feePerL2Gas} },
   totalManaUsed: ${this.totalManaUsed.toBigInt()},
 }`;
   }

package/src/rollup/checkpoint_rollup_public_inputs.ts

@@ -1,7 +1,7 @@
 import { BlobAccumulator, FinalBlobBatchingChallenges } from '@aztec/blob-lib/types';
 import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, type Tuple, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -27,6 +27,14 @@ export class CheckpointRollupPublicInputs {
      * Archive tree after adding this checkpoint range.
      */
     public newArchive: AppendOnlyTreeSnapshot,
+    /**
+     * The out hash tree snapshot immediately before this checkpoint range.
+     */
+    public previousOutHash: AppendOnlyTreeSnapshot,
+    /**
+     * The out hash tree snapshot after applying this checkpoint range.
+     */
+    public newOutHash: AppendOnlyTreeSnapshot,
     /**
      * The hashes of the headers of the constituent checkpoints.
      */
@@ -55,6 +63,8 @@ export class CheckpointRollupPublicInputs {
       reader.readObject(EpochConstantData),
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(AppendOnlyTreeSnapshot),
       reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
       reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
       reader.readObject(BlobAccumulator),
@@ -68,6 +78,8 @@ export class CheckpointRollupPublicInputs {
       this.constants,
       this.previousArchive,
       this.newArchive,
+      this.previousOutHash,
+      this.newOutHash,
       this.checkpointHeaderHashes,
       this.fees,
       this.startBlobAccumulator,

package/src/rollup/checkpoint_root_rollup_private_inputs.ts

@@ -1,12 +1,14 @@
 import { BlobAccumulator, FinalBlobBatchingChallenges } from '@aztec/blob-lib/types';
-import { ARCHIVE_HEIGHT, BLOBS_PER_BLOCK, FIELDS_PER_BLOB } from '@aztec/constants';
-import { BLS12Point, Fr } from '@aztec/foundation/fields';
+import { ARCHIVE_HEIGHT, BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB, OUT_HASH_TREE_HEIGHT } from '@aztec/constants';
+import { BLS12Point } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { BlockRollupPublicInputs } from './block_rollup_public_inputs.js';
 
@@ -20,6 +22,14 @@ export class CheckpointRootRollupHints {
      * Hint for checking the hash of previous_block_header is the last leaf of the previous archive.
      */
     public previousArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
+    /**
+     * The out hash tree snapshot immediately before this checkpoint.
+     */
+    public previousOutHash: AppendOnlyTreeSnapshot,
+    /**
+     * Hint for inserting the new out hash into the out hash tree.
+     */
+    public newOutHashSiblingPath: Tuple<Fr, typeof OUT_HASH_TREE_HEIGHT>,
     /**
      * The current blob accumulation state across the epoch.
      */
@@ -31,13 +41,13 @@ export class CheckpointRootRollupHints {
     /**
      * Flat list of all tx effects which will be added to the blob.
      * Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
-     * Tuple<Fr, FIELDS_PER_BLOB * BLOBS_PER_BLOCK>
+     * Tuple<Fr, FIELDS_PER_BLOB * BLOBS_PER_CHECKPOINT>
      */
     public blobFields: Fr[],
     /**
      * KZG commitments representing the blob (precomputed in ts, injected to use inside circuit).
      */
-    public blobCommitments: Tuple<BLS12Point, typeof BLOBS_PER_BLOCK>,
+    public blobCommitments: Tuple<BLS12Point, typeof BLOBS_PER_CHECKPOINT>,
     /**
      * The hash of eth blob hashes for this block
      * See yarn-project/foundation/src/blob/index.ts or body.ts for calculation
@@ -53,6 +63,8 @@ export class CheckpointRootRollupHints {
     return [
       fields.previousBlockHeader,
       fields.previousArchiveSiblingPath,
+      fields.previousOutHash,
+      fields.newOutHashSiblingPath,
       fields.startBlobAccumulator,
       fields.finalBlobChallenges,
       fields.blobFields,
@@ -70,12 +82,14 @@ export class CheckpointRootRollupHints {
     return new CheckpointRootRollupHints(
       BlockHeader.fromBuffer(reader),
       reader.readArray(ARCHIVE_HEIGHT, Fr),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readArray(OUT_HASH_TREE_HEIGHT, Fr),
       reader.readObject(BlobAccumulator),
       reader.readObject(FinalBlobBatchingChallenges),
       // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
       // reader.readArray(FIELDS_PER_BLOB, Fr),
-      Array.from({ length: FIELDS_PER_BLOB * BLOBS_PER_BLOCK }, () => Fr.fromBuffer(reader)),
-      reader.readArray(BLOBS_PER_BLOCK, BLS12Point),
+      Array.from({ length: FIELDS_PER_BLOB * BLOBS_PER_CHECKPOINT }, () => Fr.fromBuffer(reader)),
+      reader.readArray(BLOBS_PER_CHECKPOINT, BLS12Point),
       Fr.fromBuffer(reader),
     );
   }

package/src/rollup/epoch_constant_data.ts

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

package/src/rollup/index.ts

@@ -1,6 +1,7 @@
 export * from './avm_proof_data.js';
 export * from './base_rollup_hints.js';
 export * from './block_constant_data.js';
+export * from './block_headers_hash.js';
 export * from './block_merge_rollup_private_inputs.js';
 export * from './block_rollup_public_inputs.js';
 export * from './block_root_rollup_private_inputs.js';

package/src/rollup/public_chonk_verifier_private_inputs.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';

package/src/rollup/public_chonk_verifier_public_inputs.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';

package/src/rollup/public_tx_base_rollup_private_inputs.ts

@@ -4,7 +4,7 @@ import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
-import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
+import { ProofData, ProofDataForFixedVk, type RollupHonkProofData } from '../proofs/proof_data.js';
 import type { AvmProofData } from './avm_proof_data.js';
 import { PublicBaseRollupHints } from './base_rollup_hints.js';
 import { PublicChonkVerifierPublicInputs } from './public_chonk_verifier_public_inputs.js';
@@ -28,7 +28,7 @@ export class PublicTxBaseRollupPrivateInputs {
     const reader = BufferReader.asReader(buffer);
     return new PublicTxBaseRollupPrivateInputs(
       ProofData.fromBuffer(reader, PublicChonkVerifierPublicInputs),
-      ProofData.fromBuffer(reader, AvmCircuitPublicInputs),
+      ProofDataForFixedVk.fromBuffer(reader, AvmCircuitPublicInputs),
       reader.readObject(PublicBaseRollupHints),
     );
   }

package/src/rollup/root_rollup_public_inputs.ts

@@ -1,7 +1,7 @@
 import { FinalBlobAccumulator } from '@aztec/blob-lib/types';
 import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, type Tuple, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -21,6 +21,12 @@ export class RootRollupPublicInputs {
     public previousArchiveRoot: Fr,
     /** Root of the archive tree after this rollup is processed */
     public endArchiveRoot: Fr,
+    /**
+     * Root of the balanced merkle tree consisting of the out hashes of all checkpoints in this epoch.
+     * The out hash of the first checkpoint in the epoch is inserted at index 0, the second at index 1, and so on.
+     */
+    public outHash: Fr,
+    /** Hashes of checkpoint headers for this rollup. */
     public checkpointHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
     public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
     public constants: EpochConstantData,
@@ -31,6 +37,7 @@ export class RootRollupPublicInputs {
     return [
       fields.previousArchiveRoot,
       fields.endArchiveRoot,
+      fields.outHash,
       fields.checkpointHeaderHashes,
       fields.fees,
       fields.constants,
@@ -58,6 +65,7 @@ export class RootRollupPublicInputs {
   public static fromBuffer(buffer: Buffer | BufferReader): RootRollupPublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new RootRollupPublicInputs(
+      Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
@@ -88,6 +96,7 @@ export class RootRollupPublicInputs {
   /** Creates a random instance. Used for testing only - will not prove/verify. */
   static random() {
     return new RootRollupPublicInputs(
+      Fr.random(),
       Fr.random(),
       Fr.random(),
       makeTuple(AZTEC_MAX_EPOCH_DURATION, Fr.random),

package/src/rollup/tree_snapshot_diff_hints.ts

@@ -6,7 +6,7 @@ import {
   PUBLIC_DATA_TREE_HEIGHT,
 } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
 import type { FieldsOf } from '@aztec/foundation/types';

package/src/rollup/tx_rollup_public_inputs.ts

@@ -1,5 +1,5 @@
 import { SpongeBlob } from '@aztec/blob-lib/types';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';

package/src/schemas/schemas.ts

@@ -1,6 +1,8 @@
+import type { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import type { Buffer32 } from '@aztec/foundation/buffer';
+import type { Fq, Fr } from '@aztec/foundation/curves/bn254';
+import type { Point } from '@aztec/foundation/curves/grumpkin';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fq, Fr, Point } from '@aztec/foundation/fields';
 import { type ZodFor, schemas as foundationSchemas } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
@@ -10,6 +12,7 @@ import { EventSelector } from '../abi/event_selector.js';
 import { FunctionSelector } from '../abi/function_selector.js';
 import { NoteSelector } from '../abi/note_selector.js';
 import { AztecAddress } from '../aztec-address/index.js';
+import { Gas } from '../gas/gas.js';
 
 /**
  * Validation schemas for common types. Every schema must match its toJSON.
@@ -37,6 +40,9 @@ export const schemas = {
   /** Coerces input to UInt32. */
   UInt32: foundationSchemas.UInt32,
 
+  /** Coerces input to UInt64. */
+  UInt64: foundationSchemas.UInt64,
+
   /** Accepts a hex string as a Buffer32 type. */
   Buffer32: foundationSchemas.Buffer32 as ZodFor<Buffer32>,
 
@@ -63,6 +69,19 @@ 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,
+    publicGas: Gas.schema,
+    billedGas: Gas.schema,
+  }),
 };
 
 export const AbiDecodedSchema: ZodFor<AbiDecoded> = z.union([
@@ -73,8 +92,12 @@ export const AbiDecodedSchema: ZodFor<AbiDecoded> = z.union([
   z.record(z.lazy(() => AbiDecodedSchema)),
 ]);
 
+// C++ only supports null values, which we want to convert to undefined.
+export const NullishToUndefined = (schema: ZodFor<any>) => schema.nullish().transform(x => x ?? undefined);
+
 export {
   type ZodFor,
+  zodFor,
   bufferSchema,
   hexSchema,
   hexSchemaFor,

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. */