@aztec/stdlib 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/proofs/client_ivc_proof.ts

@@ -3,7 +3,6 @@ import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 const CLIENT_IVC_PROOF_LENGTH = 172052;
-const CLIENT_IVC_VK_LENGTH = 2730;
 
 /**
  * TODO(https://github.com/AztecProtocol/aztec-packages/issues/7370) refactor this to
@@ -15,7 +14,6 @@ export class ClientIvcProof {
     // 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,
-    public clientIvcVkBuffer: Buffer,
   ) {}
 
   public isEmpty() {
@@ -23,18 +21,15 @@ export class ClientIvcProof {
   }
 
   static empty() {
-    return new ClientIvcProof(Buffer.from(''), Buffer.from(''));
+    return new ClientIvcProof(Buffer.from(''));
   }
 
   static fake(fill = Math.floor(Math.random() * 255)) {
-    return new ClientIvcProof(Buffer.alloc(1, fill), Buffer.alloc(1, fill));
+    return new ClientIvcProof(Buffer.alloc(1, fill));
   }
 
   static random() {
-    return new ClientIvcProof(
-      Buffer.from(randomBytes(CLIENT_IVC_PROOF_LENGTH)),
-      Buffer.from(randomBytes(CLIENT_IVC_VK_LENGTH)),
-    );
+    return new ClientIvcProof(Buffer.from(randomBytes(CLIENT_IVC_PROOF_LENGTH)));
   }
 
   static get schema() {
@@ -47,15 +42,10 @@ export class ClientIvcProof {
 
   static fromBuffer(buffer: Buffer | BufferReader): ClientIvcProof {
     const reader = BufferReader.asReader(buffer);
-    return new ClientIvcProof(reader.readBuffer(), reader.readBuffer());
+    return new ClientIvcProof(reader.readBuffer());
   }
 
   public toBuffer() {
-    return serializeToBuffer(
-      this.clientIvcProofBuffer.length,
-      this.clientIvcProofBuffer,
-      this.clientIvcVkBuffer.length,
-      this.clientIvcVkBuffer,
-    );
+    return serializeToBuffer(this.clientIvcProofBuffer.length, this.clientIvcProofBuffer);
   }
 }

package/src/proofs/proof.ts

@@ -1,8 +1,10 @@
-import { AGGREGATION_OBJECT_LENGTH } from '@aztec/constants';
+import { PAIRING_POINTS_SIZE } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
+import { strict as assert } from 'assert';
+
 const EMPTY_PROOF_SIZE = 42;
 
 /**
@@ -15,13 +17,6 @@ export class Proof {
   // Make sure this type is not confused with other buffer wrappers
   readonly __proofBrand: any;
 
-  // Honk proofs start with a 4 byte length prefix
-  // the proof metadata starts immediately after
-  private readonly metadataOffset = 4;
-  // the metadata is 3 Frs long
-  // the public inputs are after it
-  private readonly publicInputsOffset = 100;
-
   constructor(
     /**
      * Holds the serialized proof data in a binary buffer format.
@@ -64,23 +59,36 @@ export class Proof {
     return bufferToHex(this.toBuffer());
   }
 
+  /**
+   * Returns the proof without the public inputs, but includes the pairing point object as part of the proof.
+   * @returns Proof in bytes form, including the pairing point object at the start.
+   */
   public withoutPublicInputs(): Buffer {
-    return Buffer.concat([
-      this.buffer.subarray(this.metadataOffset, this.publicInputsOffset),
-      this.buffer.subarray(this.publicInputsOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs),
-    ]);
+    if (this.isEmpty()) {
+      return this.buffer;
+    }
+    // We are indexing to this particular size because we are assuming the proof buffer looks like:
+    // [binary public inputs, binary proof]
+    // Here, we are assuming the pairing point object is the last 16 fields of the public inputs.
+    assert(this.numPublicInputs >= PAIRING_POINTS_SIZE, 'Proof does not contain an aggregation object');
+    const proofStart = Fr.SIZE_IN_BYTES * (this.numPublicInputs - PAIRING_POINTS_SIZE);
+    assert(this.buffer.length >= proofStart, 'Proof buffer is not appropriately sized to call withoutPublicInputs()');
+    return this.buffer.subarray(proofStart);
   }
 
+  // This function assumes that the proof will contain an aggregation object and look something like:
+  // [binary public inputs, aggregation object, rest of proof]
+  // We are extracting the binary public inputs and reading them as Frs.
   public extractPublicInputs(): Fr[] {
-    const reader = BufferReader.asReader(
-      this.buffer.subarray(this.publicInputsOffset, this.publicInputsOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs),
-    );
-    return reader.readArray(this.numPublicInputs, Fr);
-  }
-
-  public extractAggregationObject(): Fr[] {
-    const publicInputs = this.extractPublicInputs();
-    return publicInputs.slice(-1 * AGGREGATION_OBJECT_LENGTH);
+    if (this.isEmpty()) {
+      // return array of this.numPublicInputs 0s
+      return new Array(this.numPublicInputs).fill(Fr.zero());
+    }
+    assert(this.numPublicInputs >= PAIRING_POINTS_SIZE, 'Proof does not contain an aggregation object');
+    const numInnerPublicInputs = this.numPublicInputs - PAIRING_POINTS_SIZE;
+    const reader = BufferReader.asReader(this.buffer.subarray(0, Fr.SIZE_IN_BYTES * numInnerPublicInputs));
+    const publicInputs = reader.readArray(numInnerPublicInputs, Fr);
+    return publicInputs;
   }
 
   /**

package/src/proofs/proving_request_type.ts

@@ -5,6 +5,7 @@ export enum ProvingRequestType {
   PUBLIC_BASE_ROLLUP,
   MERGE_ROLLUP,
   EMPTY_BLOCK_ROOT_ROLLUP,
+  PADDING_BLOCK_ROOT_ROLLUP,
   BLOCK_ROOT_ROLLUP,
   SINGLE_TX_BLOCK_ROOT_ROLLUP,
   BLOCK_MERGE_ROLLUP,

package/src/rollup/avm_proof_data.ts

@@ -1,15 +1,16 @@
-import { AVM_PROOF_LENGTH_IN_FIELDS } from '@aztec/constants';
+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 { VkWitnessData } from '../vks/vk_witness_data.js';
+import { VkData } from '../vks/vk_data.js';
 
 export class AvmProofData {
   constructor(
     public publicInputs: AvmCircuitPublicInputs,
-    public proof: RecursiveProof<typeof AVM_PROOF_LENGTH_IN_FIELDS>,
-    public vkData: VkWitnessData,
+    public proof: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>,
+    public vkData: VkData,
   ) {}
 
   static fromBuffer(buffer: Buffer | BufferReader) {
@@ -17,7 +18,7 @@ export class AvmProofData {
     return new AvmProofData(
       reader.readObject(AvmCircuitPublicInputs),
       RecursiveProof.fromBuffer(reader),
-      reader.readObject(VkWitnessData),
+      reader.readObject(VkData),
     );
   }
 
@@ -28,8 +29,14 @@ export class AvmProofData {
   static empty() {
     return new AvmProofData(
       AvmCircuitPublicInputs.empty(),
-      makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS),
-      VkWitnessData.empty(),
+      makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
+      VkData.empty(),
     );
   }
 }
+
+// TODO(#14234)[Unconditional PIs validation]: remove this function.
+export function enhanceProofWithPiValidationFlag(proof: Fr[], skipPublicInputsValidation: boolean): Fr[] {
+  const skipPublicInputsField = skipPublicInputsValidation ? new Fr(1) : new Fr(0);
+  return [skipPublicInputsField].concat(proof).slice(0, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED);
+}

package/src/rollup/base_or_merge_rollup_public_inputs.ts

@@ -5,18 +5,13 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { PartialStateReference } from '../tx/partial_state_reference.js';
-import { RollupTypes } from '../types/shared.js';
-import { ConstantRollupData } from './constant_rollup_data.js';
+import { BlockConstantData } from './block_constant_data.js';
 
 /**
  * Output of the base and merge rollup circuits.
  */
 export class BaseOrMergeRollupPublicInputs {
   constructor(
-    /**
-     * Specifies from which type of rollup circuit these inputs are from.
-     */
-    public rollupType: RollupTypes,
     /**
      * Number of txs in this rollup.
      */
@@ -24,7 +19,7 @@ export class BaseOrMergeRollupPublicInputs {
     /**
      * Data which is forwarded through the rollup circuits unchanged.
      */
-    public constants: ConstantRollupData,
+    public constants: BlockConstantData,
     /**
      * Partial state reference at the start of the rollup circuit.
      */
@@ -59,9 +54,8 @@ export class BaseOrMergeRollupPublicInputs {
   /** Returns an empty instance. */
   static empty() {
     return new BaseOrMergeRollupPublicInputs(
-      RollupTypes.Base,
       0,
-      ConstantRollupData.empty(),
+      BlockConstantData.empty(),
       PartialStateReference.empty(),
       PartialStateReference.empty(),
       SpongeBlob.empty(),
@@ -82,8 +76,7 @@ export class BaseOrMergeRollupPublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new BaseOrMergeRollupPublicInputs(
       reader.readNumber(),
-      reader.readNumber(),
-      reader.readObject(ConstantRollupData),
+      reader.readObject(BlockConstantData),
       reader.readObject(PartialStateReference),
       reader.readObject(PartialStateReference),
       reader.readObject(SpongeBlob),
@@ -100,7 +93,6 @@ export class BaseOrMergeRollupPublicInputs {
    */
   toBuffer() {
     return serializeToBuffer(
-      this.rollupType,
       this.numTxs,
       this.constants,
 

package/src/rollup/base_rollup_hints.ts

@@ -7,9 +7,10 @@ import { MembershipWitness } from '@aztec/foundation/trees';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { PublicDataHint } from '../avm/public_data_hint.js';
-import { ContractClassLog } from '../logs/contract_class_log.js';
+import { ContractClassLogFields } from '../logs/index.js';
+import { AppendOnlyTreeSnapshot } from '../trees/index.js';
 import { PartialStateReference } from '../tx/partial_state_reference.js';
-import { ConstantRollupData } from './constant_rollup_data.js';
+import { BlockConstantData } from './block_constant_data.js';
 import { PrivateBaseStateDiffHints } from './state_diff_hints.js';
 
 export type BaseRollupHints = PrivateBaseRollupHints | PublicBaseRollupHints;
@@ -39,11 +40,11 @@ export class PrivateBaseRollupHints {
     /**
      * Preimages to the kernel's contractClassLogsHashes.
      */
-    public contractClassLogsPreimages: Tuple<ContractClassLog, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
+    public contractClassLogsFields: Tuple<ContractClassLogFields, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
     /**
      * Data which is not modified by the base rollup circuit.
      */
-    public constants: ConstantRollupData,
+    public constants: BlockConstantData,
   ) {}
 
   static from(fields: FieldsOf<PrivateBaseRollupHints>): PrivateBaseRollupHints {
@@ -57,7 +58,7 @@ export class PrivateBaseRollupHints {
       fields.stateDiffHints,
       fields.feePayerFeeJuiceBalanceReadHint,
       fields.archiveRootMembershipWitness,
-      fields.contractClassLogsPreimages,
+      fields.contractClassLogsFields,
       fields.constants,
     ] as const;
   }
@@ -86,8 +87,8 @@ export class PrivateBaseRollupHints {
       reader.readObject(PrivateBaseStateDiffHints),
       reader.readObject(PublicDataHint),
       MembershipWitness.fromBuffer(reader, ARCHIVE_HEIGHT),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog),
-      reader.readObject(ConstantRollupData),
+      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
+      reader.readObject(BlockConstantData),
     );
   }
 
@@ -102,8 +103,8 @@ export class PrivateBaseRollupHints {
       PrivateBaseStateDiffHints.empty(),
       PublicDataHint.empty(),
       MembershipWitness.empty(ARCHIVE_HEIGHT),
-      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog.empty),
-      ConstantRollupData.empty(),
+      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLogFields.empty),
+      BlockConstantData.empty(),
     );
   }
 }
@@ -114,6 +115,10 @@ export class PublicBaseRollupHints {
      * Sponge state to absorb blob inputs at the start of the rollup.
      */
     public startSpongeBlob: SpongeBlob,
+    /**
+     * Archive tree snapshot at the very beginning of the block containing this base rollup.
+     */
+    public lastArchive: AppendOnlyTreeSnapshot,
     /**
      * Membership witnesses of blocks referred by each of the 2 kernels.
      */
@@ -121,11 +126,7 @@ export class PublicBaseRollupHints {
     /**
      * Preimages to the kernel's contractClassLogsHashes.
      */
-    public contractClassLogsPreimages: Tuple<ContractClassLog, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
-    /**
-     * Data which is not modified by the base rollup circuit.
-     */
-    public constants: ConstantRollupData,
+    public contractClassLogsFields: Tuple<ContractClassLogFields, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
   ) {}
 
   static from(fields: FieldsOf<PublicBaseRollupHints>): PublicBaseRollupHints {
@@ -135,9 +136,9 @@ export class PublicBaseRollupHints {
   static getFields(fields: FieldsOf<PublicBaseRollupHints>) {
     return [
       fields.startSpongeBlob,
+      fields.lastArchive,
       fields.archiveRootMembershipWitness,
-      fields.contractClassLogsPreimages,
-      fields.constants,
+      fields.contractClassLogsFields,
     ] as const;
   }
 
@@ -161,9 +162,9 @@ export class PublicBaseRollupHints {
     const reader = BufferReader.asReader(buffer);
     return new PublicBaseRollupHints(
       reader.readObject(SpongeBlob),
+      reader.readObject(AppendOnlyTreeSnapshot),
       MembershipWitness.fromBuffer(reader, ARCHIVE_HEIGHT),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog),
-      reader.readObject(ConstantRollupData),
+      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
     );
   }
 
@@ -174,9 +175,9 @@ export class PublicBaseRollupHints {
   static empty() {
     return new PublicBaseRollupHints(
       SpongeBlob.empty(),
+      AppendOnlyTreeSnapshot.empty(),
       MembershipWitness.empty(ARCHIVE_HEIGHT),
-      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog.empty),
-      ConstantRollupData.empty(),
+      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLogFields.empty),
     );
   }
 }

package/src/rollup/block_constant_data.ts

@@ -0,0 +1,63 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { GlobalVariables } from '../tx/global_variables.js';
+
+/**
+ * Constants that are the same for the entire block.
+ */
+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,
+    /** Root of the verification key tree. */
+    public vkTreeRoot: Fr,
+    /** Root of the protocol contract tree. */
+    public protocolContractTreeRoot: Fr,
+    /** Global variables for the block. */
+    public globalVariables: GlobalVariables,
+  ) {}
+
+  static from(fields: FieldsOf<BlockConstantData>): BlockConstantData {
+    return new BlockConstantData(...BlockConstantData.getFields(fields));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): BlockConstantData {
+    const reader = BufferReader.asReader(buffer);
+    return new BlockConstantData(
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      reader.readObject(GlobalVariables),
+    );
+  }
+
+  static getFields(fields: FieldsOf<BlockConstantData>) {
+    return [
+      fields.lastArchive,
+      fields.newL1ToL2,
+      fields.vkTreeRoot,
+      fields.protocolContractTreeRoot,
+      fields.globalVariables,
+    ] as const;
+  }
+
+  static empty() {
+    return new BlockConstantData(
+      AppendOnlyTreeSnapshot.empty(),
+      AppendOnlyTreeSnapshot.empty(),
+      Fr.ZERO,
+      Fr.ZERO,
+      GlobalVariables.empty(),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...BlockConstantData.getFields(this));
+  }
+}

package/src/rollup/block_root_or_block_merge_public_inputs.ts

@@ -9,12 +9,17 @@ import type { FieldsOf } from '@aztec/foundation/types';
 
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { GlobalVariables } from '../tx/global_variables.js';
+import { EpochConstantData } from './epoch_constant_data.js';
 
 /**
  * Output of the block root and block merge rollup circuits.
  */
 export class BlockRootOrBlockMergePublicInputs {
   constructor(
+    /**
+     * Constants for the entire epoch.
+     */
+    public constants: EpochConstantData,
     /**
      * Archive tree immediately before this block range.
      */
@@ -23,14 +28,6 @@ export class BlockRootOrBlockMergePublicInputs {
      * Archive tree after adding this block range.
      */
     public newArchive: AppendOnlyTreeSnapshot,
-    /**
-     * Identifier of the previous block before the range.
-     */
-    public previousBlockHash: Fr,
-    /**
-     * Identifier of the last block in the range.
-     */
-    public endBlockHash: Fr,
     /**
      * Global variables for the first block in the range.
      */
@@ -45,25 +42,17 @@ export class BlockRootOrBlockMergePublicInputs {
      */
     public outHash: Fr,
     /**
-     * The summed `transaction_fee`s and recipients of the constituent blocks.
+     * The hashes of the proposed block headers of the constituent blocks.
      */
-    public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public proposedBlockHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
     /**
-     * Root of the verification key tree.
-     */
-    public vkTreeRoot: Fr,
-    /**
-     * Root of the protocol contract tree.
-     */
-    public protocolContractTreeRoot: Fr,
-    /**
-     * TODO(#7346): Temporarily added prover_id while we verify block-root proofs on L1
+     * The summed `transaction_fee`s and recipients of the constituent blocks.
      */
-    public proverId: Fr,
+    public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
     /**
-     * Public inputs required to verify a blob (challenge point z, evaluation y = p(z), and the commitment to p() for each blob)
+     * Public inputs required to verify a batch of blobs.
      */
-    public blobPublicInputs: Tuple<BlockBlobPublicInputs, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public blobPublicInputs: BlockBlobPublicInputs,
   ) {}
 
   /**
@@ -74,18 +63,15 @@ export class BlockRootOrBlockMergePublicInputs {
   static fromBuffer(buffer: Buffer | BufferReader): BlockRootOrBlockMergePublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new BlockRootOrBlockMergePublicInputs(
+      reader.readObject(EpochConstantData),
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(AppendOnlyTreeSnapshot),
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
       reader.readObject(GlobalVariables),
       reader.readObject(GlobalVariables),
       Fr.fromBuffer(reader),
+      reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
       reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      reader.readArray(AZTEC_MAX_EPOCH_DURATION, BlockBlobPublicInputs),
+      reader.readObject(BlockBlobPublicInputs),
     );
   }
 
@@ -95,17 +81,14 @@ export class BlockRootOrBlockMergePublicInputs {
    */
   toBuffer() {
     return serializeToBuffer(
+      this.constants,
       this.previousArchive,
       this.newArchive,
-      this.previousBlockHash,
-      this.endBlockHash,
       this.startGlobalVariables,
       this.endGlobalVariables,
       this.outHash,
+      this.proposedBlockHeaderHashes,
       this.fees,
-      this.vkTreeRoot,
-      this.protocolContractTreeRoot,
-      this.proverId,
       this.blobPublicInputs,
     );
   }
@@ -139,7 +122,10 @@ export class BlockRootOrBlockMergePublicInputs {
 }
 
 export class FeeRecipient {
-  constructor(public recipient: EthAddress, public value: Fr) {}
+  constructor(
+    public recipient: EthAddress,
+    public value: Fr,
+  ) {}
 
   static fromBuffer(buffer: Buffer | BufferReader): FeeRecipient {
     const reader = BufferReader.asReader(buffer);

package/src/rollup/block_root_rollup.ts

@@ -1,3 +1,4 @@
+import { BlobAccumulatorPublicInputs, FinalBlobBatchingChallenges } from '@aztec/blob-lib';
 import {
   ARCHIVE_HEIGHT,
   BLOBS_PER_BLOCK,
@@ -5,7 +6,7 @@ import {
   L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
   NESTED_RECURSIVE_PROOF_LENGTH,
 } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { BLS12Point, Fr } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -25,6 +26,10 @@ export class BlockRootRollupData {
      * Hint for inserting the new l1 to l2 message subtree.
      */
     public l1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>,
+    /**
+     * Hint for checking the hash of previous_block_header is the last leaf of the previous archive.
+     */
+    public previousArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
     /**
      * Hint for inserting the new block hash to the last archive.
      */
@@ -34,7 +39,15 @@ export class BlockRootRollupData {
      */
     public previousBlockHeader: BlockHeader,
     /**
-     * TODO(#7346): Temporarily added prover_id while we verify block-root proofs on L1
+     * The current blob accumulation state across the epoch.
+     */
+    public startBlobAccumulator: BlobAccumulatorPublicInputs,
+    /**
+     * Finalized challenges z and gamma for performing blob batching. Shared value across the epoch.
+     */
+    public finalBlobChallenges: FinalBlobBatchingChallenges,
+    /**
+     * Identifier of the prover.
      */
     public proverId: Fr,
   ) {}
@@ -73,8 +86,11 @@ export class BlockRootRollupData {
     return [
       fields.l1ToL2Roots,
       fields.l1ToL2MessageSubtreeSiblingPath,
+      fields.previousArchiveSiblingPath,
       fields.newArchiveSiblingPath,
       fields.previousBlockHeader,
+      fields.startBlobAccumulator,
+      fields.finalBlobChallenges,
       fields.proverId,
     ] as const;
   }
@@ -90,7 +106,10 @@ export class BlockRootRollupData {
       RootParityInput.fromBuffer(reader, NESTED_RECURSIVE_PROOF_LENGTH),
       reader.readArray(L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, Fr),
       reader.readArray(ARCHIVE_HEIGHT, Fr),
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
       BlockHeader.fromBuffer(reader),
+      reader.readObject(BlobAccumulatorPublicInputs),
+      reader.readObject(FinalBlobBatchingChallenges),
       Fr.fromBuffer(reader),
     );
   }
@@ -125,9 +144,8 @@ export class BlockRootRollupBlobData {
     public blobFields: Fr[],
     /**
      * KZG commitments representing the blob (precomputed in ts, injected to use inside circuit).
-     * TODO(Miranda): Rename to kzg_commitment to match BlobPublicInputs?
      */
-    public blobCommitments: Tuple<Tuple<Fr, 2>, typeof BLOBS_PER_BLOCK>,
+    public blobCommitments: Tuple<BLS12Point, typeof BLOBS_PER_BLOCK>,
     /**
      * The hash of eth blob hashes for this block
      * See yarn-project/foundation/src/blob/index.ts or body.ts for calculation
@@ -180,7 +198,7 @@ export class BlockRootRollupBlobData {
       // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
       // reader.readArray(FIELDS_PER_BLOB, Fr),
       Array.from({ length: FIELDS_PER_BLOB * BLOBS_PER_BLOCK }, () => Fr.fromBuffer(reader)),
-      reader.readArray(BLOBS_PER_BLOCK, { fromBuffer: () => reader.readArray(2, Fr) }),
+      reader.readArray(BLOBS_PER_BLOCK, BLS12Point),
       Fr.fromBuffer(reader),
     );
   }

package/src/rollup/empty_block_root_rollup_inputs.ts

@@ -3,8 +3,8 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
+import { BlockConstantData } from './block_constant_data.js';
 import { BlockRootRollupData } from './block_root_rollup.js';
-import { ConstantRollupData } from './constant_rollup_data.js';
 
 /**
  * Represents inputs of the empty block root rollup circuit.
@@ -12,8 +12,7 @@ import { ConstantRollupData } from './constant_rollup_data.js';
 export class EmptyBlockRootRollupInputs {
   constructor(
     public readonly data: BlockRootRollupData,
-    public readonly constants: ConstantRollupData,
-    public readonly isPadding: boolean,
+    public readonly constants: BlockConstantData,
   ) {}
 
   /**
@@ -47,7 +46,7 @@ export class EmptyBlockRootRollupInputs {
    * @returns An array of fields.
    */
   static getFields(fields: FieldsOf<EmptyBlockRootRollupInputs>) {
-    return [fields.data, fields.constants, fields.isPadding] as const;
+    return [fields.data, fields.constants] as const;
   }
 
   /**
@@ -57,11 +56,7 @@ export class EmptyBlockRootRollupInputs {
    */
   static fromBuffer(buffer: Buffer | BufferReader): EmptyBlockRootRollupInputs {
     const reader = BufferReader.asReader(buffer);
-    return new EmptyBlockRootRollupInputs(
-      reader.readObject(BlockRootRollupData),
-      reader.readObject(ConstantRollupData),
-      reader.readBoolean(),
-    );
+    return new EmptyBlockRootRollupInputs(reader.readObject(BlockRootRollupData), reader.readObject(BlockConstantData));
   }
 
   /**