feat(config): Added blobs to commit batches and made da source part of config

core/lib/config/src/configs/eth_sender.rs

@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use zksync_basic_types::H256;
 
 /// Configuration for the Ethereum sender crate.
@@ -35,6 +35,7 @@ impl ETHSenderConfig {
                 l1_batch_min_age_before_execute_seconds: None,
                 max_acceptable_priority_fee_in_gwei: 100000000000,
                 proof_loading_mode: ProofLoadingMode::OldProofFromDb,
+                pubdata_sending_mode: PubdataSendingMode::Calldata,
             },
             gas_adjuster: GasAdjusterConfig {
                 default_priority_fee_per_gas: 1000000000,
@@ -63,6 +64,14 @@ pub enum ProofLoadingMode {
     FriProofFromGcs,
 }
 
+#[derive(Debug, Deserialize, Clone, Copy, PartialEq, Serialize, Default)]
+pub enum PubdataSendingMode {
+    #[default]
+    Calldata,
+    OneBlob,
+    TwoBlobs,
+}
+
 #[derive(Debug, Deserialize, Clone, PartialEq)]
 pub struct SenderConfig {
     pub aggregated_proof_sizes: Vec<usize>,
@@ -96,6 +105,10 @@ pub struct SenderConfig {
 
     /// The mode in which proofs are loaded, either from DB/GCS for FRI/Old proof.
     pub proof_loading_mode: ProofLoadingMode,
+
+    /// The mode in which we send pubdata, either Calldata, 1 Blob, or 2 Blobs/
+    /// If not specified, Calldata will be used
+    pub pubdata_sending_mode: PubdataSendingMode,
 }
 
 impl SenderConfig {

core/lib/config/src/testonly.rs

@@ -5,7 +5,7 @@ use zksync_basic_types::{
     basic_fri_types::CircuitIdRoundTuple, network::Network, Address, L2ChainId, H256,
 };
 
-use crate::configs;
+use crate::configs::{self, eth_sender::PubdataSendingMode};
 
 /// Generator of random configs.
 pub struct Gen<'a, R: Rng> {
@@ -457,6 +457,16 @@ impl RandomConfig for configs::eth_sender::ProofLoadingMode {
     }
 }
 
+impl RandomConfig for configs::eth_sender::PubdataSendingMode {
+    fn sample(g: &mut Gen<impl Rng>) -> Self {
+        match g.rng.gen_range(0..3) {
+            0 => Self::Calldata,
+            1 => Self::OneBlob,
+            _ => Self::TwoBlobs,
+        }
+    }
+}
+
 impl RandomConfig for configs::eth_sender::SenderConfig {
     fn sample(g: &mut Gen<impl Rng>) -> Self {
         Self {
@@ -477,6 +487,7 @@ impl RandomConfig for configs::eth_sender::SenderConfig {
             l1_batch_min_age_before_execute_seconds: g.gen(),
             max_acceptable_priority_fee_in_gwei: g.gen(),
             proof_loading_mode: g.gen(),
+            pubdata_sending_mode: PubdataSendingMode::Calldata,
         }
     }
 }

core/lib/constants/src/ethereum.rs

@@ -5,11 +5,6 @@ pub const PRIORITY_EXPIRATION: u64 = 50000;
 pub const MAX_L1_TRANSACTION_GAS_LIMIT: u64 = 300000;
 pub const ETHEREUM_ADDRESS: Address = Address::zero();
 
-/// The maximum number of pubdata per L1 batch. This limit is due to the fact that the Ethereum
-/// nodes do not accept transactions that have more than 128kb of pubdata.
-/// The 18kb margin is left in case of any impreciseness of the pubdata calculation.
-pub const MAX_PUBDATA_PER_L1_BATCH: u64 = 110000;
-
 // TODO: import from `zkevm_opcode_defs` once `VM1.3` is supported
 pub const MAX_L2_TX_GAS_LIMIT: u64 = 80000000;
 

core/lib/env_config/src/eth_sender.rs

@@ -26,7 +26,9 @@ impl FromEnv for GasAdjusterConfig {
 
 #[cfg(test)]
 mod tests {
-    use zksync_config::configs::eth_sender::{ProofLoadingMode, ProofSendingMode};
+    use zksync_config::configs::eth_sender::{
+        ProofLoadingMode, ProofSendingMode, PubdataSendingMode,
+    };
 
     use super::*;
     use crate::test_utils::{hash, EnvMutex};
@@ -54,6 +56,7 @@ mod tests {
                 l1_batch_min_age_before_execute_seconds: Some(1000),
                 max_acceptable_priority_fee_in_gwei: 100_000_000_000,
                 proof_loading_mode: ProofLoadingMode::OldProofFromDb,
+                pubdata_sending_mode: PubdataSendingMode::Calldata,
             },
             gas_adjuster: GasAdjusterConfig {
                 default_priority_fee_per_gas: 20000000000,
@@ -98,6 +101,7 @@ mod tests {
             ETH_SENDER_SENDER_L1_BATCH_MIN_AGE_BEFORE_EXECUTE_SECONDS="1000"
             ETH_SENDER_SENDER_MAX_ACCEPTABLE_PRIORITY_FEE_IN_GWEI="100000000000"
             ETH_SENDER_SENDER_PROOF_LOADING_MODE="OldProofFromDb"
+            ETH_SENDER_SENDER_PUBDATA_SENDING_MODE="Calldata"
         "#;
         lock.set_env(config);
 

core/lib/l1_contract_interface/Cargo.toml

@@ -20,10 +20,12 @@ codegen = { git = "https://github.com/matter-labs/solidity_plonk_verifier.git",
 zkevm_test_harness_1_3_3 = { package = "zkevm_test_harness", git = "https://github.com/matter-labs/era-zkevm_test_harness.git", branch = "v1.3.3" }
 
 # Used to calculate the kzg commitment and proofs
-zkevm_test_harness_1_4_1 = { package = "zkevm_test_harness", git = "https://github.com/matter-labs/era-zkevm_test_harness.git", branch = "v1.4.1" }
+zkevm_test_harness_1_4_2 = { package = "zkevm_test_harness", git = "https://github.com/matter-labs/era-zkevm_test_harness.git", branch = "v1.4.2" }
 sha2 = "0.10.8"
 sha3 = "0.10.8"
 
+once_cell = "1.19"
+
 [dev-dependencies]
 hex = "0.4"
 serde = "1.0.90"

core/lib/l1_contract_interface/src/i_executor/commit/kzg.rs

@@ -6,7 +6,7 @@ use std::convert::TryInto;
 use sha2::Sha256;
 use sha3::{Digest, Keccak256};
 use zkevm_test_harness_1_3_3::ff::{PrimeField, PrimeFieldRepr};
-use zkevm_test_harness_1_4_1::{
+use zkevm_test_harness_1_4_2::{
     kzg::{compute_commitment, compute_proof, compute_proof_poly, KzgSettings},
     zkevm_circuits::{
         boojum::pairing::{
@@ -21,7 +21,7 @@ use zkevm_test_harness_1_4_1::{
     },
 };
 
-const ZK_SYNC_BYTES_PER_BLOB: usize = BLOB_CHUNK_SIZE * ELEMENTS_PER_4844_BLOCK;
+pub const ZK_SYNC_BYTES_PER_BLOB: usize = BLOB_CHUNK_SIZE * ELEMENTS_PER_4844_BLOCK;
 const EIP_4844_BYTES_PER_BLOB: usize = 32 * ELEMENTS_PER_4844_BLOCK;
 
 /// Packed pubdata commitments.
@@ -89,7 +89,7 @@ impl KzgInfo {
 
     /// Returns the bytes necessary for pubdata commitment part of batch commitments when blobs are used.
     /// Return format: opening point (16 bytes) || claimed value (32 bytes) || commitment (48 bytes)
-    ///                || opening proof (48 bytes))
+    ///                || opening proof (48 bytes)
     pub fn to_pubdata_commitment(&self) -> [u8; BYTES_PER_PUBDATA_COMMITMENT] {
         let mut res = [0u8; BYTES_PER_PUBDATA_COMMITMENT];
         // The crypto team/batch commitment expects the opening point to be 16 bytes
@@ -102,6 +102,22 @@ impl KzgInfo {
         res
     }
 
+    /// Computes the commitment to the blob needed as part of the batch commitment through the aux output
+    /// Format is: Keccak(versioned hash || opening point || opening value)
+    pub fn to_blob_commitment(&self) -> [u8; 32] {
+        let mut commitment = [0u8; 32];
+        let hash = &Keccak256::digest(
+            [
+                self.versioned_hash.as_slice(),
+                &self.opening_point[16..],
+                self.opening_value.as_slice(),
+            ]
+            .concat(),
+        );
+        commitment.copy_from_slice(hash);
+        commitment
+    }
+
     /// Deserializes `Self::SERIALIZED_SIZE` bytes into `KzgInfo` struct
     pub fn from_slice(data: &[u8]) -> Self {
         assert_eq!(data.len(), Self::SERIALIZED_SIZE);
@@ -183,7 +199,7 @@ impl KzgInfo {
     ///     7. opening point <- keccak(linear hash || versioned hash)[16..]
     ///     8. opening value, opening proof <- `compute_kzg_proof`(4844)
     ///     9. blob proof <- `compute_proof_poly`(blob, 4844 `kzg` commitment)
-    pub fn new(kzg_settings: &KzgSettings, pubdata: Vec<u8>) -> Self {
+    pub fn new(kzg_settings: &KzgSettings, pubdata: &Vec<u8>) -> Self {
         assert!(pubdata.len() <= ZK_SYNC_BYTES_PER_BLOB);
 
         let mut zksync_blob = [0u8; ZK_SYNC_BYTES_PER_BLOB];
@@ -250,7 +266,7 @@ impl KzgInfo {
 mod tests {
     use serde::{Deserialize, Serialize};
     use serde_with::{self, serde_as};
-    use zkevm_test_harness_1_4_1::{
+    use zkevm_test_harness_1_4_2::{
         boojum::pairing::{
             bls12_381::{Fr, FrRepr, G1Affine, G1Compressed},
             EncodedPoint,
@@ -322,7 +338,7 @@ mod tests {
         let path = std::path::Path::new(&zksync_home).join("trusted_setup.json");
         let kzg_settings = KzgSettings::new(path.to_str().unwrap());
 
-        let kzg_info = KzgInfo::new(&kzg_settings, kzg_test.pubdata);
+        let kzg_info = KzgInfo::new(&kzg_settings, &kzg_test.pubdata);
 
         // Verify all the fields were correctly computed
         assert_eq!(
@@ -392,7 +408,7 @@ mod tests {
         let path = std::path::Path::new(&zksync_home).join("trusted_setup.json");
         let kzg_settings = KzgSettings::new(path.to_str().unwrap());
 
-        let kzg_info = KzgInfo::new(&kzg_settings, kzg_test.pubdata);
+        let kzg_info = KzgInfo::new(&kzg_settings, &kzg_test.pubdata);
 
         let encoded_info = kzg_info.to_bytes();
         assert_eq!(KzgInfo::SERIALIZED_SIZE, encoded_info.len());

core/lib/l1_contract_interface/src/i_executor/commit/mod.rs

@@ -1 +1 @@
-mod kzg;
+pub mod kzg;

core/lib/l1_contract_interface/src/i_executor/methods/commit_batches.rs

@@ -1,3 +1,6 @@
+// TODO: Remove once integrated into batch commit
+#![allow(dead_code)]
+
 use zksync_types::{commitment::L1BatchWithMetadata, ethabi::Token};
 
 use crate::{
@@ -24,3 +27,27 @@ impl Tokenize for CommitBatches {
         vec![stored_batch_info, Token::Array(l1_batches_to_commit)]
     }
 }
+
+impl CommitBatches {
+    fn into_tokens_blobs(self, number_of_blobs: usize) -> Vec<Token> {
+        let stored_batch_info = StoredBatchInfo(&self.last_committed_l1_batch).into_token();
+        let l1_batches_to_commit = self
+            .l1_batches
+            .iter()
+            .map(|batch| CommitBatchInfo(batch).into_tokens_blobs(number_of_blobs))
+            .collect();
+
+        vec![stored_batch_info, Token::Array(l1_batches_to_commit)]
+    }
+
+    fn into_tokens_calldata(self) -> Vec<Token> {
+        let stored_batch_info = StoredBatchInfo(&self.last_committed_l1_batch).into_token();
+        let l1_batches_to_commit = self
+            .l1_batches
+            .iter()
+            .map(|batch| CommitBatchInfo(batch).into_tokens_calldata())
+            .collect();
+
+        vec![stored_batch_info, Token::Array(l1_batches_to_commit)]
+    }
+}