feat(l2)!: shared bridge

.github/workflows/pr-main_l2.yaml

@@ -138,7 +138,7 @@ jobs:
           password: ${{ secrets.DOCKERHUB_TOKEN }}
           tags: ethrex:main-l2
           artifact_path: ethrex_image_l2.tar
-          build_args: BUILD_FLAGS=--features l2
+          build_args: BUILD_FLAGS=--features l2,l2-sql
 
       - name: Upload artifacts
         uses: actions/upload-artifact@v4

cmd/ethrex/build_l2.rs

@@ -100,6 +100,10 @@ pub fn download_script() {
             &Path::new("../../crates/l2/contracts/src/l1/CommonBridge.sol"),
             "CommonBridge",
         ),
+        (
+            &Path::new("../../crates/l2/contracts/src/l1/Router.sol"),
+            "Router",
+        ),
     ];
     for (path, name) in l1_contracts {
         compile_contract_to_bytecode(
@@ -170,6 +174,7 @@ fn write_empty_bytecode_files(output_contracts_path: &Path) {
         "SP1Verifier",
         "OnChainProposer",
         "CommonBridge",
+        "Router",
         "CommonBridgeL2",
         "L2ToL1Messenger",
         "UpgradeableSystemContract",

cmd/ethrex/l2/command.rs

@@ -8,15 +8,21 @@ use crate::{
     },
     utils::{self, default_datadir, init_datadir, parse_private_key},
 };
+use bytes::Bytes;
 use clap::{FromArgMatches, Parser, Subcommand};
-use ethrex_common::utils::keccak;
+use ethrex_blockchain::{
+    Blockchain, BlockchainOptions, BlockchainType, L2Config, fork_choice::apply_fork_choice,
+};
 use ethrex_common::{
-    Address, H256, U256,
-    types::{BYTES_PER_BLOB, BlobsBundle, BlockHeader, batch::Batch, bytes_from_blob},
+    Address, U256,
+    types::{BYTES_PER_BLOB, Block, blobs_bundle, bytes_from_blob, fee_config::FeeConfig},
 };
+use ethrex_common::{types::BlobsBundle, utils::keccak};
 use ethrex_config::networks::Network;
-use ethrex_l2_common::{calldata::Value, l1_messages::get_l1_message_hash, state_diff::StateDiff};
+use ethrex_l2::utils::state_reconstruct::get_batch;
+use ethrex_l2_common::calldata::Value;
 use ethrex_l2_sdk::call_contract;
+use ethrex_rlp::decode::RLPDecode as _;
 use ethrex_rpc::{
     EthClient, clients::beacon::BeaconClient, types::block_identifier::BlockIdentifier,
 };
@@ -138,8 +144,12 @@ pub enum Command {
         blobs_dir: PathBuf,
         #[arg(short = 's', long, help = "The path to the store.")]
         store_path: PathBuf,
-        #[arg(short = 'c', long, help = "Address of the L2 proposer coinbase")]
-        coinbase: Address,
+        #[arg(
+            short = 'o',
+            long,
+            help = "Whether Osaka fork is activated or not. If None, it assumes it is active."
+        )]
+        osaka_activated: Option<bool>,
     },
     #[command(about = "Reverts unverified batches.")]
     RevertBatch {
@@ -370,7 +380,7 @@ impl Command {
                 genesis,
                 blobs_dir,
                 store_path,
-                coinbase,
+                osaka_activated,
             } => {
                 #[cfg(feature = "rocksdb")]
                 let store_type = EngineType::RocksDB;
@@ -389,21 +399,13 @@ impl Command {
                 .await?;
 
                 let rollup_store =
-                    StoreRollup::new(&store_path.join("./rollup_store"), rollup_store_type)?;
+                    StoreRollup::new(&store_path.join("rollup_store"), rollup_store_type)?;
                 rollup_store
                     .init()
                     .await
                     .map_err(|e| format!("Failed to init rollup store: {e}"))
                     .unwrap();
 
-                // Get genesis
-                let genesis_header = store.get_block_header(0)?.expect("Genesis block not found");
-
-                let mut current_state_root = genesis_header.state_root;
-
-                let mut last_block_number = 0;
-                let mut new_canonical_blocks = vec![];
-
                 // Iterate over each blob
                 let files: Vec<std::fs::DirEntry> = read_dir(blobs_dir)?.try_collect()?;
                 for (file_number, file) in files
@@ -418,100 +420,116 @@ impl Command {
                         panic!("Invalid blob size");
                     }
 
-                    // Decode state diff from blob
                     let blob = bytes_from_blob(blob.into());
-                    let state_diff = StateDiff::decode(&blob)?;
 
-                    // Apply all account updates to trie
-                    let mut trie = store.open_direct_state_trie(current_state_root)?;
+                    // Decode blocks
+                    let blocks_count = u64::from_be_bytes(
+                        blob[0..8].try_into().expect("Failed to get blob length"),
+                    );
 
-                    let account_updates = state_diff.to_account_updates(&trie)?;
+                    let mut buf = &blob[8..];
+                    let mut blocks = Vec::new();
+                    for _ in 0..blocks_count {
+                        let (item, rest) = Block::decode_unfinished(buf)?;
+                        blocks.push(item);
+                        buf = rest;
+                    }
 
-                    let account_updates_list = store
-                        .apply_account_updates_from_trie_batch(&mut trie, account_updates.values())
-                        .map_err(|e| format!("Error applying account updates: {e}"))
-                        .unwrap();
+                    // Decode fee configs
+                    let mut fee_configs = Vec::new();
 
-                    store
-                        .open_direct_state_trie(current_state_root)?
-                        .db()
-                        .put_batch(account_updates_list.state_updates)?;
+                    for _ in 0..blocks_count {
+                        let (consumed, fee_config) = FeeConfig::decode(buf)?;
+                        fee_configs.push(fee_config);
+                        buf = &buf[consumed..];
+                    }
 
-                    current_state_root = account_updates_list.state_trie_hash;
+                    // Create blockchain to execute blocks
+                    let blockchain_type =
+                        ethrex_blockchain::BlockchainType::L2(L2Config::default());
+                    let opts = BlockchainOptions {
+                        r#type: blockchain_type,
+                        ..Default::default()
+                    };
+                    let blockchain = Blockchain::new(store.clone(), opts);
 
-                    store
-                        .write_storage_trie_nodes_batch(account_updates_list.storage_updates)
-                        .await?;
+                    for (i, block) in blocks.iter().enumerate() {
+                        // Update blockchain with the block's fee config
+                        let fee_config = fee_configs
+                            .get(i)
+                            .cloned()
+                            .ok_or_eyre("Fee config not found for block")?;
 
-                    store
-                        .write_account_code_batch(account_updates_list.code_updates)
-                        .await?;
+                        let BlockchainType::L2(l2_config) = &blockchain.options.r#type else {
+                            panic!("Invalid blockchain type. Expected L2.");
+                        };
 
-                    // Get withdrawal hashes
-                    let message_hashes = state_diff
-                        .l1_messages
-                        .iter()
-                        .map(get_l1_message_hash)
-                        .collect();
-
-                    // Get the first block of the batch
-                    let first_block_number = last_block_number + 1;
-
-                    // Build the header of the last block.
-                    // Note that its state_root is the root of new_trie.
-                    let new_block = BlockHeader {
-                        coinbase,
-                        state_root: account_updates_list.state_trie_hash,
-                        ..state_diff.last_header
-                    };
+                        {
+                            let Ok(mut fee_config_guard) = l2_config.fee_config.write() else {
+                                panic!("Fee config lock was poisoned.");
+                            };
 
-                    // Store last block.
-                    let new_block_hash = new_block.hash();
-                    store
-                        .add_block_header(new_block_hash, new_block.clone())
-                        .await?;
-                    store
-                        .add_block_number(new_block_hash, state_diff.last_header.number)
-                        .await?;
-                    new_canonical_blocks.push((state_diff.last_header.number, new_block_hash));
-                    println!(
-                        "Stored last block of blob. Block {}. State root {}",
-                        new_block.number, new_block.state_root
-                    );
+                            *fee_config_guard = fee_config;
+                        }
+
+                        // Execute block
+                        blockchain.add_block(block.clone())?;
+
+                        // Add fee config to rollup store
+                        rollup_store
+                            .store_fee_config_by_block(block.header.number, fee_config)
+                            .await?;
+
+                        info!(
+                            "Added block {} with hash {:#x}",
+                            block.header.number,
+                            block.hash(),
+                        );
+                    }
+                    // Apply fork choice
+                    let latest_hash_on_batch = blocks.last().ok_or_eyre("Batch is empty")?.hash();
+                    apply_fork_choice(
+                        &store,
+                        latest_hash_on_batch,
+                        latest_hash_on_batch,
+                        latest_hash_on_batch,
+                    )
+                    .await?;
+
+                    // Prepare batch sealing
+                    let blob = blobs_bundle::blob_from_bytes(Bytes::copy_from_slice(&blob))
+                        .expect("Failed to create blob from bytes; blob was just read from file");
 
-                    last_block_number = new_block.number;
-
-                    let batch = Batch {
-                        number: batch_number,
-                        first_block: first_block_number,
-                        last_block: new_block.number,
-                        state_root: new_block.state_root,
-                        privileged_transactions_hash: H256::zero(),
-                        message_hashes,
-                        blobs_bundle: BlobsBundle::empty(),
-                        commit_tx: None,
-                        verify_tx: None,
+                    let wrapper_version = if let Some(activated) = osaka_activated
+                        && !activated
+                    {
+                        None
+                    } else {
+                        Some(1)
                     };
 
-                    // Store batch info in L2 storage
-                    rollup_store
-                        .seal_batch(batch)
-                        .await
-                        .map_err(|e| format!("Error storing batch: {e}"))
-                        .unwrap();
-                }
-                let Some((last_number, last_hash)) = new_canonical_blocks.pop() else {
-                    return Err(eyre::eyre!("No blocks found in blobs directory"));
-                };
-                store
-                    .forkchoice_update(
-                        Some(new_canonical_blocks),
-                        last_number,
-                        last_hash,
-                        None,
+                    let blobs_bundle =
+                        BlobsBundle::create_from_blobs(&vec![blob], wrapper_version)?;
+
+                    let batch = get_batch(
+                        &store,
+                        &blocks,
+                        U256::from(batch_number),
                         None,
+                        blobs_bundle,
                     )
                     .await?;
+
+                    // Seal batch
+                    rollup_store.seal_batch(batch).await?;
+
+                    // Create checkpoint
+                    let checkpoint_path =
+                        store_path.join(format!("checkpoint_batch_{batch_number}"));
+                    store.create_checkpoint(&checkpoint_path).await?;
+
+                    info!("Sealed batch {batch_number}.");
+                }
             }
             Command::RevertBatch {
                 batch,