feat(l1,l2): support fusaka blobs cell_proofs

cmd/ethrex/l2/options.rs

@@ -189,6 +189,7 @@ impl TryFrom<SequencerOptions> for SequencerConfig {
                 maximum_allowed_max_fee_per_blob_gas: opts
                     .eth_opts
                     .maximum_allowed_max_fee_per_blob_gas,
+                osaka_activation_time: opts.eth_opts.osaka_activation_time,
             },
             l1_watcher: L1WatcherConfig {
                 bridge_address: opts
@@ -339,6 +340,13 @@ pub struct EthOptions {
         help_heading = "Eth options"
     )]
     pub max_retry_delay: u64,
+    #[clap(
+        long,
+        value_name = "UINT64",
+        env = "ETHREX_OSAKA_ACTIVATION_TIME",
+        help = "Block timestamp at which the Osaka fork is activated on L1. If not set, it will assume Osaka is already active."
+    )]
+    pub osaka_activation_time: Option<u64>,
 }
 
 impl Default for EthOptions {
@@ -353,6 +361,7 @@ impl Default for EthOptions {
             backoff_factor: BACKOFF_FACTOR,
             min_retry_delay: MIN_RETRY_DELAY,
             max_retry_delay: MAX_RETRY_DELAY,
+            osaka_activation_time: None,
         }
     }
 }

crates/common/crypto/kzg.rs

@@ -69,7 +69,11 @@ pub fn verify_cell_kzg_proof_batch(
         let c_kzg_settings = c_kzg::ethereum_kzg_settings(KZG_PRECOMPUTE);
         let mut cells = Vec::new();
         for blob in blobs {
-            cells.extend(c_kzg_settings.compute_cells(&(*blob).into())?.into_iter());
+            let blob: c_kzg::Blob = (*blob).into();
+            let cells_blob = c_kzg_settings
+                .compute_cells(&blob)
+                .map_err(KzgError::CKzg)?;
+            cells.extend(*cells_blob);
         }
         c_kzg::KzgSettings::verify_cell_kzg_proof_batch(
             c_kzg_settings,
@@ -180,15 +184,35 @@ pub fn verify_kzg_proof(
 pub fn blob_to_kzg_commitment_and_proof(blob: &Blob) -> Result<(Commitment, Proof), KzgError> {
     let blob: c_kzg::Blob = (*blob).into();
 
-    let commitment = c_kzg::KzgSettings::blob_to_kzg_commitment(
-        c_kzg::ethereum_kzg_settings(KZG_PRECOMPUTE),
-        &blob,
-    )?;
-    let commitment_bytes = commitment.to_bytes();
     let c_kzg_settings = c_kzg::ethereum_kzg_settings(KZG_PRECOMPUTE);
+
+    let commitment = c_kzg::KzgSettings::blob_to_kzg_commitment(c_kzg_settings, &blob)?;
+
+    let commitment_bytes = commitment.to_bytes();
     let proof = c_kzg_settings.compute_blob_kzg_proof(&blob, &commitment_bytes)?;
 
     let proof_bytes = proof.to_bytes();
 
     Ok((commitment_bytes.into_inner(), proof_bytes.into_inner()))
 }
+
+#[cfg(feature = "c-kzg")]
+pub fn blob_to_commitment_and_cell_proofs(
+    blob: &Blob,
+) -> Result<(Commitment, Vec<Proof>), KzgError> {
+    let c_kzg_settings = c_kzg::ethereum_kzg_settings(KZG_PRECOMPUTE);
+
+    let blob: c_kzg::Blob = (*blob).into();
+
+    let commitment = c_kzg::KzgSettings::blob_to_kzg_commitment(c_kzg_settings, &blob)?;
+
+    let commitment_bytes = commitment.to_bytes();
+
+    let (_cells, cell_proofs) = c_kzg_settings
+        .compute_cells_and_kzg_proofs(&blob)
+        .map_err(KzgError::CKzg)?;
+
+    let cell_proofs = cell_proofs.map(|p| p.to_bytes().into_inner());
+
+    Ok((commitment_bytes.into_inner(), cell_proofs.to_vec()))
+}

crates/common/types/blobs_bundle.rs

@@ -1,6 +1,8 @@
 use std::ops::AddAssign;
 
 use crate::serde_utils;
+#[cfg(feature = "c-kzg")]
+use crate::types::Fork;
 use crate::types::constants::VERSIONED_HASH_VERSION_KZG;
 use crate::{Bytes, H256};
 
@@ -80,23 +82,34 @@ impl BlobsBundle {
 
     // In the future we might want to provide a new method that calculates the commitments and proofs using the following.
     #[cfg(feature = "c-kzg")]
-    pub fn create_from_blobs(blobs: &Vec<Blob>) -> Result<Self, BlobsBundleError> {
-        use ethrex_crypto::kzg::blob_to_kzg_commitment_and_proof;
+    pub fn create_from_blobs(
+        blobs: &Vec<Blob>,
+        wrapper_version: Option<u8>,
+    ) -> Result<Self, BlobsBundleError> {
+        use ethrex_crypto::kzg::{
+            blob_to_commitment_and_cell_proofs, blob_to_kzg_commitment_and_proof,
+        };
         let mut commitments = Vec::new();
         let mut proofs = Vec::new();
 
         // Populate the commitments and proofs
         for blob in blobs {
-            let (commitment, proof) = blob_to_kzg_commitment_and_proof(blob)?;
-            commitments.push(commitment);
-            proofs.push(proof);
+            if wrapper_version.unwrap_or(0) == 0 {
+                let (commitment, proof) = blob_to_kzg_commitment_and_proof(blob)?;
+                commitments.push(commitment);
+                proofs.push(proof);
+            } else {
+                let (commitment, cell_proofs) = blob_to_commitment_and_cell_proofs(blob)?;
+                commitments.push(commitment);
+                proofs.extend(cell_proofs);
+            }
         }
 
         Ok(Self {
             blobs: blobs.clone(),
             commitments,
             proofs,
-            version: 0,
+            version: wrapper_version.unwrap_or(0),
         })
     }
 
@@ -127,6 +140,10 @@ impl BlobsBundle {
             return Err(BlobsBundleError::BlobBundleEmptyError);
         }
 
+        if self.version == 0 && fork >= Fork::Osaka || self.version != 0 && fork < Fork::Osaka {
+            return Err(BlobsBundleError::InvalidBlobVersionForFork);
+        }
+
         // Check if the blob versioned hashes and blobs bundle content length mismatch
         if blob_count != self.commitments.len()
             || (self.version == 0 && blob_count != self.proofs.len())
@@ -231,6 +248,8 @@ pub enum BlobsBundleError {
     BlobToCommitmentAndProofError,
     #[error("Max blobs per block exceeded")]
     MaxBlobsExceeded,
+    #[error("Invalid blob version for the current fork")]
+    InvalidBlobVersionForFork,
     #[cfg(feature = "c-kzg")]
     #[error("KZG related error: {0}")]
     Kzg(#[from] ethrex_crypto::kzg::KzgError),
@@ -259,7 +278,7 @@ mod tests {
             })
             .collect();
 
-        let blobs_bundle = crate::types::BlobsBundle::create_from_blobs(&blobs)
+        let blobs_bundle = crate::types::BlobsBundle::create_from_blobs(&blobs, None)
             .expect("Failed to create blobs bundle");
 
         let blob_versioned_hashes = blobs_bundle.generate_versioned_hashes();
@@ -284,6 +303,78 @@ mod tests {
         ));
     }
 
+    #[test]
+    #[cfg(feature = "c-kzg")]
+    fn transaction_with_valid_blobs_should_pass_on_osaka() {
+        let blobs = vec!["Hello, world!".as_bytes(), "Goodbye, world!".as_bytes()]
+            .into_iter()
+            .map(|data| {
+                crate::types::blobs_bundle::blob_from_bytes(data.into())
+                    .expect("Failed to create blob")
+            })
+            .collect();
+
+        let blobs_bundle = crate::types::BlobsBundle::create_from_blobs(&blobs, Some(1))
+            .expect("Failed to create blobs bundle");
+
+        let blob_versioned_hashes = blobs_bundle.generate_versioned_hashes();
+
+        let tx = crate::types::transaction::EIP4844Transaction {
+            nonce: 3,
+            max_priority_fee_per_gas: 0,
+            max_fee_per_gas: 0,
+            max_fee_per_blob_gas: 0.into(),
+            gas: 15_000_000,
+            to: crate::Address::from_low_u64_be(1), // Normal tx
+            value: crate::U256::zero(),             // Value zero
+            data: crate::Bytes::default(),          // No data
+            access_list: Default::default(),        // No access list
+            blob_versioned_hashes,
+            ..Default::default()
+        };
+
+        assert!(matches!(
+            blobs_bundle.validate(&tx, crate::types::Fork::Osaka),
+            Ok(())
+        ));
+    }
+
+    #[test]
+    #[cfg(feature = "c-kzg")]
+    fn transaction_with_invalid_fork_should_fail() {
+        let blobs = vec!["Hello, world!".as_bytes(), "Goodbye, world!".as_bytes()]
+            .into_iter()
+            .map(|data| {
+                crate::types::blobs_bundle::blob_from_bytes(data.into())
+                    .expect("Failed to create blob")
+            })
+            .collect();
+
+        let blobs_bundle = crate::types::BlobsBundle::create_from_blobs(&blobs, Some(1))
+            .expect("Failed to create blobs bundle");
+
+        let blob_versioned_hashes = blobs_bundle.generate_versioned_hashes();
+
+        let tx = crate::types::transaction::EIP4844Transaction {
+            nonce: 3,
+            max_priority_fee_per_gas: 0,
+            max_fee_per_gas: 0,
+            max_fee_per_blob_gas: 0.into(),
+            gas: 15_000_000,
+            to: crate::Address::from_low_u64_be(1), // Normal tx
+            value: crate::U256::zero(),             // Value zero
+            data: crate::Bytes::default(),          // No data
+            access_list: Default::default(),        // No access list
+            blob_versioned_hashes,
+            ..Default::default()
+        };
+
+        assert!(!matches!(
+            blobs_bundle.validate(&tx, crate::types::Fork::Prague),
+            Ok(())
+        ));
+    }
+
     #[test]
     #[cfg(feature = "c-kzg")]
     fn transaction_with_invalid_proofs_should_fail() {
@@ -396,7 +487,7 @@ mod tests {
         let blobs =
             std::iter::repeat_n(blob, super::MAX_BLOB_COUNT_ELECTRA + 1).collect::<Vec<_>>();
 
-        let blobs_bundle = crate::types::BlobsBundle::create_from_blobs(&blobs)
+        let blobs_bundle = crate::types::BlobsBundle::create_from_blobs(&blobs, None)
             .expect("Failed to create blobs bundle");
 
         let blob_versioned_hashes = blobs_bundle.generate_versioned_hashes();

crates/common/types/transaction.rs

@@ -2167,6 +2167,7 @@ mod serde_impl {
         pub authorization_list: Option<Vec<AuthorizationTupleEntry>>,
         #[serde(default)]
         pub blob_versioned_hashes: Vec<H256>,
+        pub wrapper_version: Option<u8>,
         #[serde(default, with = "crate::serde_utils::bytes::vec")]
         pub blobs: Vec<Bytes>,
         #[serde(default, with = "crate::serde_utils::u64::hex_str_opt")]
@@ -2232,6 +2233,7 @@ mod serde_impl {
                 authorization_list: None,
                 blob_versioned_hashes: vec![],
                 blobs: vec![],
+                wrapper_version: None,
                 chain_id: Some(value.chain_id),
                 from: Address::default(),
             }
@@ -2286,6 +2288,7 @@ mod serde_impl {
                 authorization_list: None,
                 blob_versioned_hashes: value.blob_versioned_hashes,
                 blobs: vec![],
+                wrapper_version: None,
                 chain_id: Some(value.chain_id),
                 from: Address::default(),
             }
@@ -2308,10 +2311,11 @@ mod serde_impl {
                 })
                 .collect();
 
+            let wrapper_version = value.wrapper_version;
             Ok(Self {
                 tx: value.try_into()?,
-                wrapper_version: None,
-                blobs_bundle: BlobsBundle::create_from_blobs(&blobs)?,
+                wrapper_version,
+                blobs_bundle: BlobsBundle::create_from_blobs(&blobs, wrapper_version)?,
             })
         }
     }
@@ -2374,6 +2378,7 @@ mod serde_impl {
                 ),
                 blob_versioned_hashes: vec![],
                 blobs: vec![],
+                wrapper_version: None,
                 chain_id: Some(value.chain_id),
                 from: Address::default(),
             }
@@ -2401,6 +2406,7 @@ mod serde_impl {
                 authorization_list: None,
                 blob_versioned_hashes: vec![],
                 blobs: vec![],
+                wrapper_version: None,
                 chain_id: Some(value.chain_id),
                 from: value.from,
             }
@@ -2451,6 +2457,7 @@ mod serde_impl {
                 authorization_list: None,
                 blob_versioned_hashes: vec![],
                 blobs: vec![],
+                wrapper_version: None,
                 chain_id: None,
                 input: value.data,
             }
@@ -2481,6 +2488,7 @@ mod serde_impl {
                 authorization_list: None,
                 blob_versioned_hashes: vec![],
                 blobs: vec![],
+                wrapper_version: None,
                 chain_id: Some(value.chain_id),
                 input: value.data,
             }
@@ -2831,6 +2839,7 @@ mod tests {
             }],
             blob_versioned_hashes: Default::default(),
             blobs: Default::default(),
+            wrapper_version: None,
             chain_id: Default::default(),
             authorization_list: None,
         };
@@ -2884,6 +2893,7 @@ mod tests {
             }],
             blob_versioned_hashes: Default::default(),
             blobs: Default::default(),
+            wrapper_version: None,
             chain_id: Default::default(),
             authorization_list: None,
         };

crates/l2/Makefile

@@ -45,7 +45,10 @@ L1_AUTH_PORT=8551
 L1_RPC_ADDRESS=0.0.0.0
 L2_RPC_ADDRESS=0.0.0.0
 PROOF_COORDINATOR_ADDRESS?=127.0.0.1
-ETHREX_BLOCK_PRODUCER_OPERATOR_FEE_PER_GAS?=1000000000 \
+ETHREX_BLOCK_PRODUCER_OPERATOR_FEE_PER_GAS?=1000000000
+# Timestamp for Osaka activation in the hoodi. Sufficient to start network with Prague for tests.
+# Future: initialize network with Osaka activated once supported.
+ETHREX_OSAKA_ACTIVATION_TIME?=1761677592 
 
 # Matches the ports used by the blockchain/metrics dir
 L2_PROMETHEUS_METRICS_PORT = 3702
@@ -140,6 +143,7 @@ init-l2: ## 🚀 Initializes an L2 Lambda ethrex Client
 	--l1.bridge-address ${DEFAULT_BRIDGE_ADDRESS} \
 	--l1.on-chain-proposer-address ${DEFAULT_ON_CHAIN_PROPOSER_ADDRESS} \
 	--eth.rpc-url ${L1_RPC_URL} \
+	--osaka-activation-time ${ETHREX_OSAKA_ACTIVATION_TIME} \
 	--block-producer.coinbase-address 0x0007a881CD95B1484fca47615B64803dad620C8d \
 	--block-producer.base-fee-vault-address 0x000c0d6b7c4516a5b274c51ea331a9410fe69127 \
 	--block-producer.operator-fee-vault-address 0xd5d2a85751b6F158e5b9B8cD509206A865672362 \
@@ -151,7 +155,7 @@ init-l2: ## 🚀 Initializes an L2 Lambda ethrex Client
 init-l2-dev: ## 🚀 Initializes an L1 and L2 Lambda ethrex Client
 	COMPILE_CONTRACTS=true \
 	cargo run --release --features l2,l2-sql --manifest-path ../../Cargo.toml -- \
-	l2 --dev
+	l2 --dev --osaka-activation-time ${ETHREX_OSAKA_ACTIVATION_TIME}
 
 init-metrics: ## 🚀 Initializes Grafana and Prometheus with containers
 	L1_RPC_URL=${L1_RPC_URL} \