@aztec/stdlib 3.0.0-canary.a9708bd → 3.0.0-devnet.2

package/src/rollup/public_tx_base_rollup_private_inputs.ts

@@ -0,0 +1,57 @@
+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 { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
+import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
+import type { AvmProofData } from './avm_proof_data.js';
+import { PublicBaseRollupHints } from './base_rollup_hints.js';
+import { PublicTubePublicInputs } from './public_tube_public_inputs.js';
+
+export class PublicTxBaseRollupPrivateInputs {
+  constructor(
+    public publicTubeProofData: RollupHonkProofData<PublicTubePublicInputs>,
+    public avmProofData: AvmProofData,
+    public hints: PublicBaseRollupHints,
+  ) {}
+
+  static from(fields: FieldsOf<PublicTxBaseRollupPrivateInputs>): PublicTxBaseRollupPrivateInputs {
+    return new PublicTxBaseRollupPrivateInputs(...PublicTxBaseRollupPrivateInputs.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PublicTxBaseRollupPrivateInputs>) {
+    return [fields.publicTubeProofData, fields.avmProofData, fields.hints] as const;
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PublicTxBaseRollupPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PublicTxBaseRollupPrivateInputs(
+      ProofData.fromBuffer(reader, PublicTubePublicInputs),
+      ProofData.fromBuffer(reader, AvmCircuitPublicInputs),
+      reader.readObject(PublicBaseRollupHints),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...PublicTxBaseRollupPrivateInputs.getFields(this));
+  }
+
+  static fromString(str: string) {
+    return PublicTxBaseRollupPrivateInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /** Returns a representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a string. */
+  static get schema() {
+    return bufferSchemaFor(PublicTxBaseRollupPrivateInputs);
+  }
+}

package/src/rollup/root_rollup_private_inputs.ts

@@ -0,0 +1,90 @@
+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 { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
+import { CheckpointRollupPublicInputs } from './checkpoint_rollup_public_inputs.js';
+
+/**
+ * Represents inputs of the root rollup circuit.
+ */
+export class RootRollupPrivateInputs {
+  constructor(
+    /**
+     * The previous rollup data.
+     * Note: Root rollup circuit is the latest circuit the chain of circuits and the previous rollup data is the data
+     * from 2 checkpoint root/merge/padding circuits.
+     */
+    public previousRollups: [
+      RollupHonkProofData<CheckpointRollupPublicInputs>,
+      RollupHonkProofData<CheckpointRollupPublicInputs>,
+    ],
+  ) {}
+
+  /**
+   * Serializes the inputs to a buffer.
+   * @returns - The inputs serialized to a buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(...RootRollupPrivateInputs.getFields(this));
+  }
+
+  /**
+   * Serializes the inputs to a hex string.
+   * @returns The instance serialized to a hex string.
+   */
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /**
+   * Creates a new instance from fields.
+   * @param fields - Fields to create the instance from.
+   * @returns A new RootRollupPrivateInputs instance.
+   */
+  static from(fields: FieldsOf<RootRollupPrivateInputs>) {
+    return new RootRollupPrivateInputs(...RootRollupPrivateInputs.getFields(fields));
+  }
+
+  /**
+   * Extracts fields from an instance.
+   * @param fields - Fields to create the instance from.
+   * @returns An array of fields.
+   */
+  static getFields(fields: FieldsOf<RootRollupPrivateInputs>) {
+    return [fields.previousRollups] as const;
+  }
+
+  /**
+   * Deserializes the inputs from a buffer.
+   * @param buffer - A buffer to deserialize from.
+   * @returns A new RootRollupPrivateInputs instance.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new RootRollupPrivateInputs([
+      ProofData.fromBuffer(reader, CheckpointRollupPublicInputs),
+      ProofData.fromBuffer(reader, CheckpointRollupPublicInputs),
+    ]);
+  }
+
+  /**
+   * Deserializes the inputs from a hex string.
+   * @param str - A hex string to deserialize from.
+   * @returns A new RootRollupPrivateInputs instance.
+   */
+  static fromString(str: string) {
+    return RootRollupPrivateInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  /** Returns a representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a string. */
+  static get schema() {
+    return bufferSchemaFor(RootRollupPrivateInputs);
+  }
+}

package/src/rollup/root_rollup_public_inputs.ts

@@ -0,0 +1,99 @@
+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 { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, type Tuple, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { FeeRecipient } from './checkpoint_rollup_public_inputs.js';
+import { EpochConstantData } from './epoch_constant_data.js';
+
+/**
+ * Represents public inputs of the root rollup circuit.
+ *
+ * NOTE: in practice, we'll hash all of this up into a single public input, for cheap onchain verification.
+ */
+export class RootRollupPublicInputs {
+  constructor(
+    /** Root of the archive tree before this rollup is processed */
+    public previousArchiveRoot: Fr,
+    /** Root of the archive tree after this rollup is processed */
+    public endArchiveRoot: Fr,
+    public checkpointHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public constants: EpochConstantData,
+    public blobPublicInputs: FinalBlobAccumulator,
+  ) {}
+
+  static getFields(fields: FieldsOf<RootRollupPublicInputs>) {
+    return [
+      fields.previousArchiveRoot,
+      fields.endArchiveRoot,
+      fields.checkpointHeaderHashes,
+      fields.fees,
+      fields.constants,
+      fields.blobPublicInputs,
+    ] as const;
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...RootRollupPublicInputs.getFields(this));
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(...RootRollupPublicInputs.getFields(this));
+  }
+
+  static from(fields: FieldsOf<RootRollupPublicInputs>): RootRollupPublicInputs {
+    return new RootRollupPublicInputs(...RootRollupPublicInputs.getFields(fields));
+  }
+
+  /**
+   * Deserializes a buffer into a `RootRollupPublicInputs` object.
+   * @param buffer - The buffer to deserialize.
+   * @returns The deserialized `RootRollupPublicInputs` object.
+   */
+  public static fromBuffer(buffer: Buffer | BufferReader): RootRollupPublicInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new RootRollupPublicInputs(
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
+      reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
+      EpochConstantData.fromBuffer(reader),
+      reader.readObject(FinalBlobAccumulator),
+    );
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string) {
+    return RootRollupPublicInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  /** Returns a representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a string. */
+  static get schema() {
+    return bufferSchemaFor(RootRollupPublicInputs);
+  }
+
+  /** Creates a random instance. Used for testing only - will not prove/verify. */
+  static random() {
+    return new RootRollupPublicInputs(
+      Fr.random(),
+      Fr.random(),
+      makeTuple(AZTEC_MAX_EPOCH_DURATION, Fr.random),
+      makeTuple(AZTEC_MAX_EPOCH_DURATION, FeeRecipient.random),
+      new EpochConstantData(Fr.random(), Fr.random(), Fr.random(), Fr.random(), Fr.random()),
+      FinalBlobAccumulator.random(),
+    );
+  }
+}

package/src/rollup/{state_diff_hints.ts → tree_snapshot_diff_hints.ts}

@@ -1,7 +1,7 @@
 import {
   MAX_NULLIFIERS_PER_TX,
-  NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH,
-  NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH,
+  NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
+  NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
   NULLIFIER_TREE_HEIGHT,
   PUBLIC_DATA_TREE_HEIGHT,
 } from '@aztec/constants';
@@ -11,13 +11,17 @@ import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/s
 import { MembershipWitness } from '@aztec/foundation/trees';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { NullifierLeafPreimage, PublicDataTreeLeafPreimage } from '../trees/index.js';
+import { NullifierLeafPreimage } from '../trees/index.js';
 
 /**
  * Hints used while proving state diff validity for the private base rollup.
  */
-export class PrivateBaseStateDiffHints {
+export class TreeSnapshotDiffHints {
   constructor(
+    /**
+     * Sibling path "pointing to" where the new note hash subtree should be inserted into the note hash tree.
+     */
+    public noteHashSubtreeRootSiblingPath: Tuple<Fr, typeof NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH>,
     /**
      * The nullifiers which need to be updated to perform the batch insertion of the new nullifiers.
      * See `StandardIndexedTree.batchInsert` function for more details.
@@ -39,44 +43,29 @@ export class PrivateBaseStateDiffHints {
      * The indexes of the sorted nullifiers to the original ones.
      */
     public sortedNullifierIndexes: Tuple<number, typeof MAX_NULLIFIERS_PER_TX>,
-    /**
-     * Sibling path "pointing to" where the new note hash subtree should be inserted into the note hash tree.
-     */
-    public noteHashSubtreeSiblingPath: Tuple<Fr, typeof NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH>,
     /**
      * Sibling path "pointing to" where the new nullifiers subtree should be inserted into the nullifier tree.
      */
-    public nullifierSubtreeSiblingPath: Tuple<Fr, typeof NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH>,
-
-    /**
-     * Low leaf for the fee write in the public data tree.
-     */
-    public feeWriteLowLeafPreimage: PublicDataTreeLeafPreimage,
-    /**
-     * Membership witness for the low leaf for the fee write in the public data tree.
-     */
-    public feeWriteLowLeafMembershipWitness: MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT>,
+    public nullifierSubtreeRootSiblingPath: Tuple<Fr, typeof NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH>,
     /**
-     * Sibling path "pointing to" where the fee write should be inserted into the public data tree.
+     * Membership witness for the fee payer's balance leaf in the public data tree.
      */
-    public feeWriteSiblingPath: Tuple<Fr, typeof PUBLIC_DATA_TREE_HEIGHT>,
+    public feePayerBalanceMembershipWitness: MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT>,
   ) {}
 
-  static from(fields: FieldsOf<PrivateBaseStateDiffHints>): PrivateBaseStateDiffHints {
-    return new PrivateBaseStateDiffHints(...PrivateBaseStateDiffHints.getFields(fields));
+  static from(fields: FieldsOf<TreeSnapshotDiffHints>): TreeSnapshotDiffHints {
+    return new TreeSnapshotDiffHints(...TreeSnapshotDiffHints.getFields(fields));
   }
 
-  static getFields(fields: FieldsOf<PrivateBaseStateDiffHints>) {
+  static getFields(fields: FieldsOf<TreeSnapshotDiffHints>) {
     return [
+      fields.noteHashSubtreeRootSiblingPath,
       fields.nullifierPredecessorPreimages,
       fields.nullifierPredecessorMembershipWitnesses,
       fields.sortedNullifiers,
       fields.sortedNullifierIndexes,
-      fields.noteHashSubtreeSiblingPath,
-      fields.nullifierSubtreeSiblingPath,
-      fields.feeWriteLowLeafPreimage,
-      fields.feeWriteLowLeafMembershipWitness,
-      fields.feeWriteSiblingPath,
+      fields.nullifierSubtreeRootSiblingPath,
+      fields.feePayerBalanceMembershipWitness,
     ] as const;
   }
 
@@ -85,42 +74,38 @@ export class PrivateBaseStateDiffHints {
    * @returns A buffer of the serialized state diff hints.
    */
   toBuffer(): Buffer {
-    return serializeToBuffer(...PrivateBaseStateDiffHints.getFields(this));
+    return serializeToBuffer(...TreeSnapshotDiffHints.getFields(this));
   }
 
   /**
    * Deserializes the state diff hints from a buffer.
    * @param buffer - A buffer to deserialize from.
-   * @returns A new PrivateBaseStateDiffHints instance.
+   * @returns A new TreeSnapshotDiffHints instance.
    */
-  static fromBuffer(buffer: Buffer | BufferReader): PrivateBaseStateDiffHints {
+  static fromBuffer(buffer: Buffer | BufferReader): TreeSnapshotDiffHints {
     const reader = BufferReader.asReader(buffer);
-    return new PrivateBaseStateDiffHints(
+    return new TreeSnapshotDiffHints(
+      reader.readArray(NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
       reader.readArray(MAX_NULLIFIERS_PER_TX, NullifierLeafPreimage),
       reader.readArray(MAX_NULLIFIERS_PER_TX, {
         fromBuffer: buffer => MembershipWitness.fromBuffer(buffer, NULLIFIER_TREE_HEIGHT),
       }),
       reader.readArray(MAX_NULLIFIERS_PER_TX, Fr),
       reader.readNumbers(MAX_NULLIFIERS_PER_TX),
-      reader.readArray(NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, Fr),
-      reader.readArray(NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, Fr),
-      reader.readObject(PublicDataTreeLeafPreimage),
+      reader.readArray(NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
       MembershipWitness.fromBuffer(reader, PUBLIC_DATA_TREE_HEIGHT),
-      reader.readArray(PUBLIC_DATA_TREE_HEIGHT, Fr),
     );
   }
 
   static empty() {
-    return new PrivateBaseStateDiffHints(
+    return new TreeSnapshotDiffHints(
+      makeTuple(NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr.zero),
       makeTuple(MAX_NULLIFIERS_PER_TX, NullifierLeafPreimage.empty),
       makeTuple(MAX_NULLIFIERS_PER_TX, () => MembershipWitness.empty(NULLIFIER_TREE_HEIGHT)),
       makeTuple(MAX_NULLIFIERS_PER_TX, Fr.zero),
       makeTuple(MAX_NULLIFIERS_PER_TX, () => 0),
-      makeTuple(NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, Fr.zero),
-      makeTuple(NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, Fr.zero),
-      PublicDataTreeLeafPreimage.empty(),
+      makeTuple(NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr.zero),
       MembershipWitness.empty(PUBLIC_DATA_TREE_HEIGHT),
-      makeTuple(PUBLIC_DATA_TREE_HEIGHT, Fr.zero),
     );
   }
 }

package/src/rollup/{merge_rollup.ts → tx_merge_rollup_private_inputs.ts}

@@ -2,17 +2,18 @@ import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
-import { PreviousRollupData } from './previous_rollup_data.js';
+import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
+import { TxRollupPublicInputs } from './tx_rollup_public_inputs.js';
 
 /**
  * Represents inputs of the merge rollup circuit.
  */
-export class MergeRollupInputs {
+export class TxMergeRollupPrivateInputs {
   constructor(
     /**
      * Previous rollup data from the 2 merge or base rollup circuits that preceded this merge rollup circuit.
      */
-    public previousRollupData: [PreviousRollupData, PreviousRollupData],
+    public previousRollups: [RollupHonkProofData<TxRollupPublicInputs>, RollupHonkProofData<TxRollupPublicInputs>],
   ) {}
 
   /**
@@ -20,7 +21,7 @@ export class MergeRollupInputs {
    * @returns The inputs serialized to a buffer.
    */
   toBuffer() {
-    return serializeToBuffer(this.previousRollupData);
+    return serializeToBuffer(this.previousRollups);
   }
 
   /**
@@ -34,20 +35,23 @@ export class MergeRollupInputs {
   /**
    * Deserializes the inputs from a buffer.
    * @param buffer - The buffer to deserialize from.
-   * @returns A new MergeRollupInputs instance.
+   * @returns A new TxMergeRollupPrivateInputs instance.
    */
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new MergeRollupInputs([reader.readObject(PreviousRollupData), reader.readObject(PreviousRollupData)]);
+    return new TxMergeRollupPrivateInputs([
+      ProofData.fromBuffer(reader, TxRollupPublicInputs),
+      ProofData.fromBuffer(reader, TxRollupPublicInputs),
+    ]);
   }
 
   /**
    * Deserializes the inputs from a hex string.
    * @param str - A hex string to deserialize from.
-   * @returns A new MergeRollupInputs instance.
+   * @returns A new TxMergeRollupPrivateInputs instance.
    */
   static fromString(str: string) {
-    return MergeRollupInputs.fromBuffer(hexToBuffer(str));
+    return TxMergeRollupPrivateInputs.fromBuffer(hexToBuffer(str));
   }
 
   /** Returns a buffer representation for JSON serialization. */
@@ -57,6 +61,6 @@ export class MergeRollupInputs {
 
   /** Creates an instance from a string. */
   static get schema() {
-    return bufferSchemaFor(MergeRollupInputs);
+    return bufferSchemaFor(TxMergeRollupPrivateInputs);
   }
 }

package/src/rollup/{base_or_merge_rollup_public_inputs.ts → tx_rollup_public_inputs.ts}

@@ -1,4 +1,4 @@
-import { SpongeBlob } from '@aztec/blob-lib';
+import { SpongeBlob } from '@aztec/blob-lib/types';
 import { Fr } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
@@ -10,7 +10,7 @@ import { BlockConstantData } from './block_constant_data.js';
 /**
  * Output of the base and merge rollup circuits.
  */
-export class BaseOrMergeRollupPublicInputs {
+export class TxRollupPublicInputs {
   constructor(
     /**
      * Number of txs in this rollup.
@@ -23,11 +23,11 @@ export class BaseOrMergeRollupPublicInputs {
     /**
      * Partial state reference at the start of the rollup circuit.
      */
-    public start: PartialStateReference,
+    public startTreeSnapshots: PartialStateReference,
     /**
      * Partial state reference at the end of the rollup circuit.
      */
-    public end: PartialStateReference,
+    public endTreeSnapshots: PartialStateReference,
     /**
      * Sponge state to absorb blob inputs at the start of the rollup circuit.
      */
@@ -37,7 +37,7 @@ export class BaseOrMergeRollupPublicInputs {
      */
     public endSpongeBlob: SpongeBlob,
     /**
-     * SHA256 hash of L2 to L1 messages. Used to make public inputs constant-sized (to then be opened on-chain).
+     * SHA256 hash of L2 to L1 messages. Used to make public inputs constant-sized (to then be opened onchain).
      * Note: Truncated to 31 bytes to fit in Fr.
      */
     public outHash: Fr,
@@ -53,7 +53,7 @@ export class BaseOrMergeRollupPublicInputs {
 
   /** Returns an empty instance. */
   static empty() {
-    return new BaseOrMergeRollupPublicInputs(
+    return new TxRollupPublicInputs(
       0,
       BlockConstantData.empty(),
       PartialStateReference.empty(),
@@ -72,9 +72,9 @@ export class BaseOrMergeRollupPublicInputs {
    * @param buffer - Buffer or reader to read from.
    * @returns The deserialized public inputs.
    */
-  static fromBuffer(buffer: Buffer | BufferReader): BaseOrMergeRollupPublicInputs {
+  static fromBuffer(buffer: Buffer | BufferReader): TxRollupPublicInputs {
     const reader = BufferReader.asReader(buffer);
-    return new BaseOrMergeRollupPublicInputs(
+    return new TxRollupPublicInputs(
       reader.readNumber(),
       reader.readObject(BlockConstantData),
       reader.readObject(PartialStateReference),
@@ -96,8 +96,8 @@ export class BaseOrMergeRollupPublicInputs {
       this.numTxs,
       this.constants,
 
-      this.start,
-      this.end,
+      this.startTreeSnapshots,
+      this.endTreeSnapshots,
 
       this.startSpongeBlob,
       this.endSpongeBlob,
@@ -120,10 +120,10 @@ export class BaseOrMergeRollupPublicInputs {
   /**
    * Deserializes from a hex string.
    * @param str - A hex string to deserialize from.
-   * @returns A new BaseOrMergeRollupPublicInputs instance.
+   * @returns A new TxRollupPublicInputs instance.
    */
   static fromString(str: string) {
-    return BaseOrMergeRollupPublicInputs.fromBuffer(hexToBuffer(str));
+    return TxRollupPublicInputs.fromBuffer(hexToBuffer(str));
   }
 
   /** Returns a buffer representation for JSON serialization. */
@@ -133,6 +133,6 @@ export class BaseOrMergeRollupPublicInputs {
 
   /** Creates an instance from a hex string. */
   static get schema() {
-    return bufferSchemaFor(BaseOrMergeRollupPublicInputs);
+    return bufferSchemaFor(TxRollupPublicInputs);
   }
 }

package/src/slashing/types.ts

@@ -22,6 +22,29 @@ export enum OffenseType {
   ATTESTED_DESCENDANT_OF_INVALID = 7,
 }
 
+export function getOffenseTypeName(offense: OffenseType) {
+  switch (offense) {
+    case OffenseType.UNKNOWN:
+      return 'unknown';
+    case OffenseType.DATA_WITHHOLDING:
+      return 'data_withholding';
+    case OffenseType.VALID_EPOCH_PRUNED:
+      return 'valid_epoch_pruned';
+    case OffenseType.INACTIVITY:
+      return 'inactivity';
+    case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
+      return 'broadcasted_invalid_block_proposal';
+    case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
+      return 'proposed_insufficient_attestations';
+    case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
+      return 'proposed_incorrect_attestations';
+    case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
+      return 'attested_descendant_of_invalid';
+    default:
+      throw new Error(`Unknown offense type: ${offense}`);
+  }
+}
+
 export const OffenseTypeSchema = z.nativeEnum(OffenseType);
 
 export const OffenseToBigInt: Record<OffenseType, bigint> = {

package/src/snapshots/download.ts

@@ -2,6 +2,12 @@ import { fromEntries, getEntries, maxBy } from '@aztec/foundation/collection';
 import { jsonParseWithSchema } from '@aztec/foundation/json-rpc';
 import type { ReadOnlyFileStore } from '@aztec/stdlib/file-store';
 
+import { createReadStream, createWriteStream } from 'fs';
+import fs from 'fs/promises';
+import pathMod from 'path';
+import { pipeline } from 'stream/promises';
+import { createGunzip, gunzipSync } from 'zlib';
+
 import {
   SnapshotDataKeys,
   type SnapshotDataUrls,
@@ -20,7 +26,8 @@ export async function getSnapshotIndex(
   try {
     if (await store.exists(snapshotIndexPath)) {
       const snapshotIndexData = await store.read(snapshotIndexPath);
-      return jsonParseWithSchema(snapshotIndexData.toString(), SnapshotsIndexSchema);
+      const buf = maybeGunzip(snapshotIndexData);
+      return jsonParseWithSchema(buf.toString('utf-8'), SnapshotsIndexSchema);
     } else {
       return undefined;
     }
@@ -50,10 +57,67 @@ export function makeSnapshotPaths(baseDir: string): SnapshotDataUrls {
   return fromEntries(SnapshotDataKeys.map(key => [key, `${baseDir}/${key}.db`]));
 }
 
+function isGzipMagic(data: Buffer): boolean {
+  return data.length >= 2 && data[0] === 0x1f && data[1] === 0x8b;
+}
+
+function maybeGunzip(data: Buffer): Buffer {
+  const magicNumberIndicatesGzip = isGzipMagic(data);
+
+  if (magicNumberIndicatesGzip) {
+    try {
+      const out = gunzipSync(data);
+      return out;
+    } catch (err) {
+      throw new Error(`Decompression of gzipped data failed: ${(err as Error).message}`);
+    }
+  }
+  return data;
+}
+
+async function detectGzip(localFilePathToPeek: string): Promise<boolean> {
+  // Peek the actual bytes we downloaded.
+  try {
+    const fd = await fs.open(localFilePathToPeek, 'r');
+    try {
+      const header = Buffer.alloc(2);
+      const { bytesRead } = await fd.read(header, 0, 2, 0);
+      return bytesRead >= 2 && isGzipMagic(header);
+    } finally {
+      await fd.close();
+    }
+  } catch {
+    return false;
+  }
+}
+
 export async function downloadSnapshot(
   snapshot: Pick<SnapshotMetadata, 'dataUrls'>,
   localPaths: Record<SnapshotDataKeys, string>,
   store: ReadOnlyFileStore,
 ): Promise<void> {
-  await Promise.all(getEntries(localPaths).map(([key, path]) => store.download(snapshot.dataUrls[key], path)));
+  await Promise.all(
+    getEntries(localPaths).map(async ([key, path]) => {
+      await fs.mkdir(pathMod.dirname(path), { recursive: true });
+
+      const tmpPath = `${path}.download`;
+      try {
+        const url = snapshot.dataUrls[key];
+        await store.download(url, tmpPath);
+
+        const isGzip = await detectGzip(tmpPath);
+
+        const read = createReadStream(tmpPath);
+        const write = createWriteStream(path);
+        if (isGzip) {
+          const gunzip = createGunzip();
+          await pipeline(read, gunzip, write);
+        } else {
+          await pipeline(read, write);
+        }
+      } finally {
+        await fs.unlink(tmpPath).catch(() => undefined);
+      }
+    }),
+  );
 }

package/src/snapshots/upload.ts

@@ -48,6 +48,7 @@ export async function uploadSnapshotToIndex(
 
   await store.save(getSnapshotIndexPath(metadata), Buffer.from(jsonStringify(snapshotsIndex, true)), {
     public: true, // Make the index publicly accessible
+    compress: false, // Ensure index.json is not gzipped
     metadata: { ['Cache-control']: 'no-store' }, // Do not cache object versions
   });
   return newSnapshotMetadata;