@aztec/stdlib 2.1.0-rc.9 → 3.0.0-devnet.2

package/src/proofs/client_ivc_proof.ts

@@ -1,51 +1,117 @@
+import { CIVC_PROOF_LENGTH } from '@aztec/constants';
 import { randomBytes } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
-const CLIENT_IVC_PROOF_LENGTH = 172052;
-
-/**
- * TODO(https://github.com/AztecProtocol/aztec-packages/issues/7370) refactor this to
- * eventually we read all these VKs from the data tree instead of passing them
- */
 export class ClientIvcProof {
   constructor(
-    // produced by the sequencer when making the tube proof
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7370): Need to precompute private kernel tail VK so we can verify this immediately in the tx pool
-    // which parts of these are needed to quickly verify that we have a correct IVC proof
-    public clientIvcProofBuffer: Buffer,
-  ) {}
+    // The proof fields.
+    // For native verification, attach public inputs via `attachPublicInputs(publicInputs)`.
+    // Not using Tuple here due to the length being too high.
+    public fields: Fr[],
+  ) {
+    if (fields.length !== CIVC_PROOF_LENGTH) {
+      throw new Error(`Invalid ClientIvcProof length: ${fields.length}`);
+    }
+  }
 
-  public isEmpty() {
-    return this.clientIvcProofBuffer.length === 0;
+  public attachPublicInputs(publicInputs: Fr[]) {
+    return new ClientIvcProofWithPublicInputs([...publicInputs, ...this.fields]);
   }
 
-  static empty() {
-    return new ClientIvcProof(Buffer.from(''));
+  public isEmpty() {
+    return this.fields.every(field => field.isZero());
   }
 
-  static fake(fill = Math.floor(Math.random() * 255)) {
-    return new ClientIvcProof(Buffer.alloc(1, fill));
+  static empty() {
+    return new ClientIvcProof(new Array(CIVC_PROOF_LENGTH).fill(Fr.ZERO));
   }
 
   static random() {
-    return new ClientIvcProof(Buffer.from(randomBytes(CLIENT_IVC_PROOF_LENGTH)));
+    // NB: Not using Fr.random here because it slows down some tests that require a large number of txs significantly.
+    const reducedFrSize = Fr.SIZE_IN_BYTES - 1;
+    const randomFields = randomBytes(CIVC_PROOF_LENGTH * reducedFrSize);
+    const proof = Array.from(
+      { length: CIVC_PROOF_LENGTH },
+      (_, i) => new Fr(randomFields.subarray(i * reducedFrSize, (i + 1) * reducedFrSize)),
+    );
+    return new ClientIvcProof(proof);
   }
 
   static get schema() {
     return bufferSchemaFor(ClientIvcProof);
   }
 
+  // We use this in tandem with the bufferSchemaFor to serialize to base64 strings.
   toJSON() {
     return this.toBuffer();
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): ClientIvcProof {
     const reader = BufferReader.asReader(buffer);
-    return new ClientIvcProof(reader.readBuffer());
+    const proofLength = reader.readNumber();
+    const proof = reader.readArray(proofLength, Fr);
+    return new ClientIvcProof(proof);
   }
 
   public toBuffer() {
-    return serializeToBuffer(this.clientIvcProofBuffer.length, this.clientIvcProofBuffer);
+    return serializeToBuffer(this.fields.length, this.fields);
+  }
+}
+
+export class ClientIvcProofWithPublicInputs {
+  constructor(
+    // The proof fields with public inputs.
+    // For recursive verification, use without public inputs via `removePublicInputs()`.
+    public fieldsWithPublicInputs: Fr[],
+  ) {
+    if (fieldsWithPublicInputs.length < CIVC_PROOF_LENGTH) {
+      throw new Error(`Invalid ClientIvcProofWithPublicInputs length: ${fieldsWithPublicInputs.length}`);
+    }
+  }
+
+  public getPublicInputs() {
+    const numPublicInputs = this.fieldsWithPublicInputs.length - CIVC_PROOF_LENGTH;
+    return this.fieldsWithPublicInputs.slice(0, numPublicInputs);
+  }
+
+  public removePublicInputs() {
+    const numPublicInputs = this.fieldsWithPublicInputs.length - CIVC_PROOF_LENGTH;
+    return new ClientIvcProof(this.fieldsWithPublicInputs.slice(numPublicInputs));
+  }
+
+  public isEmpty() {
+    return this.fieldsWithPublicInputs.every(field => field.isZero());
+  }
+
+  static empty() {
+    return ClientIvcProof.empty().attachPublicInputs([]);
+  }
+
+  static get schema() {
+    return bufferSchemaFor(ClientIvcProofWithPublicInputs);
+  }
+
+  // We use this in tandem with the bufferSchemaFor to serialize to base64 strings.
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): ClientIvcProofWithPublicInputs {
+    const reader = BufferReader.asReader(buffer);
+    const proofLength = reader.readNumber();
+    const proof = reader.readArray(proofLength, Fr);
+    return new ClientIvcProofWithPublicInputs(proof);
+  }
+
+  public toBuffer() {
+    return serializeToBuffer(this.fieldsWithPublicInputs.length, this.fieldsWithPublicInputs);
+  }
+
+  // Called when constructing from bb proving results.
+  static fromBufferArray(fields: Uint8Array[]): ClientIvcProofWithPublicInputs {
+    const proof = fields.map(field => Fr.fromBuffer(Buffer.from(field)));
+    return new ClientIvcProofWithPublicInputs(proof);
   }
 }

package/src/proofs/index.ts

@@ -1,4 +1,5 @@
 export * from './recursive_proof.js';
 export * from './client_ivc_proof.js';
 export * from './proof.js';
+export * from './proof_data.js';
 export * from './proving_request_type.js';

package/src/proofs/proof_data.ts

@@ -0,0 +1,36 @@
+import type { CIVC_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import { BufferReader, type Bufferable, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { RecursiveProof } from '../proofs/recursive_proof.js';
+import { VkData } from '../vks/index.js';
+
+/**
+ * Represents the data of a recursive proof.
+ */
+export class ProofData<T extends Bufferable, PROOF_LENGTH extends number> {
+  constructor(
+    public publicInputs: T,
+    public proof: RecursiveProof<PROOF_LENGTH>,
+    public vkData: VkData,
+  ) {}
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(this.publicInputs, this.proof, this.vkData);
+  }
+
+  public static fromBuffer<T extends Bufferable, PROOF_LENGTH extends number>(
+    buffer: Buffer | BufferReader,
+    publicInputs: {
+      fromBuffer: (reader: BufferReader) => T;
+    },
+  ): ProofData<T, PROOF_LENGTH> {
+    const reader = BufferReader.asReader(buffer);
+    return new ProofData(reader.readObject(publicInputs), RecursiveProof.fromBuffer(reader), reader.readObject(VkData));
+  }
+}
+
+export type CivcProofData<T extends Bufferable> = ProofData<T, typeof CIVC_PROOF_LENGTH>;
+
+export type UltraHonkProofData<T extends Bufferable> = ProofData<T, typeof RECURSIVE_PROOF_LENGTH>;
+
+export type RollupHonkProofData<T extends Bufferable> = ProofData<T, typeof RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;

package/src/proofs/proving_request_type.ts

@@ -1,18 +1,22 @@
 export enum ProvingRequestType {
   PUBLIC_VM,
+  PUBLIC_TUBE,
 
-  PRIVATE_BASE_ROLLUP,
-  PUBLIC_BASE_ROLLUP,
-  MERGE_ROLLUP,
-  EMPTY_BLOCK_ROOT_ROLLUP,
-  PADDING_BLOCK_ROOT_ROLLUP,
+  PRIVATE_TX_BASE_ROLLUP,
+  PUBLIC_TX_BASE_ROLLUP,
+  TX_MERGE_ROLLUP,
+  BLOCK_ROOT_FIRST_ROLLUP,
+  BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP,
+  BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP,
   BLOCK_ROOT_ROLLUP,
-  SINGLE_TX_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_ROLLUP,
 
-  BASE_PARITY,
-  ROOT_PARITY,
-  /** Recursive Client IVC verification to connect private to public or rollup */
-  TUBE_PROOF,
+  PARITY_BASE,
+  PARITY_ROOT,
 }

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

@@ -1,17 +1,17 @@
-import { SpongeBlob } from '@aztec/blob-lib';
+import { SpongeBlob } from '@aztec/blob-lib/types';
 import { ARCHIVE_HEIGHT, MAX_CONTRACT_CLASS_LOGS_PER_TX } 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 { 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;
 
@@ -28,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.
      */
@@ -55,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;
@@ -84,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),
     );
@@ -100,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(),
     );
@@ -122,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.
      */
@@ -137,7 +137,7 @@ export class PublicBaseRollupHints {
     return [
       fields.startSpongeBlob,
       fields.lastArchive,
-      fields.archiveRootMembershipWitness,
+      fields.anchorBlockArchiveSiblingPath,
       fields.contractClassLogsFields,
     ] as const;
   }
@@ -163,7 +163,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)),
     );
   }
@@ -176,7 +176,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),
     );
   }

package/src/rollup/block_constant_data.ts

@@ -12,14 +12,21 @@ export class BlockConstantData {
   constructor(
     /** Archive tree snapshot at the very beginning of the entire rollup. */
     public lastArchive: AppendOnlyTreeSnapshot,
-    /** L1 to L2 message tree snapshot after this block lands. */
-    public newL1ToL2: AppendOnlyTreeSnapshot,
+    /**
+     * L1-to-L2 message tree snapshot after this block lands.
+     * For the first block in a checkpoint, this should be the snapshot after inserting the new l1-to-l2 message subtree
+     * into the last l1-to-l2 tree snapshot in `last_archive`.
+     * For subsequent blocks, this should match the snapshot of the previous block.
+     */
+    public l1ToL2TreeSnapshot: AppendOnlyTreeSnapshot,
     /** Root of the verification key tree. */
     public vkTreeRoot: Fr,
-    /** Root of the protocol contract tree. */
-    public protocolContractTreeRoot: Fr,
+    /** Hash of the protocol contracts list. */
+    public protocolContractsHash: Fr,
     /** Global variables for the block. */
     public globalVariables: GlobalVariables,
+    /** Identifier of the prover. */
+    public proverId: Fr,
   ) {}
 
   static from(fields: FieldsOf<BlockConstantData>): BlockConstantData {
@@ -34,16 +41,18 @@ export class BlockConstantData {
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       reader.readObject(GlobalVariables),
+      Fr.fromBuffer(reader),
     );
   }
 
   static getFields(fields: FieldsOf<BlockConstantData>) {
     return [
       fields.lastArchive,
-      fields.newL1ToL2,
+      fields.l1ToL2TreeSnapshot,
       fields.vkTreeRoot,
-      fields.protocolContractTreeRoot,
+      fields.protocolContractsHash,
       fields.globalVariables,
+      fields.proverId,
     ] as const;
   }
 
@@ -54,6 +63,7 @@ export class BlockConstantData {
       Fr.ZERO,
       Fr.ZERO,
       GlobalVariables.empty(),
+      Fr.ZERO,
     );
   }
 

package/src/rollup/{block_merge_rollup.ts → block_merge_rollup_private_inputs.ts}

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

package/src/rollup/block_rollup_public_inputs.ts

@@ -0,0 +1,123 @@
+import { SpongeBlob } from '@aztec/blob-lib/types';
+import { Fr } from '@aztec/foundation/fields';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { StateReference } from '../tx/state_reference.js';
+import type { UInt64 } from '../types/shared.js';
+import { CheckpointConstantData } from './checkpoint_constant_data.js';
+
+/**
+ * Output of the block root and block merge rollup circuits.
+ */
+export class BlockRollupPublicInputs {
+  constructor(
+    /**
+     * Constants for the entire checkpoint.
+     */
+    public constants: CheckpointConstantData,
+    /**
+     * Archive tree immediately before this block range.
+     */
+    public previousArchive: AppendOnlyTreeSnapshot,
+    /**
+     * Archive tree after applying this block range.
+     */
+    public newArchive: AppendOnlyTreeSnapshot,
+    /**
+     * State reference immediately before this block range.
+     */
+    public startState: StateReference,
+    /**
+     * State reference after applying this block range.
+     */
+    public endState: StateReference,
+    /**
+     * Sponge state to absorb blob inputs at the start of this block range.
+     */
+    public startSpongeBlob: SpongeBlob,
+    /**
+     * Sponge state to absorb blob inputs at the end of this block range.
+     */
+    public endSpongeBlob: SpongeBlob,
+    /**
+     * Timestamp of the first block in this block range.
+     */
+    public startTimestamp: UInt64,
+    /**
+     * Timestamp of the last block in this block range.
+     */
+    public endTimestamp: UInt64,
+    /**
+     * SHA256 hash of l1 to l2 messages.
+     */
+    public inHash: Fr,
+    /**
+     * SHA256 hash of L2 to L1 messages created in this block range.
+     */
+    public outHash: Fr,
+    /**
+     * The summed transaction fees of all the txs in this block range.
+     */
+    public accumulatedFees: Fr,
+    /**
+     * The summed mana used of all the txs in this block range.
+     */
+    public accumulatedManaUsed: Fr,
+  ) {}
+
+  static fromBuffer(buffer: Buffer | BufferReader): BlockRollupPublicInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new BlockRollupPublicInputs(
+      reader.readObject(CheckpointConstantData),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(StateReference),
+      reader.readObject(StateReference),
+      reader.readObject(SpongeBlob),
+      reader.readObject(SpongeBlob),
+      reader.readUInt64(),
+      reader.readUInt64(),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.constants,
+      this.previousArchive,
+      this.newArchive,
+      this.startState,
+      this.endState,
+      this.startSpongeBlob,
+      this.endSpongeBlob,
+      bigintToUInt64BE(this.startTimestamp),
+      bigintToUInt64BE(this.endTimestamp),
+      this.inHash,
+      this.outHash,
+      this.accumulatedFees,
+      this.accumulatedManaUsed,
+    );
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string) {
+    return BlockRollupPublicInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(BlockRollupPublicInputs);
+  }
+}