@aztec/stdlib 3.0.0-nightly.20250925 → 3.0.0-nightly.20250927

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/stdlib",
-  "version": "3.0.0-nightly.20250925",
+  "version": "3.0.0-nightly.20250927",
   "type": "module",
   "inherits": [
     "../package.common.json",
@@ -69,13 +69,14 @@
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
   "dependencies": {
-    "@aztec/bb.js": "3.0.0-nightly.20250925",
-    "@aztec/blob-lib": "3.0.0-nightly.20250925",
-    "@aztec/constants": "3.0.0-nightly.20250925",
-    "@aztec/ethereum": "3.0.0-nightly.20250925",
-    "@aztec/foundation": "3.0.0-nightly.20250925",
-    "@aztec/l1-artifacts": "3.0.0-nightly.20250925",
-    "@aztec/noir-noirc_abi": "3.0.0-nightly.20250925",
+    "@aws-sdk/client-s3": "^3.892.0",
+    "@aztec/bb.js": "3.0.0-nightly.20250927",
+    "@aztec/blob-lib": "3.0.0-nightly.20250927",
+    "@aztec/constants": "3.0.0-nightly.20250927",
+    "@aztec/ethereum": "3.0.0-nightly.20250927",
+    "@aztec/foundation": "3.0.0-nightly.20250927",
+    "@aztec/l1-artifacts": "3.0.0-nightly.20250927",
+    "@aztec/noir-noirc_abi": "3.0.0-nightly.20250927",
     "@google-cloud/storage": "^7.15.0",
     "axios": "^1.9.0",
     "json-stringify-deterministic": "1.0.12",

package/src/abi/event_metadata_definition.ts

@@ -0,0 +1,8 @@
+import type { AbiType } from './abi.js';
+import type { EventSelector } from './event_selector.js';
+
+export type EventMetadataDefinition = {
+  eventSelector: EventSelector;
+  abiType: AbiType;
+  fieldNames: string[];
+};

package/src/abi/index.ts

@@ -3,6 +3,7 @@ export * from './buffer.js';
 export * from './decoder.js';
 export * from './encoder.js';
 export * from './authorization_selector.js';
+export * from './event_metadata_definition.js';
 export * from './event_selector.js';
 export * from './function_selector.js';
 export * from './note_selector.js';

package/src/avm/avm_accumulated_data.ts

@@ -22,6 +22,7 @@ import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import { inspect } from 'util';
 import { z } from 'zod';
 
+import { countAccumulatedItems } from '../kernel/utils/index.js';
 import { FlatPublicLogs } from '../logs/public_log.js';
 import { ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
 import { PublicDataWrite } from './public_data_write.js';
@@ -184,6 +185,15 @@ export class AvmAccumulatedData {
     .join(', ')}],
 }`;
   }
+
+  getArrayLengths() {
+    return new AvmAccumulatedDataArrayLengths(
+      countAccumulatedItems(this.noteHashes),
+      countAccumulatedItems(this.nullifiers),
+      countAccumulatedItems(this.l2ToL1Msgs),
+      countAccumulatedItems(this.publicDataWrites),
+    );
+  }
 }
 
 /**

package/src/avm/index.ts

@@ -3,7 +3,6 @@ export * from './avm_accumulated_data.js';
 export * from './avm_circuit_public_inputs.js';
 export * from './revert_code.js';
 export * from './public_data_write.js';
-export * from './public_data_hint.js';
 export * from './public_data_update_request.js';
 export * from './contract_storage_update_request.js';
 export * from './contract_storage_read.js';

package/src/block/body.ts

@@ -19,13 +19,7 @@ export function getBlockBlobFields(txEffects: TxEffect[]) {
 }
 
 export class Body {
-  constructor(public txEffects: TxEffect[]) {
-    txEffects.forEach(txEffect => {
-      if (txEffect.isEmpty()) {
-        throw new Error('Empty tx effect not allowed in Body');
-      }
-    });
-  }
+  constructor(public txEffects: TxEffect[]) {}
 
   equals(other: Body) {
     return (

package/src/contract/contract_class_metadata.ts

@@ -0,0 +1,8 @@
+import type { ContractArtifact } from '../abi/abi.js';
+import type { ContractClassWithId } from './interfaces/contract_class.js';
+
+export interface ContractClassMetadata {
+  contractClass?: ContractClassWithId | undefined;
+  isContractClassPubliclyRegistered: boolean;
+  artifact?: ContractArtifact | undefined;
+}

package/src/contract/contract_metadata.ts

@@ -0,0 +1,7 @@
+import type { ContractInstanceWithAddress } from './interfaces/contract_instance.js';
+
+export interface ContractMetadata {
+  contractInstance?: ContractInstanceWithAddress | undefined;
+  isContractInitialized: boolean;
+  isContractPublished: boolean;
+}

package/src/contract/index.ts

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

package/src/file-store/factory.ts

@@ -4,9 +4,11 @@ import { GoogleCloudFileStore } from './gcs.js';
 import { HttpFileStore } from './http.js';
 import type { FileStore, ReadOnlyFileStore } from './interface.js';
 import { LocalFileStore } from './local.js';
+import { S3FileStore } from './s3.js';
 
 const supportedExamples = [
   `gs://bucket-name/path/to/store`,
+  `s3://bucket-name/path/to/store`,
   `file:///absolute/local/path/to/store`,
   `https://host/path`,
 ];
@@ -39,6 +41,19 @@ export async function createFileStore(
     } catch {
       throw new Error(`Invalid google cloud store definition: '${config}'.`);
     }
+  } else if (config.startsWith('s3://')) {
+    try {
+      const url = new URL(config);
+      const bucket = url.host;
+      const path = url.pathname.replace(/^\/+/, '');
+      const endpoint = url.searchParams.get('endpoint');
+      const publicBaseUrl = url.searchParams.get('publicBaseUrl') ?? undefined;
+      logger.info(`Creating S3 file store at ${bucket} ${path}`);
+      const store = new S3FileStore(bucket, path, { endpoint: endpoint ?? undefined, publicBaseUrl });
+      return store;
+    } catch {
+      throw new Error(`Invalid S3 store definition: '${config}'.`);
+    }
   } else {
     throw new Error(`Unknown file store config: '${config}'. Supported values are ${supportedExamples.join(', ')}.`);
   }

package/src/file-store/s3.ts

@@ -0,0 +1,186 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+
+import {
+  GetObjectCommand,
+  type GetObjectCommandOutput,
+  HeadObjectCommand,
+  PutObjectCommand,
+  S3Client,
+} from '@aws-sdk/client-s3';
+import { createReadStream, createWriteStream } from 'fs';
+import { mkdir } from 'fs/promises';
+import { dirname, join } from 'path';
+import { Readable } from 'stream';
+import { finished } from 'stream/promises';
+import { createGzip } from 'zlib';
+
+import type { FileStore, FileStoreSaveOptions } from './interface.js';
+
+function normalizeBasePath(path: string): string {
+  return path?.replace(/^\/+|\/+$/g, '') ?? '';
+}
+
+export class S3FileStore implements FileStore {
+  private readonly s3: S3Client;
+  private readonly region: string;
+  private readonly endpoint?: string;
+  private readonly publicBaseUrl?: string;
+
+  constructor(
+    private readonly bucketName: string,
+    private readonly basePath: string,
+    opts: { endpoint?: string; publicBaseUrl?: string },
+    private readonly log: Logger = createLogger('stdlib:s3-file-store'),
+  ) {
+    this.endpoint = opts.endpoint;
+    this.region = this.endpoint ? 'auto' : (process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1');
+    this.publicBaseUrl = opts.publicBaseUrl;
+
+    const clientOptions: any = {};
+    if (this.endpoint) {
+      clientOptions.region = 'auto';
+      clientOptions.endpoint = this.endpoint;
+      clientOptions.forcePathStyle = true;
+    } else {
+      clientOptions.region = this.region;
+    }
+    this.s3 = new S3Client(clientOptions);
+  }
+
+  public async save(path: string, data: Buffer, opts: FileStoreSaveOptions = {}): Promise<string> {
+    const key = this.getFullPath(path);
+    const shouldCompress = !opts.compress;
+    const body = shouldCompress ? (await import('zlib')).gzipSync(data) : data;
+    const put = new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      Body: body,
+      ContentEncoding: shouldCompress ? 'gzip' : undefined,
+      CacheControl: opts.metadata?.['Cache-control'],
+      Metadata: this.extractUserMetadata(opts.metadata),
+    });
+    await this.s3.send(put);
+    return this.buildReturnedUrl(key, !!opts.public);
+  }
+
+  public async upload(destPath: string, srcPath: string, opts: FileStoreSaveOptions = {}): Promise<string> {
+    const key = this.getFullPath(destPath);
+    const shouldCompress = opts.compress !== false; // default true like GCS impl
+
+    await mkdir(dirname(srcPath), { recursive: true }).catch(() => undefined);
+
+    const source = createReadStream(srcPath);
+    const bodyStream = shouldCompress ? source.pipe(createGzip()) : source;
+    const put = new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      Body: bodyStream as any,
+      ContentEncoding: shouldCompress ? 'gzip' : undefined,
+      CacheControl: opts.metadata?.['Cache-control'],
+      Metadata: this.extractUserMetadata(opts.metadata),
+    });
+    await this.s3.send(put);
+    return this.buildReturnedUrl(key, !!opts.public);
+  }
+
+  public async read(pathOrUrlStr: string): Promise<Buffer> {
+    const { bucket, key } = this.getBucketAndKey(pathOrUrlStr);
+    const out: GetObjectCommandOutput = await this.s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+    const stream = out.Body as Readable;
+    const chunks: Buffer[] = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+  }
+
+  public async download(pathOrUrlStr: string, destPath: string): Promise<void> {
+    const { bucket, key } = this.getBucketAndKey(pathOrUrlStr);
+    const out: GetObjectCommandOutput = await this.s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+    await mkdir(dirname(destPath), { recursive: true });
+    const write = createWriteStream(destPath);
+    await finished((out.Body as Readable).pipe(write));
+  }
+
+  public async exists(pathOrUrlStr: string): Promise<boolean> {
+    try {
+      const { bucket, key } = this.getBucketAndKey(pathOrUrlStr);
+      await this.s3.send(new HeadObjectCommand({ Bucket: bucket, Key: key }));
+      return true;
+    } catch (err: any) {
+      const code = err?.$metadata?.httpStatusCode ?? err?.name ?? err?.Code;
+      if (code === 404 || code === 'NotFound' || code === 'NoSuchKey') {
+        return false;
+      }
+      this.log.warn(`Error checking existence for ${pathOrUrlStr}: ${err?.message ?? String(err)}`);
+      return false;
+    }
+  }
+
+  private extractUserMetadata(meta?: Record<string, string>): Record<string, string> | undefined {
+    if (!meta) {
+      return undefined;
+    }
+    const { ['Cache-control']: _ignored, ...rest } = meta;
+    return Object.keys(rest).length ? rest : undefined;
+  }
+
+  private buildReturnedUrl(key: string, makePublic: boolean): string {
+    if (!makePublic) {
+      return `s3://${this.bucketName}/${key}`;
+    }
+
+    if (this.publicBaseUrl) {
+      const base = this.publicBaseUrl.replace(/\/$/, '');
+      // key already includes basePath via getFullPath, so do not prefix basePath again
+      const full = key.replace(/^\/+/, '');
+      return `${base}/${full}`;
+    }
+
+    // Try to synthesize a URL from endpoint if available (works for public R2 buckets)
+    if (this.endpoint) {
+      try {
+        const url = new URL(this.endpoint);
+        return `https://${this.bucketName}.${url.host}/${key}`;
+      } catch {
+        // fallthrough
+      }
+    }
+
+    // Fallback to AWS style URL if region looks valid
+    return `https://${this.bucketName}.s3.${this.region}.amazonaws.com/${key}`;
+  }
+
+  private getBucketAndKey(pathOrUrlStr: string): { bucket: string; key: string } {
+    if (URL.canParse(pathOrUrlStr)) {
+      const url = new URL(pathOrUrlStr);
+      if (url.protocol === 's3:') {
+        return { bucket: url.host, key: url.pathname.replace(/^\/+/, '') };
+      }
+      // For https URLs, try to infer virtual-hosted or path-style
+      if (url.protocol === 'https:' || url.protocol === 'http:') {
+        // If the URL matches the configured publicBaseUrl host, map back to our bucket and key
+        if (this.publicBaseUrl && url.host === new URL(this.publicBaseUrl).host) {
+          return { bucket: this.bucketName, key: url.pathname.replace(/^\/+/, '') };
+        }
+        const hostParts = url.host.split('.');
+        if (hostParts.length > 3 && (hostParts[1] === 's3' || hostParts[hostParts.length - 2] === 'r2')) {
+          // virtual hosted
+          return { bucket: hostParts[0], key: url.pathname.replace(/^\/+/, '') };
+        } else if (this.endpoint && url.host === new URL(this.endpoint).host) {
+          // path-style at custom endpoint
+          const [bucket, ...rest] = url.pathname.replace(/^\/+/, '').split('/');
+          return { bucket, key: rest.join('/') };
+        }
+      }
+    }
+    // Treat as path
+    return { bucket: this.bucketName, key: this.getFullPath(pathOrUrlStr) };
+  }
+
+  private getFullPath(path: string): string {
+    const base = normalizeBasePath(this.basePath);
+    const rel = path.replace(/^\/+/, '');
+    return base ? join(base, rel) : rel;
+  }
+}

package/src/interfaces/client.ts

@@ -1,4 +1,3 @@
-export * from './pxe.js';
 export * from './aztec-node.js';
 export * from './aztec-node-admin.js';
 export * from './private_kernel_prover.js';

package/src/interfaces/proving-job.ts

@@ -10,7 +10,6 @@ import { z } from 'zod';
 
 import { AvmCircuitInputs } from '../avm/avm.js';
 import { AvmProvingRequestSchema } from '../avm/avm_proving_request.js';
-import { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
 import { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js';
 import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
 import { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js';
@@ -32,8 +31,9 @@ import {
   CheckpointRootRollupPrivateInputs,
   CheckpointRootSingleBlockRollupPrivateInputs,
 } from '../rollup/checkpoint_root_rollup_private_inputs.js';
-import { PublicTubePrivateInputs } from '../rollup/index.js';
 import { PrivateTxBaseRollupPrivateInputs } from '../rollup/private_tx_base_rollup_private_inputs.js';
+import { PublicTubePrivateInputs } from '../rollup/public_tube_private_inputs.js';
+import { PublicTubePublicInputs } from '../rollup/public_tube_public_inputs.js';
 import { PublicTxBaseRollupPrivateInputs } from '../rollup/public_tx_base_rollup_private_inputs.js';
 import { RootRollupPrivateInputs } from '../rollup/root_rollup_private_inputs.js';
 import { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
@@ -214,7 +214,7 @@ export const ProvingJobResult = z.discriminatedUnion('type', [
   z.object({
     type: z.literal(ProvingRequestType.PUBLIC_TUBE),
     result: schemaForPublicInputsAndRecursiveProof(
-      PrivateToPublicKernelCircuitPublicInputs.schema,
+      PublicTubePublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
@@ -326,7 +326,7 @@ export type ProvingJobResult = z.infer<typeof ProvingJobResult>;
 export type ProvingJobResultsMap = {
   [ProvingRequestType.PUBLIC_VM]: ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
   [ProvingRequestType.PUBLIC_TUBE]: PublicInputsAndRecursiveProof<
-    PrivateToPublicKernelCircuitPublicInputs,
+    PublicTubePublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
   [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: PublicInputsAndRecursiveProof<

package/src/interfaces/server_circuit_prover.ts

@@ -6,7 +6,6 @@ import type {
 } from '@aztec/constants';
 
 import type { AvmCircuitInputs } from '../avm/avm.js';
-import type { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
 import type { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js';
 import type { ParityPublicInputs } from '../parity/parity_public_inputs.js';
 import type { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js';
@@ -28,6 +27,7 @@ import type {
 } from '../rollup/checkpoint_root_rollup_private_inputs.js';
 import type { PrivateTxBaseRollupPrivateInputs } from '../rollup/private_tx_base_rollup_private_inputs.js';
 import type { PublicTubePrivateInputs } from '../rollup/public_tube_private_inputs.js';
+import type { PublicTubePublicInputs } from '../rollup/public_tube_public_inputs.js';
 import type { PublicTxBaseRollupPrivateInputs } from '../rollup/public_tx_base_rollup_private_inputs.js';
 import type { RootRollupPrivateInputs } from '../rollup/root_rollup_private_inputs.js';
 import type { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
@@ -64,12 +64,7 @@ export interface ServerCircuitProver {
     inputs: PublicTubePrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<
-      PrivateToPublicKernelCircuitPublicInputs,
-      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
-    >
-  >;
+  ): Promise<PublicInputsAndRecursiveProof<PublicTubePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
 
   /**
    * Creates a proof for the given input.

package/src/interfaces/slasher.ts

@@ -24,6 +24,7 @@ export interface SlasherConfig {
   slashOffenseExpirationRounds: number; // Number of rounds after which pending offenses expire
   slashMaxPayloadSize: number; // Maximum number of offenses to include in a single slash payload
   slashGracePeriodL2Slots: number; // Number of L2 slots to wait after genesis before slashing for most offenses
+  slashExecuteRoundsLookBack: number; // How many rounds to look back when searching for a round to execute
 }
 
 export const SlasherConfigSchema = z.object({
@@ -44,5 +45,6 @@ export const SlasherConfigSchema = z.object({
   slashMaxPayloadSize: z.number(),
   slashGracePeriodL2Slots: z.number(),
   slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
+  slashExecuteRoundsLookBack: z.number(),
   slashSelfAllowed: z.boolean().optional(),
 }) satisfies ZodFor<SlasherConfig>;

package/src/interfaces/validator.ts

@@ -32,11 +32,14 @@ export interface ValidatorClientConfig {
   /** Interval between polling for new attestations from peers */
   attestationPollingIntervalMs: number;
 
-  /** Re-execute transactions before attesting */
+  /** Whether to re-execute transactions in a block proposal before attesting */
   validatorReexecute: boolean;
 
   /** Will re-execute until this many milliseconds are left in the slot */
   validatorReexecuteDeadlineMs: number;
+
+  /** Whether to always reexecute block proposals, even for non-validator nodes or when out of the currnet committee */
+  alwaysReexecuteBlockProposals?: boolean;
 }
 
 export type ValidatorClientFullConfig = ValidatorClientConfig &
@@ -50,6 +53,7 @@ export const ValidatorClientConfigSchema = z.object({
   attestationPollingIntervalMs: z.number().min(0),
   validatorReexecute: z.boolean(),
   validatorReexecuteDeadlineMs: z.number().min(0),
+  alwaysReexecuteBlockProposals: z.boolean().optional(),
 }) satisfies ZodFor<Omit<ValidatorClientConfig, 'validatorPrivateKeys'>>;
 
 export interface Validator {

package/src/logs/contract_class_log.ts

@@ -133,12 +133,11 @@ export class ContractClassLog {
   }
 
   toBlobFields(): Fr[] {
-    return [new Fr(this.emittedLength), this.contractAddress.toField()].concat(this.getEmittedFields());
+    return [this.contractAddress.toField()].concat(this.getEmittedFields());
   }
 
-  static fromBlobFields(fields: Fr[] | FieldReader) {
+  static fromBlobFields(emittedLength: number, fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    const emittedLength = reader.readU32();
     const contractAddress = reader.readObject(AztecAddress);
     const emittedFields = reader.readFieldArray(emittedLength);
     return new ContractClassLog(

package/src/rollup/avm_proof_data.ts

@@ -1,39 +1,10 @@
 import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
-import { RecursiveProof, makeEmptyRecursiveProof } from '../proofs/recursive_proof.js';
-import { VkData } from '../vks/vk_data.js';
+import type { ProofData } from '../proofs/proof_data.js';
 
-export class AvmProofData {
-  constructor(
-    public publicInputs: AvmCircuitPublicInputs,
-    public proof: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>,
-    public vkData: VkData,
-  ) {}
-
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new AvmProofData(
-      reader.readObject(AvmCircuitPublicInputs),
-      RecursiveProof.fromBuffer(reader),
-      reader.readObject(VkData),
-    );
-  }
-
-  toBuffer() {
-    return serializeToBuffer(this.publicInputs, this.proof, this.vkData);
-  }
-
-  static empty() {
-    return new AvmProofData(
-      AvmCircuitPublicInputs.empty(),
-      makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
-      VkData.empty(),
-    );
-  }
-}
+export type AvmProofData = ProofData<AvmCircuitPublicInputs, typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
 
 // TODO(#14234)[Unconditional PIs validation]: remove this function.
 export function enhanceProofWithPiValidationFlag(proof: Fr[], skipPublicInputsValidation: boolean): Fr[] {

package/src/rollup/base_rollup_hints.ts

@@ -4,15 +4,14 @@ import { makeTuple } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
-import { MembershipWitness } from '@aztec/foundation/trees';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { PublicDataHint } from '../avm/public_data_hint.js';
 import { ContractClassLogFields } from '../logs/index.js';
-import { AppendOnlyTreeSnapshot } from '../trees/index.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { PublicDataTreeLeafPreimage } from '../trees/public_data_leaf.js';
 import { PartialStateReference } from '../tx/partial_state_reference.js';
 import { BlockConstantData } from './block_constant_data.js';
-import { PrivateBaseStateDiffHints } from './state_diff_hints.js';
+import { TreeSnapshotDiffHints } from './tree_snapshot_diff_hints.js';
 
 export type BaseRollupHints = PrivateBaseRollupHints | PublicBaseRollupHints;
 
@@ -29,15 +28,15 @@ export class PrivateBaseRollupHints {
     /**
      * Hints used while proving state diff validity.
      */
-    public stateDiffHints: PrivateBaseStateDiffHints,
+    public treeSnapshotDiffHints: TreeSnapshotDiffHints,
     /**
-     * Public data read hint for accessing the balance of the fee payer.
+     * Public data tree leaf preimage for accessing the balance of the fee payer.
      */
-    public feePayerFeeJuiceBalanceReadHint: PublicDataHint,
+    public feePayerBalanceLeafPreimage: PublicDataTreeLeafPreimage,
     /**
      * Membership witnesses of blocks referred by each of the 2 kernels.
      */
-    public archiveRootMembershipWitness: MembershipWitness<typeof ARCHIVE_HEIGHT>,
+    public anchorBlockArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
     /**
      * Preimages to the kernel's contractClassLogsHashes.
      */
@@ -56,9 +55,9 @@ export class PrivateBaseRollupHints {
     return [
       fields.start,
       fields.startSpongeBlob,
-      fields.stateDiffHints,
-      fields.feePayerFeeJuiceBalanceReadHint,
-      fields.archiveRootMembershipWitness,
+      fields.treeSnapshotDiffHints,
+      fields.feePayerBalanceLeafPreimage,
+      fields.anchorBlockArchiveSiblingPath,
       fields.contractClassLogsFields,
       fields.constants,
     ] as const;
@@ -85,9 +84,9 @@ export class PrivateBaseRollupHints {
     return new PrivateBaseRollupHints(
       reader.readObject(PartialStateReference),
       reader.readObject(SpongeBlob),
-      reader.readObject(PrivateBaseStateDiffHints),
-      reader.readObject(PublicDataHint),
-      MembershipWitness.fromBuffer(reader, ARCHIVE_HEIGHT),
+      reader.readObject(TreeSnapshotDiffHints),
+      reader.readObject(PublicDataTreeLeafPreimage),
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
       reader.readObject(BlockConstantData),
     );
@@ -101,9 +100,9 @@ export class PrivateBaseRollupHints {
     return new PrivateBaseRollupHints(
       PartialStateReference.empty(),
       SpongeBlob.empty(),
-      PrivateBaseStateDiffHints.empty(),
-      PublicDataHint.empty(),
-      MembershipWitness.empty(ARCHIVE_HEIGHT),
+      TreeSnapshotDiffHints.empty(),
+      PublicDataTreeLeafPreimage.empty(),
+      makeTuple(ARCHIVE_HEIGHT, Fr.zero),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLogFields.empty),
       BlockConstantData.empty(),
     );
@@ -123,15 +122,11 @@ export class PublicBaseRollupHints {
     /**
      * Membership witnesses of blocks referred by each of the 2 kernels.
      */
-    public archiveRootMembershipWitness: MembershipWitness<typeof ARCHIVE_HEIGHT>,
+    public anchorBlockArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
     /**
      * Preimages to the kernel's contractClassLogsHashes.
      */
     public contractClassLogsFields: Tuple<ContractClassLogFields, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
-    /**
-     * Identifier of the prover.
-     */
-    public proverId: Fr,
   ) {}
 
   static from(fields: FieldsOf<PublicBaseRollupHints>): PublicBaseRollupHints {
@@ -142,9 +137,8 @@ export class PublicBaseRollupHints {
     return [
       fields.startSpongeBlob,
       fields.lastArchive,
-      fields.archiveRootMembershipWitness,
+      fields.anchorBlockArchiveSiblingPath,
       fields.contractClassLogsFields,
-      fields.proverId,
     ] as const;
   }
 
@@ -169,9 +163,8 @@ export class PublicBaseRollupHints {
     return new PublicBaseRollupHints(
       reader.readObject(SpongeBlob),
       reader.readObject(AppendOnlyTreeSnapshot),
-      MembershipWitness.fromBuffer(reader, ARCHIVE_HEIGHT),
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
-      reader.readObject(Fr),
     );
   }
 
@@ -183,9 +176,8 @@ export class PublicBaseRollupHints {
     return new PublicBaseRollupHints(
       SpongeBlob.empty(),
       AppendOnlyTreeSnapshot.empty(),
-      MembershipWitness.empty(ARCHIVE_HEIGHT),
+      makeTuple(ARCHIVE_HEIGHT, Fr.zero),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLogFields.empty),
-      Fr.ZERO,
     );
   }
 }