feat(levm): run hive tests with levm, generate and publish report

.github/scripts/publish_levm_hive.sh

@@ -0,0 +1,22 @@
+curl -X POST $url \
+-H 'Content-Type: application/json; charset=utf-8' \
+--data @- <<EOF
+$(jq -n --arg text "$(cat results.md)" '{
+    "blocks": [
+        {
+            "type": "header",
+            "text": {
+                "type": "plain_text",
+                "text": "LEVM Hive Coverage Report"
+            }
+        },
+        {
+            "type": "section",
+            "text": {
+                "type": "mrkdwn",
+                "text": $text
+            }             
+        }
+    ]
+}')
+EOF

.github/workflows/daily_reports_levm_hive.yaml

@@ -0,0 +1,92 @@
+name: Daily Reports Hive LEVM
+
+on:
+  schedule:
+    # Every day at UTC midnight
+    - cron: "0 0 * * 1,2,3,4,5"
+  workflow_dispatch:
+
+env:
+  RUST_VERSION: 1.81.0
+
+jobs:
+  run-hive:
+    name: Hive
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+
+      - name: Build Image with LEVM
+        run: cd crates/vm/levm && make build-image-levm
+
+      - name: Setup Hive
+        run: make setup-hive
+
+      - name: Run Hive RPC Simulation
+        run: cd hive && ./hive --sim ethereum/rpc-compat --client ethrex --sim.limit "*" --sim.parallelism 16
+        continue-on-error: true
+
+      - name: Run Hive Sync Simulation
+        run: cd hive && ./hive --sim ethereum/sync --client ethrex --sim.limit "*" --sim.parallelism 16
+        continue-on-error: true
+
+      - name: Run Hive Engine Simulation
+        run: cd hive && ./hive --sim ethereum/engine --client ethrex --sim.limit "*" --sim.parallelism 16
+        continue-on-error: true
+
+      - name: Run Hive P2P Simulation
+        run: cd hive && ./hive --sim devp2p --client ethrex --sim.limit "*" --sim.parallelism 16
+        continue-on-error: true
+
+      - name: Upload results
+        uses: actions/upload-artifact@v4
+        with:
+          name: testing_logs
+          path: hive/workspace/logs/*-*.json
+
+  hive-report:
+    name: Generate report and upload to summary and slack
+    needs: run-hive
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Rustup toolchain install
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.RUST_VERSION }}
+
+      - name: Download all results
+        uses: actions/download-artifact@v4
+        with:
+          path: hive/workspace/logs
+          pattern: "*_logs"
+          merge-multiple: true
+
+      - name: Caching
+        uses: Swatinem/rust-cache@v2
+
+      - name: Generate the hive report
+        run: cargo run -p hive_report > results.md
+
+      - name: Post results in summary
+        run: |
+          echo "# LEVM Hive coverage report" >> $GITHUB_STEP_SUMMARY
+          cat results.md >> $GITHUB_STEP_SUMMARY
+
+      - name: Post results to levm slack channel
+        env:
+          url: ${{ secrets.LEVM_SLACK_WEBHOOK }}
+        run: sh .github/scripts/publish_levm_hive.sh
+
+      # Note: Leave this commented, as it is for testing purposes.
+      # - name: Post results to test channel for debugging
+      #   env:
+      #     url: ${{ secrets.TEST_CHANNEL_SLACK }}
+      #   run: sh .github/scripts/publish_levm_hive.sh

.gitignore

@@ -48,6 +48,7 @@ levm_ef_tests_summary_slack.txt
 levm_ef_tests_summary_github.txt
 levm_ef_tests_summary.txt
 
+results.md
 loc_report.md
 loc_report_slack.txt
 loc_report_github.txt

Dockerfile

@@ -21,8 +21,10 @@ COPY --from=planner /ethrex/recipe.json recipe.json
 # Build dependencies only, these remained cached
 RUN cargo chef cook --release --recipe-path recipe.json
 
+# Optional build flags
+ARG BUILD_FLAGS=""
 COPY . .
-RUN cargo build --release
+RUN cargo build --release $BUILD_FLAGS
 
 FROM ubuntu:24.04
 WORKDIR /usr/local/bin

cmd/ethrex/ethrex.rs

@@ -356,7 +356,7 @@ fn import_blocks(store: &Store, blocks: &Vec<Block>) {
     }
     if let Some(last_block) = blocks.last() {
         let hash = last_block.hash();
-        apply_fork_choice(store, hash, hash, hash).unwrap();
+        let _ = apply_fork_choice(store, hash, hash, hash);
     }
     info!("Added {} blocks to blockchain", size);
 }

crates/blockchain/Cargo.toml

@@ -28,6 +28,7 @@ path = "./blockchain.rs"
 
 [features]
 default = ["c-kzg"]
+default-levm = ["default", "levm"]
 libmdbx = [
     "ethrex-core/libmdbx",
     "ethrex-storage/default",

crates/common/types/account.rs

@@ -37,7 +37,7 @@ pub struct Account {
     pub storage: HashMap<H256, U256>,
 }
 
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Eq)]
 pub struct AccountInfo {
     pub code_hash: H256,
     pub balance: U256,

crates/l2/Makefile

@@ -66,6 +66,17 @@ init-l1: ## 🚀 Initializes an L1 Lambda ethrex Client
 	--authrpc.port ${L1_AUTH_PORT} \
 	--datadir ${ethrex_L1_DEV_LIBMDBX}
 
+init-l1-levm: ## 🚀 Initializes an L1 Lambda ethrex Client with LEVM
+	cargo run --release \
+    --manifest-path ../../Cargo.toml \
+    --bin ethrex \
+    --features dev,ethrex-blockchain/default-levm,ethrex-vm/default-levm -- \
+    --network ${L1_GENESIS_FILE_PATH} \
+    --http.port ${L1_PORT} \
+    --http.addr 0.0.0.0 \
+    --authrpc.port ${L1_AUTH_PORT} \
+    --datadir ${ethrex_L1_DEV_LIBMDBX}
+
 down-local-l1: ## 🛑 Shuts down the L1 Lambda ethrex Client
 	docker compose -f ${ethrex_DEV_DOCKER_COMPOSE_PATH} down
 	docker compose -f docker-compose-l2.yaml down

crates/storage/store/storage.rs

@@ -44,7 +44,7 @@ pub enum EngineType {
     RedB,
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct AccountUpdate {
     pub address: Address,
     pub removed: bool,

crates/vm/Cargo.toml

@@ -39,6 +39,7 @@ path = "./vm.rs"
 
 [features]
 default = ["c-kzg", "blst"]
+default-levm = ["default", "levm"]
 l2 = []
 c-kzg = ["revm/c-kzg"]
 blst = ["revm/blst"]

crates/vm/levm/Makefile

@@ -76,3 +76,11 @@ build-revm-comparison:
 		--bin levm_factorial \
 		--bin revm_fibonacci \
 		--bin levm_fibonacci
+
+###### Build Client with LEVM ######
+
+FLAGS := "--features ethrex-blockchain/default-levm,ethrex-vm/default-levm"
+
+build-image-levm: ## 🐳 Build the Docker image with LEVM features
+	cd ../../../ && \
+	docker build -t ethrex --build-arg BUILD_FLAGS=$(FLAGS) .

crates/vm/vm.rs

@@ -88,6 +88,62 @@ cfg_if::cfg_if! {
         use std::{collections::HashMap, sync::Arc};
         use ethrex_core::types::code_hash;
 
+        pub fn get_state_transitions_levm(
+            initial_state: &EvmState,
+            block_hash: H256,
+            new_state: &CacheDB,
+        ) -> Vec<AccountUpdate> {
+            let current_db = match initial_state {
+                EvmState::Store(state) => state.database.store.clone(),
+                EvmState::Execution(_cache_db) => unreachable!("Execution state should not be passed here"),
+            };
+            let mut account_updates: Vec<AccountUpdate> = vec![];
+            for (new_state_account_address, new_state_account) in new_state {
+                // This stores things that have changed in the account.
+                let mut account_update = AccountUpdate::new(*new_state_account_address);
+
+                // Account state before block execution.
+                let initial_account_state = current_db
+                    .get_account_info_by_hash(block_hash, *new_state_account_address)
+                    .expect("Error getting account info by address")
+                    .unwrap_or_default();
+                // Account state after block execution.
+                let new_state_acc_info = AccountInfo {
+                    code_hash: code_hash(&new_state_account.info.bytecode),
+                    balance: new_state_account.info.balance,
+                    nonce: new_state_account.info.nonce,
+                };
+
+                // Compare Account Info
+                if initial_account_state != new_state_acc_info {
+                    account_update.info = Some(new_state_acc_info.clone());
+                }
+
+                // If code hash is different it means the code is different too.
+                if initial_account_state.code_hash != new_state_acc_info.code_hash {
+                    account_update.code = Some(new_state_account.info.bytecode.clone());
+                }
+
+                let mut updated_storage = HashMap::new();
+                for (key, storage_slot) in &new_state_account.storage {
+                    // original_value in storage_slot is not the original_value on the DB, be careful.
+                    let original_value = current_db.get_storage_at_hash(block_hash, *new_state_account_address, *key).unwrap().unwrap_or_default(); // Option inside result, I guess I have to assume it is zero.
+
+                    if original_value != storage_slot.current_value {
+                        updated_storage.insert(*key, storage_slot.current_value);
+                    }
+                }
+                account_update.added_storage = updated_storage;
+
+                account_update.removed = new_state_account.is_empty();
+
+                if account_update != AccountUpdate::new(*new_state_account_address) {
+                    account_updates.push(account_update);
+                }
+            }
+            account_updates
+        }
+
         /// Executes all transactions in a block and returns their receipts.
         pub fn execute_block(
             block: &Block,
@@ -103,56 +159,49 @@ cfg_if::cfg_if! {
                     }
                 }
             }
-            let mut receipts = Vec::new();
-            let mut cumulative_gas_used = 0;
 
             let store_wrapper = Arc::new(StoreWrapper {
                 store: state.database().unwrap().clone(),
                 block_hash: block.header.parent_hash,
             });
 
-            let mut account_updates: Vec<AccountUpdate> = vec![];
+            // Account updates are initialized like this because of the beacon_root_contract_call, it is going to be empty if it wasn't called.
+            let mut account_updates = get_state_transitions(state);
 
-            for transaction in block.body.transactions.iter() {
-                let result = execute_tx_levm(transaction, block_header, store_wrapper.clone()).unwrap();
-                cumulative_gas_used += result.gas_used;
-                let receipt = Receipt::new(
-                    transaction.tx_type(),
-                    matches!(result.result, TxResult::Success),
-                    cumulative_gas_used,
-                    result.logs,
-                );
-                receipts.push(receipt);
+            let mut receipts = Vec::new();
+            let mut cumulative_gas_used = 0;
+            let mut temporary_cache: CacheDB = HashMap::new();
 
-                for (address, account) in result.new_state {
-                    let mut added_storage = HashMap::new();
+            for tx in block.body.transactions.iter() {
+                let report = execute_tx_levm(tx, block_header, store_wrapper.clone(), temporary_cache.clone()).unwrap();
 
-                    for (key, value) in account.storage {
-                        added_storage.insert(key, value.current_value);
+                let mut new_state = report.new_state.clone();
+
+                // Now original_value is going to be the same as the current_value, for the next transaction.
+                // It should have only one value but it is convenient to keep on using our CacheDB structure
+                for account in new_state.values_mut() {
+                    for storage_slot in account.storage.values_mut() {
+                        storage_slot.original_value = storage_slot.current_value;
                     }
+                }
 
-                    let code = if account.info.bytecode.is_empty() {
-                        None
-                    } else {
-                        Some(account.info.bytecode.clone())
-                    };
+                temporary_cache.extend(new_state);
 
-                    let account_update = AccountUpdate {
-                        address,
-                        removed: false,
-                        info: Some(AccountInfo {
-                            code_hash: code_hash(&account.info.bytecode),
-                            balance: account.info.balance,
-                            nonce: account.info.nonce,
-                        }),
-                        code,
-                        added_storage,
-                    };
+                // Currently, in LEVM, we don't substract refunded gas to used gas, but that can change in the future.
+                let gas_used = report.gas_used - report.gas_refunded;
+                cumulative_gas_used += gas_used;
+                let receipt = Receipt::new(
+                    tx.tx_type(),
+                    matches!(report.result.clone(), TxResult::Success),
+                    cumulative_gas_used,
+                    report.logs.clone(),
+                );
 
-                    account_updates.push(account_update);
-                }
+                receipts.push(receipt);
             }
 
+            account_updates.extend(get_state_transitions_levm(state, block.header.parent_hash, &temporary_cache));
+
             if let Some(withdrawals) = &block.body.withdrawals {
                 process_withdrawals(state, withdrawals)?;
             }
@@ -164,6 +213,7 @@ cfg_if::cfg_if! {
             tx: &Transaction,
             block_header: &BlockHeader,
             db: Arc<dyn LevmDatabase>,
+            temporary_cache: CacheDB
         ) -> Result<TransactionReport, VMError> {
             let gas_price : U256 = tx.effective_gas_price(block_header.base_fee_per_gas).ok_or(VMError::InvalidTransaction)?.into();
 
@@ -194,7 +244,7 @@ cfg_if::cfg_if! {
                 tx.value(),
                 tx.data().clone(),
                 db,
-                CacheDB::default(),
+                temporary_cache,
                 tx.access_list(),
             )?;