@aztec/stdlib 3.0.0-canary.a9708bd → 3.0.0-manual.20251030

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;

package/src/stats/stats.ts

@@ -86,20 +86,26 @@ export type ClientCircuitName =
   | 'app-circuit';
 
 export type ServerCircuitName =
-  | 'base-parity'
-  | 'root-parity'
-  | 'private-base-rollup'
-  | 'public-base-rollup'
-  | 'merge-rollup'
-  | 'block-root-rollup'
-  | 'single-tx-block-root-rollup'
-  | 'empty-block-root-rollup'
-  | 'padding-block-root-rollup'
-  | 'block-merge-rollup'
-  | 'root-rollup'
-  | 'avm-circuit'
-  | 'tube-circuit';
+  | 'parity-base'
+  | 'parity-root'
+  | 'chonk-verifier-public'
+  | 'rollup-tx-base-private'
+  | 'rollup-tx-base-public'
+  | 'rollup-tx-merge'
+  | 'rollup-block-root-first'
+  | 'rollup-block-root-first-single-tx'
+  | 'rollup-block-root-first-empty-tx'
+  | 'rollup-block-root'
+  | 'rollup-block-root-single-tx'
+  | 'rollup-block-merge'
+  | 'rollup-checkpoint-root'
+  | 'rollup-checkpoint-root-single-block'
+  | 'rollup-checkpoint-padding'
+  | 'rollup-checkpoint-merge'
+  | 'rollup-root'
+  | 'avm-circuit';
 
+// Circuit names should match the corresponding names in noir-protocol-circuits.
 export type CircuitName = ClientCircuitName | ServerCircuitName;
 
 /** Stats for circuit simulation. */
@@ -175,8 +181,8 @@ export type CircuitVerificationStats = {
   eventName: 'circuit-verification';
   /** Name of the circuit. */
   circuitName: CircuitName;
-  /** Type of proof (client-ivc, honk, etc) */
-  proofType: 'client-ivc' | 'ultra-honk';
+  /** Type of proof (chonk, honk, etc) */
+  proofType: 'chonk' | 'ultra-honk';
   /** Duration in ms. */
   duration: number;
 };