feat(l2): add validium mode

crates/l2/configs/sequencer_config_example.toml

@@ -41,6 +41,8 @@ l1_private_key = "0x385c546456b6a603a1cfcaa9ec9494ba4832da08dd6bcf4de9a71e4a01b7
 interval_ms = 5000
 # 1 Gwei
 arbitrary_base_blob_gas_price = 1000000000
+# If set to true, initializes the committer in validium mode
+validium = false
 
 [prover_server]
 # set it to 0.0.0.0 to allow connections from other machines

crates/l2/contracts/deployer.rs

@@ -350,13 +350,14 @@ async fn deploy_contracts(
         Color::Cyan,
     );
 
-    let (on_chain_proposer_deployment_tx_hash, on_chain_proposer_address) = deploy_contract(
-        deployer,
-        deployer_private_key,
-        eth_client,
-        &contracts_path.join("solc_out/OnChainProposer.bin"),
-    )
-    .await?;
+    let (on_chain_proposer_deployment_tx_hash, on_chain_proposer_address) =
+        deploy_on_chain_proposer(
+            deployer,
+            deployer_private_key,
+            eth_client,
+            &contracts_path.join("solc_out/OnChainProposer.bin"),
+        )
+        .await?;
 
     let msg = format!(
         "OnChainProposer:\n\tDeployed at address {}\n\tWith tx hash {}",
@@ -438,12 +439,10 @@ async fn deploy_contract(
     contract_path: &Path,
 ) -> Result<(H256, Address), DeployError> {
     let init_code = hex::decode(std::fs::read_to_string(contract_path).map_err(|err| {
-        DeployError::DecodingError(format!("Failed to read on_chain_proposer_init_code: {err}"))
+        DeployError::DecodingError(format!("Failed to read contract init code: {err}"))
     })?)
     .map_err(|err| {
-        DeployError::DecodingError(format!(
-            "Failed to decode on_chain_proposer_init_code: {err}"
-        ))
+        DeployError::DecodingError(format!("Failed to decode contract init code: {err}"))
     })?
     .into();
 
@@ -455,6 +454,44 @@ async fn deploy_contract(
     Ok((deploy_tx_hash, contract_address))
 }
 
+async fn deploy_on_chain_proposer(
+    deployer: Address,
+    deployer_private_key: SecretKey,
+    eth_client: &EthClient,
+    contract_path: &Path,
+) -> Result<(H256, Address), DeployError> {
+    let mut init_code = hex::decode(std::fs::read_to_string(contract_path).map_err(|err| {
+        DeployError::DecodingError(format!("Failed to read on_chain_proposer_init_code: {err}"))
+    })?)
+    .map_err(|err| {
+        DeployError::DecodingError(format!(
+            "Failed to decode on_chain_proposer_init_code: {err}"
+        ))
+    })?;
+
+    let validium: bool = read_env_var("COMMITTER_VALIDIUM")?
+        .trim()
+        .parse()
+        .map_err(|err| DeployError::ParseError(format!("Malformed COMMITTER_VALIDIUM: {err}")))?;
+
+    let validium_value = if validium { 1u8 } else { 0u8 };
+    let encoded_validium = vec![0; 31]
+        .into_iter()
+        .chain(std::iter::once(validium_value));
+    init_code.extend(encoded_validium);
+
+    let (deploy_tx_hash, contract_address) = create2_deploy(
+        deployer,
+        deployer_private_key,
+        &init_code.into(),
+        eth_client,
+    )
+    .await
+    .map_err(DeployError::from)?;
+
+    Ok((deploy_tx_hash, contract_address))
+}
+
 async fn deploy_bridge(
     deployer: Address,
     deployer_private_key: SecretKey,

crates/l2/contracts/src/l1/OnChainProposer.sol

@@ -53,6 +53,16 @@ contract OnChainProposer is IOnChainProposer, ReentrancyGuard {
     /// @dev Used only in dev mode.
     address public constant DEV_MODE = address(0xAA);
 
+    /// @notice Indicates whether the contract operates in validium mode.
+    /// @dev This value is immutable and can only be set during contract deployment.
+    bool public immutable VALIDIUM;
+
+    /// @notice Constructor to initialize the immutable validium value.
+    /// @param _validium A boolean indicating if the contract operates in validium mode.
+    constructor(bool _validium) {
+        VALIDIUM = _validium;
+    }
+
     modifier onlySequencer() {
         require(
             authorizedSequencerAddresses[msg.sender],
@@ -145,10 +155,12 @@ contract OnChainProposer is IOnChainProposer, ReentrancyGuard {
             blockNumber == lastCommittedBlock + 1,
             "OnChainProposer: blockNumber is not the immediate successor of lastCommittedBlock"
         );
-        require(
-            blockCommitments[blockNumber].commitmentHash == bytes32(0),
-            "OnChainProposer: block already committed"
-        );
+        if (!VALIDIUM) {
+            require(
+                blockCommitments[blockNumber].commitmentHash == bytes32(0),
+                "OnChainProposer: block already committed"
+            );
+        }
         // Check if commitment is equivalent to blob's KZG commitment.
 
         if (depositLogs != bytes32(0)) {
@@ -165,12 +177,15 @@ contract OnChainProposer is IOnChainProposer, ReentrancyGuard {
                 withdrawalsLogsMerkleRoot
             );
         }
-        blockCommitments[blockNumber] = BlockCommitmentInfo(
+        if (!VALIDIUM) {
+            blockCommitments[blockNumber] = BlockCommitmentInfo(
             commitment,
             depositLogs
-        );
+            );
+            emit BlockCommitted(commitment);
+        }
+
         lastCommittedBlock = blockNumber;
-        emit BlockCommitted(commitment);
     }
 
     /// @inheritdoc IOnChainProposer
@@ -201,10 +216,12 @@ contract OnChainProposer is IOnChainProposer, ReentrancyGuard {
             "OnChainProposer: block already verified"
         );
 
-        require(
-            blockCommitments[blockNumber].commitmentHash != bytes32(0),
-            "OnChainProposer: block not committed"
-        );
+        if (!VALIDIUM) {
+            require(
+                blockCommitments[blockNumber].commitmentHash != bytes32(0),
+                "OnChainProposer: block not committed"
+            );
+        }
 
         if (PICOVERIFIER != DEV_MODE) {
             // If the verification fails, it will revert.
@@ -234,16 +251,18 @@ contract OnChainProposer is IOnChainProposer, ReentrancyGuard {
         }
 
         lastVerifiedBlock = blockNumber;
-        // The first 2 bytes are the number of deposits.
-        uint16 deposits_amount = uint16(
-            bytes2(blockCommitments[blockNumber].depositLogs)
-        );
-        if (deposits_amount > 0) {
-            ICommonBridge(BRIDGE).removeDepositLogs(deposits_amount);
-        }
 
-        // Remove previous block commitment as it is no longer needed.
-        delete blockCommitments[blockNumber - 1];
+        if (!VALIDIUM) {
+            // The first 2 bytes are the number of deposits.
+            uint16 deposits_amount = uint16(
+                bytes2(blockCommitments[blockNumber].depositLogs)
+            );
+            if (deposits_amount > 0) {
+                ICommonBridge(BRIDGE).removeDepositLogs(deposits_amount);
+            }
+            // Remove previous block commitment as it is no longer needed.
+            delete blockCommitments[blockNumber - 1];
+        }
 
         emit BlockVerified(blockNumber);
     }

crates/l2/sequencer/l1_committer.rs

@@ -6,6 +6,7 @@ use crate::{
     utils::config::{committer::CommitterConfig, errors::ConfigError, eth::EthConfig},
 };
 
+use bytes::Bytes;
 use ethrex_common::{
     types::{
         blobs_bundle, fake_exponential_checked, BlobsBundle, BlobsBundleError, Block,
@@ -39,6 +40,7 @@ pub struct Committer {
     interval_ms: u64,
     arbitrary_base_blob_gas_price: u64,
     execution_cache: Arc<ExecutionCache>,
+    validium: bool,
 }
 
 pub async fn start_l1_committer(
@@ -70,6 +72,7 @@ impl Committer {
             interval_ms: committer_config.interval_ms,
             arbitrary_base_blob_gas_price: committer_config.arbitrary_base_blob_gas_price,
             execution_cache,
+            validium: committer_config.validium,
         }
     }
 
@@ -159,7 +162,11 @@ impl Committer {
             &account_updates,
         )?;
 
-        let blobs_bundle = self.generate_blobs_bundle(&state_diff)?;
+        let blobs_bundle = if !self.validium {
+            self.generate_blobs_bundle(&state_diff)?
+        } else {
+            BlobsBundle::default()
+        };
 
         let head_block_hash = block_to_commit.hash();
         match self
@@ -356,33 +363,28 @@ impl Committer {
     ) -> Result<H256, CommitterError> {
         info!("Sending commitment for block {block_number}");
 
-        let blob_versioned_hashes = blobs_bundle.generate_versioned_hashes();
+        let commitment_bytes: Bytes = if !self.validium {
+            let blob_versioned_hashes = blobs_bundle.generate_versioned_hashes();
+            blob_versioned_hashes
+                .first()
+                .ok_or(BlobsBundleError::BlobBundleEmptyError)
+                .map_err(CommitterError::from)?
+                .as_fixed_bytes()
+                .to_vec()
+                .into()
+        } else {
+            Bytes::from(vec![0; 32]) // Validium doesn't need to send commitment.
+        };
+
         let calldata_values = vec![
             Value::Uint(U256::from(block_number)),
-            Value::FixedBytes(
-                blob_versioned_hashes
-                    .first()
-                    .ok_or(BlobsBundleError::BlobBundleEmptyError)
-                    .map_err(CommitterError::from)?
-                    .as_fixed_bytes()
-                    .to_vec()
-                    .into(),
-            ),
+            Value::FixedBytes(commitment_bytes),
             Value::FixedBytes(withdrawal_logs_merkle_root.0.to_vec().into()),
             Value::FixedBytes(deposit_logs_hash.0.to_vec().into()),
         ];
 
         let calldata = encode_calldata(COMMIT_FUNCTION_SIGNATURE, &calldata_values)?;
 
-        let le_bytes = estimate_blob_gas(
-            &self.eth_client,
-            self.arbitrary_base_blob_gas_price,
-            20, // 20% of headroom
-        )
-        .await?
-        .to_le_bytes();
-
-        let gas_price_per_blob = U256::from_little_endian(&le_bytes);
         let gas_price = self
             .eth_client
             .get_gas_price_with_extra(20)
@@ -392,25 +394,58 @@ impl Committer {
                 CommitterError::InternalError("Failed to convert gas_price to a u64".to_owned())
             })?;
 
-        let wrapped_tx = self
-            .eth_client
-            .build_eip4844_transaction(
-                self.on_chain_proposer_address,
-                self.l1_address,
-                calldata.into(),
-                Overrides {
-                    from: Some(self.l1_address),
-                    gas_price_per_blob: Some(gas_price_per_blob),
-                    max_fee_per_gas: Some(gas_price),
-                    max_priority_fee_per_gas: Some(gas_price),
-                    ..Default::default()
-                },
-                blobs_bundle,
+        // Validium: EIP1559 Transaction.
+        // Rollup: EIP4844 Transaction -> For on-chain Data Availability.
+        let mut tx = if !self.validium {
+            let le_bytes = estimate_blob_gas(
+                &self.eth_client,
+                self.arbitrary_base_blob_gas_price,
+                20, // 20% of headroom
             )
-            .await
-            .map_err(CommitterError::from)?;
+            .await?
+            .to_le_bytes();
+
+            let gas_price_per_blob = U256::from_little_endian(&le_bytes);
+
+            let wrapped_tx = self
+                .eth_client
+                .build_eip4844_transaction(
+                    self.on_chain_proposer_address,
+                    self.l1_address,
+                    calldata.into(),
+                    Overrides {
+                        from: Some(self.l1_address),
+                        gas_price_per_blob: Some(gas_price_per_blob),
+                        max_fee_per_gas: Some(gas_price),
+                        max_priority_fee_per_gas: Some(gas_price),
+                        ..Default::default()
+                    },
+                    blobs_bundle,
+                )
+                .await
+                .map_err(CommitterError::from)?;
+
+            WrappedTransaction::EIP4844(wrapped_tx)
+        } else {
+            let wrapped_tx = self
+                .eth_client
+                .build_eip1559_transaction(
+                    self.on_chain_proposer_address,
+                    self.l1_address,
+                    calldata.into(),
+                    Overrides {
+                        from: Some(self.l1_address),
+                        max_fee_per_gas: Some(gas_price),
+                        max_priority_fee_per_gas: Some(gas_price),
+                        ..Default::default()
+                    },
+                )
+                .await
+                .map_err(CommitterError::from)?;
+
+            WrappedTransaction::EIP1559(wrapped_tx)
+        };
 
-        let mut tx = WrappedTransaction::EIP4844(wrapped_tx);
         self.eth_client
             .set_gas_for_wrapped_tx(&mut tx, self.l1_address)
             .await?;

crates/l2/utils/config/committer.rs

@@ -13,6 +13,7 @@ pub struct CommitterConfig {
     pub l1_private_key: SecretKey,
     pub interval_ms: u64,
     pub arbitrary_base_blob_gas_price: u64,
+    pub validium: bool,
 }
 
 impl CommitterConfig {

crates/l2/utils/config/toml_parser.rs

@@ -131,6 +131,7 @@ struct Committer {
     l1_private_key: String,
     interval_ms: u64,
     arbitrary_base_blob_gas_price: u64,
+    validium: bool,
 }
 
 impl Committer {
@@ -143,12 +144,14 @@ impl Committer {
 {prefix}_L1_PRIVATE_KEY={}
 {prefix}_INTERVAL_MS={}
 {prefix}_ARBITRARY_BASE_BLOB_GAS_PRICE={}
+{prefix}_VALIDIUM={}
 ",
             self.on_chain_proposer_address,
             self.l1_address,
             self.l1_private_key,
             self.interval_ms,
             self.arbitrary_base_blob_gas_price,
+            self.validium,
         )
     }
 }