@aztec/stdlib 0.77.0-testnet-ignition.17

package/src/rollup/merge_rollup.ts

@@ -0,0 +1,62 @@
+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';
+
+/**
+ * Represents inputs of the merge rollup circuit.
+ */
+export class MergeRollupInputs {
+  constructor(
+    /**
+     * Previous rollup data from the 2 merge or base rollup circuits that preceded this merge rollup circuit.
+     */
+    public previousRollupData: [PreviousRollupData, PreviousRollupData],
+  ) {}
+
+  /**
+   * Serializes the inputs to a buffer.
+   * @returns The inputs serialized to a buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(this.previousRollupData);
+  }
+
+  /**
+   * Serializes the inputs to a hex string.
+   * @returns The instance serialized to a hex string.
+   */
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /**
+   * Deserializes the inputs from a buffer.
+   * @param buffer - The buffer to deserialize from.
+   * @returns A new MergeRollupInputs instance.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new MergeRollupInputs([reader.readObject(PreviousRollupData), reader.readObject(PreviousRollupData)]);
+  }
+
+  /**
+   * Deserializes the inputs from a hex string.
+   * @param str - A hex string to deserialize from.
+   * @returns A new MergeRollupInputs instance.
+   */
+  static fromString(str: string) {
+    return MergeRollupInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  /** Returns a buffer representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a string. */
+  static get schema() {
+    return bufferSchemaFor(MergeRollupInputs);
+  }
+}

package/src/rollup/previous_rollup_block_data.ts

@@ -0,0 +1,54 @@
+import { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, VK_TREE_HEIGHT } from '@aztec/constants';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { MembershipWitness } from '@aztec/foundation/trees';
+
+import { RecursiveProof } from '../proofs/recursive_proof.js';
+import { VerificationKeyAsFields } from '../vks/verification_key.js';
+import { BlockRootOrBlockMergePublicInputs } from './block_root_or_block_merge_public_inputs.js';
+
+/**
+ * Represents the data of a previous block merge or block root rollup circuit.
+ */
+export class PreviousRollupBlockData {
+  constructor(
+    /**
+     * Public inputs to the block merge or block root rollup circuit.
+     */
+    public blockRootOrBlockMergePublicInputs: BlockRootOrBlockMergePublicInputs,
+    /**
+     * The proof of the block merge or block root rollup circuit.
+     */
+    public proof: RecursiveProof<typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>,
+    /**
+     * The verification key of the block merge or block root rollup circuit.
+     */
+    public vk: VerificationKeyAsFields,
+    /**
+     * Sibling path of the rollup circuit's vk in a big tree of rollup circuit vks.
+     */
+    public vkWitness: MembershipWitness<typeof VK_TREE_HEIGHT>,
+  ) {}
+
+  /**
+   * Serializes previous rollup data to a buffer.
+   * @returns The buffer of the serialized previous rollup data.
+   */
+  public toBuffer(): Buffer {
+    return serializeToBuffer(this.blockRootOrBlockMergePublicInputs, this.proof, this.vk, this.vkWitness);
+  }
+
+  /**
+   * Deserializes previous rollup data from a buffer.
+   * @param buffer - A buffer to deserialize from.
+   * @returns A new PreviousRollupData instance.
+   */
+  public static fromBuffer(buffer: Buffer | BufferReader): PreviousRollupBlockData {
+    const reader = BufferReader.asReader(buffer);
+    return new PreviousRollupBlockData(
+      reader.readObject(BlockRootOrBlockMergePublicInputs),
+      RecursiveProof.fromBuffer(reader, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+      reader.readObject(VerificationKeyAsFields),
+      MembershipWitness.fromBuffer(reader, VK_TREE_HEIGHT),
+    );
+  }
+}

package/src/rollup/previous_rollup_data.ts

@@ -0,0 +1,54 @@
+import { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, VK_TREE_HEIGHT } from '@aztec/constants';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { MembershipWitness } from '@aztec/foundation/trees';
+
+import { RecursiveProof } from '../proofs/recursive_proof.js';
+import { VerificationKeyAsFields } from '../vks/verification_key.js';
+import { BaseOrMergeRollupPublicInputs } from './base_or_merge_rollup_public_inputs.js';
+
+/**
+ * Represents the data of a previous merge or base rollup circuit.
+ */
+export class PreviousRollupData {
+  constructor(
+    /**
+     * Public inputs to the base or merge rollup circuit.
+     */
+    public baseOrMergeRollupPublicInputs: BaseOrMergeRollupPublicInputs,
+    /**
+     * The proof of the base or merge rollup circuit.
+     */
+    public proof: RecursiveProof<typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>,
+    /**
+     * The verification key of the base or merge rollup circuit.
+     */
+    public vk: VerificationKeyAsFields,
+    /**
+     * Sibling path of the rollup circuit's vk in a big tree of rollup circuit vks.
+     */
+    public vkWitness: MembershipWitness<typeof VK_TREE_HEIGHT>,
+  ) {}
+
+  /**
+   * Serializes previous rollup data to a buffer.
+   * @returns The buffer of the serialized previous rollup data.
+   */
+  public toBuffer(): Buffer {
+    return serializeToBuffer(this.baseOrMergeRollupPublicInputs, this.proof, this.vk, this.vkWitness);
+  }
+
+  /**
+   * Deserializes previous rollup data from a buffer.
+   * @param buffer - A buffer to deserialize from.
+   * @returns A new PreviousRollupData instance.
+   */
+  public static fromBuffer(buffer: Buffer | BufferReader): PreviousRollupData {
+    const reader = BufferReader.asReader(buffer);
+    return new PreviousRollupData(
+      reader.readObject(BaseOrMergeRollupPublicInputs),
+      RecursiveProof.fromBuffer(reader, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+      reader.readObject(VerificationKeyAsFields),
+      MembershipWitness.fromBuffer(reader, VK_TREE_HEIGHT),
+    );
+  }
+}

package/src/rollup/private_base_rollup_inputs.ts

@@ -0,0 +1,50 @@
+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 { PrivateBaseRollupHints } from './base_rollup_hints.js';
+import { PrivateTubeData } from './private_tube_data.js';
+
+export class PrivateBaseRollupInputs {
+  constructor(public tubeData: PrivateTubeData, public hints: PrivateBaseRollupHints) {}
+
+  static from(fields: FieldsOf<PrivateBaseRollupInputs>): PrivateBaseRollupInputs {
+    return new PrivateBaseRollupInputs(...PrivateBaseRollupInputs.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PrivateBaseRollupInputs>) {
+    return [fields.tubeData, fields.hints] as const;
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateBaseRollupInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateBaseRollupInputs(reader.readObject(PrivateTubeData), reader.readObject(PrivateBaseRollupHints));
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...PrivateBaseRollupInputs.getFields(this));
+  }
+
+  static fromString(str: string) {
+    return PrivateBaseRollupInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static empty() {
+    return new PrivateBaseRollupInputs(PrivateTubeData.empty(), PrivateBaseRollupHints.empty());
+  }
+
+  /** Returns a buffer representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a hex string. */
+  static get schema() {
+    return bufferSchemaFor(PrivateBaseRollupInputs);
+  }
+}

package/src/rollup/private_tube_data.ts

@@ -0,0 +1,35 @@
+import { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { PrivateToRollupKernelCircuitPublicInputs } from '../kernel/private_to_rollup_kernel_circuit_public_inputs.js';
+import { RecursiveProof, makeEmptyRecursiveProof } from '../proofs/recursive_proof.js';
+import { VkWitnessData } from '../vks/vk_witness_data.js';
+
+export class PrivateTubeData {
+  constructor(
+    public publicInputs: PrivateToRollupKernelCircuitPublicInputs,
+    public proof: RecursiveProof<typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>,
+    public vkData: VkWitnessData,
+  ) {}
+
+  static empty() {
+    return new PrivateTubeData(
+      PrivateToRollupKernelCircuitPublicInputs.empty(),
+      makeEmptyRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+      VkWitnessData.empty(),
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateTubeData(
+      reader.readObject(PrivateToRollupKernelCircuitPublicInputs),
+      RecursiveProof.fromBuffer(reader, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+      reader.readObject(VkWitnessData),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.publicInputs, this.proof, this.vkData);
+  }
+}

package/src/rollup/public_base_rollup_inputs.ts

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

package/src/rollup/public_tube_data.ts

@@ -0,0 +1,35 @@
+import { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
+import { RecursiveProof, makeEmptyRecursiveProof } from '../proofs/recursive_proof.js';
+import { VkWitnessData } from '../vks/vk_witness_data.js';
+
+export class PublicTubeData {
+  constructor(
+    public publicInputs: PrivateToPublicKernelCircuitPublicInputs,
+    public proof: RecursiveProof<typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>,
+    public vkData: VkWitnessData,
+  ) {}
+
+  static empty() {
+    return new PublicTubeData(
+      PrivateToPublicKernelCircuitPublicInputs.empty(),
+      makeEmptyRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+      VkWitnessData.empty(),
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new PublicTubeData(
+      reader.readObject(PrivateToPublicKernelCircuitPublicInputs),
+      RecursiveProof.fromBuffer(reader, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+      reader.readObject(VkWitnessData),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.publicInputs, this.proof, this.vkData);
+  }
+}

package/src/rollup/root_rollup.ts

@@ -0,0 +1,206 @@
+import { BlockBlobPublicInputs } from '@aztec/blob-lib';
+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 { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { FeeRecipient } from './block_root_or_block_merge_public_inputs.js';
+import { PreviousRollupBlockData } from './previous_rollup_block_data.js';
+
+/**
+ * Represents inputs of the root rollup circuit.
+ */
+export class RootRollupInputs {
+  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 block merge circuits.
+     */
+    public previousRollupData: [PreviousRollupBlockData, PreviousRollupBlockData],
+    /** Identifier of the prover for this root rollup. */
+    public proverId: Fr,
+  ) {}
+
+  /**
+   * Serializes the inputs to a buffer.
+   * @returns - The inputs serialized to a buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(...RootRollupInputs.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 RootRollupInputs instance.
+   */
+  static from(fields: FieldsOf<RootRollupInputs>): RootRollupInputs {
+    return new RootRollupInputs(...RootRollupInputs.getFields(fields));
+  }
+
+  /**
+   * Extracts fields from an instance.
+   * @param fields - Fields to create the instance from.
+   * @returns An array of fields.
+   */
+  static getFields(fields: FieldsOf<RootRollupInputs>) {
+    return [fields.previousRollupData, fields.proverId] as const;
+  }
+
+  /**
+   * Deserializes the inputs from a buffer.
+   * @param buffer - A buffer to deserialize from.
+   * @returns A new RootRollupInputs instance.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): RootRollupInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new RootRollupInputs(
+      [reader.readObject(PreviousRollupBlockData), reader.readObject(PreviousRollupBlockData)],
+      Fr.fromBuffer(reader),
+    );
+  }
+
+  /**
+   * Deserializes the inputs from a hex string.
+   * @param str - A hex string to deserialize from.
+   * @returns A new RootRollupInputs instance.
+   */
+  static fromString(str: string) {
+    return RootRollupInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  /** Returns a representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a string. */
+  static get schema() {
+    return bufferSchemaFor(RootRollupInputs);
+  }
+}
+
+/**
+ * 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 on-chain verification.
+ */
+export class RootRollupPublicInputs {
+  constructor(
+    /** Snapshot of archive tree before/after this rollup been processed */
+    public previousArchive: AppendOnlyTreeSnapshot,
+    public endArchive: AppendOnlyTreeSnapshot,
+    public previousBlockHash: Fr,
+    public endBlockHash: Fr,
+    // This is a u64 in nr, but GlobalVariables contains this as a u64 and is mapped to ts as a field, so I'm doing the same here
+    public endTimestamp: Fr,
+    public endBlockNumber: Fr,
+    public outHash: Fr,
+    public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public vkTreeRoot: Fr,
+    public protocolContractTreeRoot: Fr,
+    public proverId: Fr,
+    public blobPublicInputs: Tuple<BlockBlobPublicInputs, typeof AZTEC_MAX_EPOCH_DURATION>,
+  ) {}
+
+  static getFields(fields: FieldsOf<RootRollupPublicInputs>) {
+    return [
+      fields.previousArchive,
+      fields.endArchive,
+      fields.previousBlockHash,
+      fields.endBlockHash,
+      fields.endTimestamp,
+      fields.endBlockNumber,
+      fields.outHash,
+      fields.fees,
+      fields.vkTreeRoot,
+      fields.protocolContractTreeRoot,
+      fields.proverId,
+      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(
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      reader.readArray(AZTEC_MAX_EPOCH_DURATION, BlockBlobPublicInputs),
+    );
+  }
+
+  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. */
+  static random() {
+    return new RootRollupPublicInputs(
+      AppendOnlyTreeSnapshot.random(),
+      AppendOnlyTreeSnapshot.random(),
+      Fr.random(),
+      Fr.random(),
+      Fr.random(),
+      Fr.random(),
+      Fr.random(),
+      makeTuple(AZTEC_MAX_EPOCH_DURATION, FeeRecipient.random),
+      Fr.random(),
+      Fr.random(),
+      Fr.random(),
+      makeTuple(AZTEC_MAX_EPOCH_DURATION, BlockBlobPublicInputs.empty),
+    );
+  }
+}

package/src/rollup/state_diff_hints.ts

@@ -0,0 +1,126 @@
+import {
+  MAX_NULLIFIERS_PER_TX,
+  NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH,
+  NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH,
+  NULLIFIER_TREE_HEIGHT,
+  PUBLIC_DATA_TREE_HEIGHT,
+} from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import { MembershipWitness } from '@aztec/foundation/trees';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { NullifierLeafPreimage, PublicDataTreeLeafPreimage } from '../trees/index.js';
+
+/**
+ * Hints used while proving state diff validity for the private base rollup.
+ */
+export class PrivateBaseStateDiffHints {
+  constructor(
+    /**
+     * The nullifiers which need to be updated to perform the batch insertion of the new nullifiers.
+     * See `StandardIndexedTree.batchInsert` function for more details.
+     */
+    public nullifierPredecessorPreimages: Tuple<NullifierLeafPreimage, typeof MAX_NULLIFIERS_PER_TX>,
+    /**
+     * Membership witnesses for the nullifiers which need to be updated to perform the batch insertion of the new
+     * nullifiers.
+     */
+    public nullifierPredecessorMembershipWitnesses: Tuple<
+      MembershipWitness<typeof NULLIFIER_TREE_HEIGHT>,
+      typeof MAX_NULLIFIERS_PER_TX
+    >,
+    /**
+     * The nullifiers to be inserted in the tree, sorted high to low.
+     */
+    public sortedNullifiers: Tuple<Fr, typeof MAX_NULLIFIERS_PER_TX>,
+    /**
+     * 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>,
+    /**
+     * Sibling path "pointing to" where the fee write should be inserted into the public data tree.
+     */
+    public feeWriteSiblingPath: Tuple<Fr, typeof PUBLIC_DATA_TREE_HEIGHT>,
+  ) {}
+
+  static from(fields: FieldsOf<PrivateBaseStateDiffHints>): PrivateBaseStateDiffHints {
+    return new PrivateBaseStateDiffHints(...PrivateBaseStateDiffHints.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PrivateBaseStateDiffHints>) {
+    return [
+      fields.nullifierPredecessorPreimages,
+      fields.nullifierPredecessorMembershipWitnesses,
+      fields.sortedNullifiers,
+      fields.sortedNullifierIndexes,
+      fields.noteHashSubtreeSiblingPath,
+      fields.nullifierSubtreeSiblingPath,
+      fields.feeWriteLowLeafPreimage,
+      fields.feeWriteLowLeafMembershipWitness,
+      fields.feeWriteSiblingPath,
+    ] as const;
+  }
+
+  /**
+   * Serializes the state diff hints to a buffer.
+   * @returns A buffer of the serialized state diff hints.
+   */
+  toBuffer(): Buffer {
+    return serializeToBuffer(...PrivateBaseStateDiffHints.getFields(this));
+  }
+
+  /**
+   * Deserializes the state diff hints from a buffer.
+   * @param buffer - A buffer to deserialize from.
+   * @returns A new PrivateBaseStateDiffHints instance.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateBaseStateDiffHints {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateBaseStateDiffHints(
+      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),
+      MembershipWitness.fromBuffer(reader, PUBLIC_DATA_TREE_HEIGHT),
+      reader.readArray(PUBLIC_DATA_TREE_HEIGHT, Fr),
+    );
+  }
+
+  static empty() {
+    return new PrivateBaseStateDiffHints(
+      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(),
+      MembershipWitness.empty(PUBLIC_DATA_TREE_HEIGHT),
+      makeTuple(PUBLIC_DATA_TREE_HEIGHT, Fr.zero),
+    );
+  }
+}