feat: WIP batch blobs and validate in rollup

noir-projects/noir-protocol-circuits/crates/blob/src/blob_public_inputs.nr

@@ -6,6 +6,8 @@ use types::{
     utils::reader::Reader,
 };
 
+// TODO(MW): delete
+
 // NB: This only exists because a nested array of [[Field; 2]; N] did not build with ci2.5, but was fine otherwise
 // For blobs, we use the compressed 48 byte BLS12 commitment to compute the challenge. We never need to operate on it,
 // so it's encoded as 2 fields. The first is the first 31 bytes, and the second is the next 17 bytes.

noir-projects/noir-protocol-circuits/crates/rollup-lib/Nargo.toml

@@ -5,6 +5,7 @@ authors = [""]
 compiler_version = ">=0.18.0"
 
 [dependencies]
+bigint = { tag = "v0.7.3", git = "https://github.com/noir-lang/noir-bignum" }
 types = { path = "../types" }
 parity_lib = { path = "../parity-lib" }
 blob = { path = "../blob" }

noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/block_root_or_block_merge_public_inputs.nr

@@ -8,7 +8,7 @@ use dep::types::{
     traits::{Deserialize, Empty, Serialize, ToField},
     utils::reader::Reader,
 };
-use blob::blob_public_inputs::BlockBlobPublicInputs;
+use blob::blob_batching_public_inputs::BlockBlobPublicInputs;
 
 pub struct FeeRecipient {
     pub recipient: EthAddress,
@@ -53,7 +53,7 @@ pub struct BlockRootOrBlockMergePublicInputs {
     pub vk_tree_root: Field, // Root of allowed vk tree
     pub protocol_contract_tree_root: Field, // Root of protocol contract tree
     pub prover_id: Field, // TODO(#7346): Temporarily added prover_id while we verify block-root proofs on L1
-    pub blob_public_inputs: [BlockBlobPublicInputs; AZTEC_MAX_EPOCH_DURATION], // z, y, and C s.t. p(z) = y and C commits to p, for blob verification
+    pub blob_public_inputs: BlockBlobPublicInputs, // Blob accumulators at the start and end of this block range
 }
 
 impl BlockRootOrBlockMergePublicInputs {
@@ -75,7 +75,7 @@ impl Empty for BlockRootOrBlockMergePublicInputs {
             vk_tree_root: 0,
             protocol_contract_tree_root: 0,
             prover_id: 0,
-            blob_public_inputs: [BlockBlobPublicInputs::empty(); AZTEC_MAX_EPOCH_DURATION],
+            blob_public_inputs: BlockBlobPublicInputs::empty(),
         }
     }
 }
@@ -113,9 +113,7 @@ impl Serialize<BLOCK_ROOT_OR_BLOCK_MERGE_PUBLIC_INPUTS_LENGTH> for BlockRootOrBl
         fields.push(self.vk_tree_root);
         fields.push(self.protocol_contract_tree_root);
         fields.push(self.prover_id as Field);
-        for i in 0..AZTEC_MAX_EPOCH_DURATION {
-            fields.extend_from_array(self.blob_public_inputs[i].serialize());
-        }
+        fields.extend_from_array(self.blob_public_inputs.serialize());
         assert_eq(fields.len(), BLOCK_ROOT_OR_BLOCK_MERGE_PUBLIC_INPUTS_LENGTH);
 
         fields.storage()
@@ -141,10 +139,7 @@ impl Deserialize<BLOCK_ROOT_OR_BLOCK_MERGE_PUBLIC_INPUTS_LENGTH> for BlockRootOr
             vk_tree_root: reader.read(),
             protocol_contract_tree_root: reader.read(),
             prover_id: reader.read(),
-            blob_public_inputs: reader.read_struct_array(
-                BlockBlobPublicInputs::deserialize,
-                [BlockBlobPublicInputs::empty(); AZTEC_MAX_EPOCH_DURATION],
-            ),
+            blob_public_inputs: reader.read_struct(BlockBlobPublicInputs::deserialize),
         };
 
         reader.finish();

noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/block_root_rollup_data.nr

@@ -1,4 +1,6 @@
-use blob::blob_public_inputs::BlobCommitment;
+use blob::blob_batching_public_inputs::{
+    BlobAccumulatorPublicInputs, BLSPoint, FinalBlobBatchingChallenges,
+};
 use parity_lib::root::root_rollup_parity_input::RootRollupParityInput;
 use types::{
     block_header::BlockHeader,
@@ -23,17 +25,29 @@ pub struct BlockRootRollupData {
     // Its hash is checked against the previous archive.
     pub previous_block_header: BlockHeader,
 
+    // <-- NOTE: start_blob_accumulator and  final_blob_challenges exist here and not BlockRootRollupBlobData
+    // so we can inject easily into EmptyBlockRootRollupInputs:
+
+    // The current blob accumulation state across the epoch.
+    // Injected here and checked vs the previous end state in each block merge and root rollup circuit:
+    pub start_blob_accumulator: BlobAccumulatorPublicInputs,
+    // Finalized challenges z and gamma for performing blob batching. Shared value across the epoch
+    // Precompjuted, injected here, and confirmed in the root rollup circuit:
+    pub final_blob_challenges: FinalBlobBatchingChallenges,
+
+    // -->
+
     // TODO(#7346): Temporarily added prover_id while we verify block-root proofs on L1
     pub prover_id: Field,
 }
 
 pub struct BlockRootRollupBlobData {
     // Fields for blob verification made of all tx effects in this block
-    // (will likely change to be accumulated and sent up to the final root)
     pub blobs_fields: [Field; FIELDS_PER_BLOB * BLOBS_PER_BLOCK],
-    // see blob/src/blob.nr -> evaluate_blob() -  these are used for creating the challenge z
-    pub blob_commitments: [BlobCommitment; BLOBS_PER_BLOCK],
+    // see blob/src/blob.nr -> evaluate_blob() -  these are used for creating each blob's challenge z_i
+    pub blob_commitments: [BLSPoint; BLOBS_PER_BLOCK],
     // Flat sha256 hash of the EVM blob hashes, can be injected here as the contract checks its validity vs the blob_public_inputs
     // NB: to fit it into a field, we truncate to 31 bytes
+    // TODO(MW): Replace with v?
     pub blobs_hash: Field,
 }

noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/block_merge_rollup_inputs.nr

@@ -8,6 +8,7 @@ use dep::types::{
     },
     traits::Empty,
 };
+use blob::blob_batching_public_inputs::BlockBlobPublicInputs;
 
 global ALLOWED_PREVIOUS_CIRCUITS: [u32; 4] = [
     BLOCK_ROOT_ROLLUP_INDEX,
@@ -54,11 +55,11 @@ impl BlockMergeRollupInputs {
 
         let fees = components::accumulate_blocks_fees(left, right);
 
-        // TODO: We need to eventually accumulate blob info to a single BlobPublicInputs instance which will verify multiple blobs in one call
-        // For now, we do them individually
-        // How we accumulate is being worked on by @Mike
-        // let blob_public_inputs = left.blob_public_inputs.accumulate(right.blob_public_inputs);
-        let blob_public_inputs = components::accumulate_blob_public_inputs(left, right);
+        let blob_public_inputs = BlockBlobPublicInputs {
+            start_blob_accumulator: left.blob_public_inputs.start_blob_accumulator,
+            end_blob_accumulator: right.blob_public_inputs.end_blob_accumulator,
+            final_blob_challenges: left.blob_public_inputs.final_blob_challenges,
+        };
 
         // TODO(MW): Batching here will consist of checks:
         // - left.end_blob_accumulator == right.start_blob_accumulator
@@ -107,6 +108,14 @@ mod tests {
         let _output = inputs.block_merge_rollup_circuit();
     }
 
+    #[test(should_fail_with = "input blocks have different epoch blob challenges")]
+    fn blob_different_challenges_fails() {
+        let mut inputs = default_block_merge_rollup_inputs();
+        inputs.previous_rollup_data[0].block_root_or_block_merge_public_inputs.blob_public_inputs.final_blob_challenges.z +=
+            1;
+        let _output = inputs.block_merge_rollup_circuit();
+    }
+
     #[test(should_fail_with = "input blocks have different archive tree snapshots")]
     fn previous_rollups_dont_follow_archive() {
         let mut inputs = default_block_merge_rollup_inputs();
@@ -126,6 +135,14 @@ mod tests {
         let _output = inputs.block_merge_rollup_circuit();
     }
 
+    #[test(should_fail_with = "input block blob accumulators do not follow on from each other")]
+    fn previous_rollups_dont_follow_blob_accumulator() {
+        let mut inputs = default_block_merge_rollup_inputs();
+        inputs.previous_rollup_data[0].block_root_or_block_merge_public_inputs.blob_public_inputs.end_blob_accumulator.z_acc +=
+            1;
+        let _output = inputs.block_merge_rollup_circuit();
+    }
+
     #[test]
     fn block_fees_are_accumulated() {
         let mut inputs = default_block_merge_rollup_inputs();
@@ -156,16 +173,18 @@ mod tests {
         let outputs = inputs.block_merge_rollup_circuit();
 
         assert_eq(
-            outputs.blob_public_inputs[0],
+            outputs.blob_public_inputs.start_blob_accumulator,
             inputs.previous_rollup_data[0]
                 .block_root_or_block_merge_public_inputs
-                .blob_public_inputs[0],
+                .blob_public_inputs
+                .start_blob_accumulator,
         );
         assert_eq(
-            outputs.blob_public_inputs[1],
+            outputs.blob_public_inputs.end_blob_accumulator,
             inputs.previous_rollup_data[1]
                 .block_root_or_block_merge_public_inputs
-                .blob_public_inputs[0],
+                .blob_public_inputs
+                .end_blob_accumulator,
         );
     }