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

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/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/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,7 +122,7 @@ 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.
      */
@@ -142,7 +141,7 @@ export class PublicBaseRollupHints {
     return [
       fields.startSpongeBlob,
       fields.lastArchive,
-      fields.archiveRootMembershipWitness,
+      fields.anchorBlockArchiveSiblingPath,
       fields.contractClassLogsFields,
       fields.proverId,
     ] as const;
@@ -169,7 +168,7 @@ 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,7 +182,7 @@ 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,
     );

package/src/rollup/block_root_rollup_private_inputs.ts

@@ -1,5 +1,5 @@
 import { SpongeBlob } from '@aztec/blob-lib/types';
-import { ARCHIVE_HEIGHT, L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH } from '@aztec/constants';
+import { ARCHIVE_HEIGHT, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, type Tuple, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
@@ -28,9 +28,9 @@ export class BlockRootFirstRollupPrivateInputs {
      */
     public previousL1ToL2: AppendOnlyTreeSnapshot,
     /**
-     * Hint for inserting the new l1 to l2 message subtree into `previousL1ToL2`.
+     * Hint for inserting the new l1 to l2 message subtree root into `previousL1ToL2`.
      */
-    public newL1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>,
+    public newL1ToL2MessageSubtreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH>,
     /**
      * Hint for inserting the new block hash to the last archive.
      */
@@ -46,7 +46,7 @@ export class BlockRootFirstRollupPrivateInputs {
       fields.l1ToL2Roots,
       fields.previousRollups,
       fields.previousL1ToL2,
-      fields.newL1ToL2MessageSubtreeSiblingPath,
+      fields.newL1ToL2MessageSubtreeRootSiblingPath,
       fields.newArchiveSiblingPath,
     ] as const;
   }
@@ -61,7 +61,7 @@ export class BlockRootFirstRollupPrivateInputs {
       ProofData.fromBuffer(reader, ParityPublicInputs),
       [ProofData.fromBuffer(reader, TxRollupPublicInputs), ProofData.fromBuffer(reader, TxRollupPublicInputs)],
       AppendOnlyTreeSnapshot.fromBuffer(reader),
-      reader.readArray(L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, Fr),
+      reader.readArray(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
       reader.readArray(ARCHIVE_HEIGHT, Fr),
     );
   }
@@ -90,9 +90,9 @@ export class BlockRootSingleTxFirstRollupPrivateInputs {
      */
     public previousL1ToL2: AppendOnlyTreeSnapshot,
     /**
-     * Hint for inserting the new l1 to l2 message subtree.
+     * Hint for inserting the new l1 to l2 message subtree root.
      */
-    public newL1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>,
+    public newL1ToL2MessageSubtreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH>,
     /**
      * Hint for inserting the new block hash to the last archive.
      */
@@ -110,7 +110,7 @@ export class BlockRootSingleTxFirstRollupPrivateInputs {
       fields.l1ToL2Roots,
       fields.previousRollup,
       fields.previousL1ToL2,
-      fields.newL1ToL2MessageSubtreeSiblingPath,
+      fields.newL1ToL2MessageSubtreeRootSiblingPath,
       fields.newArchiveSiblingPath,
     ] as const;
   }
@@ -125,7 +125,7 @@ export class BlockRootSingleTxFirstRollupPrivateInputs {
       ProofData.fromBuffer(reader, ParityPublicInputs),
       ProofData.fromBuffer(reader, TxRollupPublicInputs),
       AppendOnlyTreeSnapshot.fromBuffer(reader),
-      reader.readArray(L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, Fr),
+      reader.readArray(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
       reader.readArray(ARCHIVE_HEIGHT, Fr),
     );
   }
@@ -167,9 +167,9 @@ export class BlockRootEmptyTxFirstRollupPrivateInputs {
      */
     public timestamp: UInt64,
     /**
-     * Hint for inserting the new l1 to l2 message subtree.
+     * Hint for inserting the new l1 to l2 message subtree root.
      */
-    public newL1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>,
+    public newL1ToL2MessageSubtreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH>,
     /**
      * Hint for inserting the new block hash to the last archive.
      */
@@ -188,7 +188,7 @@ export class BlockRootEmptyTxFirstRollupPrivateInputs {
       fields.constants,
       fields.startSpongeBlob,
       fields.timestamp,
-      fields.newL1ToL2MessageSubtreeSiblingPath,
+      fields.newL1ToL2MessageSubtreeRootSiblingPath,
       fields.newArchiveSiblingPath,
     ] as const;
   }
@@ -201,7 +201,7 @@ export class BlockRootEmptyTxFirstRollupPrivateInputs {
       this.constants,
       this.startSpongeBlob,
       bigintToUInt64BE(this.timestamp),
-      this.newL1ToL2MessageSubtreeSiblingPath,
+      this.newL1ToL2MessageSubtreeRootSiblingPath,
       this.newArchiveSiblingPath,
     ]);
   }
@@ -215,7 +215,7 @@ export class BlockRootEmptyTxFirstRollupPrivateInputs {
       CheckpointConstantData.fromBuffer(reader),
       SpongeBlob.fromBuffer(reader),
       reader.readUInt64(),
-      reader.readArray(L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, Fr),
+      reader.readArray(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
       reader.readArray(ARCHIVE_HEIGHT, Fr),
     );
   }

package/src/rollup/index.ts

@@ -15,6 +15,6 @@ export * from './public_tx_base_rollup_private_inputs.js';
 export * from './public_tube_private_inputs.js';
 export * from './root_rollup_private_inputs.js';
 export * from './root_rollup_public_inputs.js';
-export * from './state_diff_hints.js';
+export * from './tree_snapshot_diff_hints.js';
 export * from './tx_merge_rollup_private_inputs.js';
 export * from './tx_rollup_public_inputs.js';

package/src/rollup/public_tx_base_rollup_private_inputs.ts

@@ -3,9 +3,10 @@ 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 { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
 import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
-import { AvmProofData } from './avm_proof_data.js';
+import type { AvmProofData } from './avm_proof_data.js';
 import { PublicBaseRollupHints } from './base_rollup_hints.js';
 
 export class PublicTxBaseRollupPrivateInputs {
@@ -27,7 +28,7 @@ export class PublicTxBaseRollupPrivateInputs {
     const reader = BufferReader.asReader(buffer);
     return new PublicTxBaseRollupPrivateInputs(
       ProofData.fromBuffer(reader, PrivateToPublicKernelCircuitPublicInputs),
-      reader.readObject(AvmProofData),
+      ProofData.fromBuffer(reader, AvmCircuitPublicInputs),
       reader.readObject(PublicBaseRollupHints),
     );
   }

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),
     );
   }
 }