perf(levm): remove Result<OpcodeResult, VMError> to avoid expensive matches

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Perf
 
+### 2026-02-27
+
+- Refactor LEVM opcode handlers to avoid expensive matches [#4791](https://github.com/lambdaclass/ethrex/pull/4791)
+
 ### 2026-02-25
 
 - Speed up snap sync validation with parallelism and deduplication [#6191](https://github.com/lambdaclass/ethrex/pull/6191)

crates/blockchain/mempool.rs

@@ -12,7 +12,7 @@ use crate::{
     error::MempoolError,
 };
 use ethrex_common::{
-    Address, H160, H256, U256,
+    Address, H160, H256,
     types::{BlobsBundle, BlockHeader, ChainConfig, MempoolTransaction, Transaction, TxType},
 };
 use ethrex_storage::error::StoreError;
@@ -217,7 +217,9 @@ impl Mempool {
             // Filter by blob gas fee
             if is_blob_tx
                 && let Some(blob_fee) = filter.blob_fee
-                && tx.max_fee_per_blob_gas().is_none_or(|fee| fee < blob_fee)
+                && tx
+                    .max_fee_per_blob_gas()
+                    .is_none_or(|fee| fee < blob_fee.into())
             {
                 return false;
             }
@@ -420,7 +422,7 @@ impl Mempool {
 pub struct PendingTxFilter {
     pub min_tip: Option<u64>,
     pub base_fee: Option<u64>,
-    pub blob_fee: Option<U256>,
+    pub blob_fee: Option<u64>,
     pub only_plain_txs: bool,
     pub only_blob_txs: bool,
 }

crates/blockchain/payload.rs

@@ -490,10 +490,13 @@ impl Blockchain {
         &self,
         context: &mut PayloadBuildContext,
     ) -> Result<(TransactionQueue, TransactionQueue), ChainError> {
+        let blob_fee: u64 = context.base_fee_per_blob_gas.try_into().map_err(|_| {
+            ChainError::Custom("base_fee_per_blob_gas does not fit in u64".to_owned())
+        })?;
         let tx_filter = PendingTxFilter {
             /*TODO(https://github.com/lambdaclass/ethrex/issues/680): add tip filter */
             base_fee: context.base_fee_per_gas(),
-            blob_fee: Some(context.base_fee_per_blob_gas),
+            blob_fee: Some(blob_fee),
             ..Default::default()
         };
         let plain_tx_filter = PendingTxFilter {

crates/common/types/block.rs

@@ -1072,7 +1072,7 @@ mod test {
     #[test]
     fn test_fake_exponential_overflow() {
         // With u64 this overflows
-        assert!(fake_exponential(U256::from(57532635), U256::from(3145728), 3338477).is_ok());
+        assert!(fake_exponential(57532635.into(), 3145728.into(), 3338477).is_ok());
     }
 
     #[test]

crates/l2/sequencer/l1_committer.rs

@@ -1597,20 +1597,23 @@ async fn estimate_blob_gas(
     // If the blob's market is in high demand, the equation may give a really big number.
     // This function doesn't panic, it performs checked/saturating operations.
     let blob_gas = fake_exponential(
-        U256::from(MIN_BASE_FEE_PER_BLOB_GAS),
-        U256::from(total_blob_gas),
+        MIN_BASE_FEE_PER_BLOB_GAS.into(),
+        total_blob_gas.into(),
         BLOB_BASE_FEE_UPDATE_FRACTION,
     )
     .map_err(BlobEstimationError::FakeExponentialError)?;
 
     let gas_with_headroom = (blob_gas * (100 + headroom)) / 100;
 
     // Check if we have an overflow when we take the headroom into account.
-    let blob_gas = U256::from(arbitrary_base_blob_gas_price)
-        .checked_add(gas_with_headroom)
+    let gas_with_headroom_u64: u64 = gas_with_headroom
+        .try_into()
+        .map_err(|_| BlobEstimationError::OverflowError)?;
+    let blob_gas = arbitrary_base_blob_gas_price
+        .checked_add(gas_with_headroom_u64)
         .ok_or(BlobEstimationError::OverflowError)?;
 
-    Ok(blob_gas)
+    Ok(blob_gas.into())
 }
 
 /// Regenerates state by re-applying blocks from the last known state root.

crates/networking/rpc/eth/block.rs

@@ -344,6 +344,9 @@ pub async fn get_all_block_rpc_receipts(
             .unwrap_or_default(),
     );
     let base_fee_per_gas = header.base_fee_per_gas;
+    let blob_base_fee_u64: u64 = blob_base_fee
+        .try_into()
+        .map_err(|_| RpcErr::Internal("blob_base_fee does not fit in u64".to_owned()))?;
     // Fetch receipt info from block
     let block_info = RpcReceiptBlockInfo::from_block_header(header);
     // Fetch receipt for each tx in the block and add block and tx info
@@ -360,7 +363,7 @@ pub async fn get_all_block_rpc_receipts(
             tx.clone(),
             index,
             gas_used,
-            blob_base_fee,
+            blob_base_fee_u64,
             base_fee_per_gas,
         )?;
         let receipt = RpcReceipt::new(

crates/networking/rpc/eth/fee_market.rs

@@ -1,6 +1,5 @@
 use ethrex_blockchain::payload::calc_gas_limit;
 use ethrex_common::{
-    U256,
     constants::GAS_PER_BLOB,
     types::{
         Block, BlockHeader, ELASTICITY_MULTIPLIER, Fork, ForkBlobSchedule, Transaction,
@@ -103,7 +102,7 @@ impl RpcHandler for FeeHistoryRequest {
         let oldest_block = start_block;
         let block_count = (end_block - start_block + 1) as usize;
         let mut base_fee_per_gas = vec![0_u64; block_count + 1];
-        let mut base_fee_per_blob_gas = vec![U256::zero(); block_count + 1];
+        let mut base_fee_per_blob_gas = vec![0_u64; block_count + 1];
         let mut gas_used_ratio = vec![0_f64; block_count];
         let mut blob_gas_used_ratio = vec![0_f64; block_count];
         let mut reward = Vec::<Vec<u64>>::with_capacity(block_count);
@@ -144,7 +143,9 @@ impl RpcHandler for FeeHistoryRequest {
             );
 
             base_fee_per_gas[idx] = header.base_fee_per_gas.unwrap_or_default();
-            base_fee_per_blob_gas[idx] = blob_base_fee;
+            base_fee_per_blob_gas[idx] = blob_base_fee
+                .try_into()
+                .map_err(|_| RpcErr::Internal("blob_base_fee does not fit in u64".to_owned()))?;
             gas_used_ratio[idx] = header.gas_used as f64 / header.gas_limit as f64;
             blob_gas_used_ratio[idx] = blob_gas_used_r;
 
@@ -155,7 +156,7 @@ impl RpcHandler for FeeHistoryRequest {
                         blob_schedule,
                         fork,
                         context.gas_ceil,
-                    );
+                    )?;
             }
             if !self.reward_percentiles.is_empty() {
                 reward.push(calculate_percentiles_for_block(
@@ -166,13 +167,12 @@ impl RpcHandler for FeeHistoryRequest {
         }
 
         let u64_to_hex_str = |x: u64| format!("0x{x:x}");
-        let u256_to_hex_str = |x: U256| format!("0x{x:x}");
         let response = FeeHistoryResponse {
             oldest_block: u64_to_hex_str(oldest_block),
             base_fee_per_gas: base_fee_per_gas.into_iter().map(u64_to_hex_str).collect(),
             base_fee_per_blob_gas: base_fee_per_blob_gas
                 .into_iter()
-                .map(u256_to_hex_str)
+                .map(u64_to_hex_str)
                 .collect(),
             gas_used_ratio,
             blob_gas_used_ratio,
@@ -191,7 +191,7 @@ fn project_next_block_base_fee_values(
     schedule: ForkBlobSchedule,
     fork: Fork,
     gas_ceil: u64,
-) -> (u64, U256) {
+) -> Result<(u64, u64), RpcErr> {
     // NOTE: Given that this client supports the Paris fork and later versions, we are sure that the next block
     // will have the London update active, so the base fee calculation makes sense
     // Geth performs a validation for this case:
@@ -208,7 +208,10 @@ fn project_next_block_base_fee_values(
     let next_excess_blob_gas = calc_excess_blob_gas(header, schedule, fork);
     let base_fee_per_blob =
         calculate_base_fee_per_blob_gas(next_excess_blob_gas, schedule.base_fee_update_fraction);
-    (base_fee_per_gas, base_fee_per_blob)
+    let base_fee_per_blob_u64: u64 = base_fee_per_blob
+        .try_into()
+        .map_err(|_| RpcErr::Internal("base_fee_per_blob does not fit in u64".to_owned()))?;
+    Ok((base_fee_per_gas, base_fee_per_blob_u64))
 }
 
 async fn get_range(

crates/networking/rpc/types/receipt.rs

@@ -1,5 +1,5 @@
 use ethrex_common::{
-    Address, Bloom, Bytes, H256, U256,
+    Address, Bloom, Bytes, H256,
     constants::GAS_PER_BLOB,
     evm::calculate_create_address,
     serde_utils,
@@ -154,10 +154,10 @@ pub struct RpcReceiptTxInfo {
     pub effective_gas_price: u64,
     #[serde(
         skip_serializing_if = "Option::is_none",
-        with = "serde_utils::u256::hex_str_opt",
+        with = "serde_utils::u64::hex_str_opt",
         default = "Option::default"
     )]
-    pub blob_gas_price: Option<U256>,
+    pub blob_gas_price: Option<u64>,
     #[serde(
         skip_serializing_if = "Option::is_none",
         with = "serde_utils::u64::hex_str_opt",
@@ -171,7 +171,7 @@ impl RpcReceiptTxInfo {
         transaction: Transaction,
         index: u64,
         gas_used: u64,
-        block_blob_gas_price: U256,
+        block_blob_gas_price: u64,
         base_fee_per_gas: Option<u64>,
     ) -> Result<Self, RpcErr> {
         let nonce = transaction.nonce();

crates/vm/backends/levm/mod.rs

@@ -456,15 +456,15 @@ impl LEVM {
             &vm_type,
         )?;
 
-        let block_excess_blob_gas = block_header.excess_blob_gas.map(U256::from);
+        let block_excess_blob_gas = block_header.excess_blob_gas;
         let config = EVMConfig::new_from_chain_config(&chain_config, block_header);
         let env = Environment {
             origin: tx_sender,
             gas_limit: tx.gas_limit(),
             config,
-            block_number: block_header.number.into(),
+            block_number: block_header.number,
             coinbase: block_header.coinbase,
-            timestamp: block_header.timestamp.into(),
+            timestamp: block_header.timestamp,
             prev_randao: Some(block_header.prev_randao),
             slot_number: block_header
                 .slot_number
@@ -475,7 +475,7 @@ impl LEVM {
             base_blob_fee_per_gas: get_base_fee_per_blob_gas(block_excess_blob_gas, &config)?,
             gas_price,
             block_excess_blob_gas,
-            block_blob_gas_used: block_header.blob_gas_used.map(U256::from),
+            block_blob_gas_used: block_header.blob_gas_used,
             tx_blob_hashes: tx.blob_versioned_hashes(),
             tx_max_priority_fee_per_gas: tx.max_priority_fee().map(U256::from),
             tx_max_fee_per_gas: tx.max_fee_per_gas().map(U256::from),
@@ -776,14 +776,14 @@ pub fn generic_system_contract_levm(
         // EIPs 2935, 4788, 7002 and 7251 dictate that the system calls have a gas limit of 30 million and they do not use intrinsic gas.
         // So we add the base cost that will be taken in the execution.
         gas_limit: SYS_CALL_GAS_LIMIT + TX_BASE_COST,
-        block_number: block_header.number.into(),
+        block_number: block_header.number,
         coinbase: block_header.coinbase,
-        timestamp: block_header.timestamp.into(),
+        timestamp: block_header.timestamp,
         prev_randao: Some(block_header.prev_randao),
         base_fee_per_gas: U256::zero(),
         gas_price: U256::zero(),
-        block_excess_blob_gas: block_header.excess_blob_gas.map(U256::from),
-        block_blob_gas_used: block_header.blob_gas_used.map(U256::from),
+        block_excess_blob_gas: block_header.excess_blob_gas,
+        block_blob_gas_used: block_header.blob_gas_used,
         block_gas_limit: i64::MAX as u64, // System calls, have no constraint on the block's gas limit.
         config,
         ..Default::default()
@@ -965,7 +965,7 @@ fn env_from_generic(
     let chain_config = db.store.get_chain_config()?;
     let gas_price =
         calculate_gas_price_for_generic(tx, header.base_fee_per_gas.unwrap_or(INITIAL_BASE_FEE));
-    let block_excess_blob_gas = header.excess_blob_gas.map(U256::from);
+    let block_excess_blob_gas = header.excess_blob_gas;
     let config = EVMConfig::new_from_chain_config(&chain_config, header);
 
     // Validate slot_number for Amsterdam+ blocks
@@ -991,17 +991,17 @@ fn env_from_generic(
             .gas
             .unwrap_or(get_max_allowed_gas_limit(header.gas_limit, config.fork)), // Ensure tx doesn't fail due to gas limit
         config,
-        block_number: header.number.into(),
+        block_number: header.number,
         coinbase: header.coinbase,
-        timestamp: header.timestamp.into(),
+        timestamp: header.timestamp,
         prev_randao: Some(header.prev_randao),
         slot_number,
         chain_id: chain_config.chain_id.into(),
         base_fee_per_gas: header.base_fee_per_gas.unwrap_or_default().into(),
         base_blob_fee_per_gas: get_base_fee_per_blob_gas(block_excess_blob_gas, &config)?,
         gas_price,
         block_excess_blob_gas,
-        block_blob_gas_used: header.blob_gas_used.map(U256::from),
+        block_blob_gas_used: header.blob_gas_used,
         tx_blob_hashes: tx.blob_versioned_hashes.clone(),
         tx_max_priority_fee_per_gas: tx.max_priority_fee_per_gas.map(U256::from),
         tx_max_fee_per_gas: tx.max_fee_per_gas.map(U256::from),

crates/vm/levm/src/call_frame.rs

@@ -8,9 +8,13 @@ use crate::{
 };
 use bytes::Bytes;
 use ethrex_common::types::block_access_list::BlockAccessListCheckpoint;
-use ethrex_common::{Address, U256};
-use ethrex_common::{H256, types::Code};
-use std::{collections::HashMap, fmt, hint::assert_unchecked};
+use ethrex_common::{Address, H256, U256, types::Code};
+use std::{
+    collections::HashMap,
+    fmt,
+    hash::{Hash, Hasher},
+    hint::assert_unchecked,
+};
 
 /// [`u64`]s that make up a [`U256`]
 const U64_PER_U256: usize = U256::MAX.0.len();
@@ -219,6 +223,16 @@ impl fmt::Debug for Stack {
     }
 }
 
+impl Hash for Stack {
+    #[expect(
+        clippy::indexing_slicing,
+        reason = "offset is always within bounds of values"
+    )]
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.values[self.offset..].hash(state);
+    }
+}
+
 #[derive(Debug)]
 /// A call frame, or execution environment, is the context in which
 /// the EVM is currently executing.
@@ -314,7 +328,10 @@ impl CallFrameBackup {
 }
 
 impl CallFrame {
-    #[allow(clippy::too_many_arguments)]
+    #[expect(
+        clippy::too_many_arguments,
+        reason = "inlined constructor, many args needed for performance"
+    )]
     // Force inline, due to lot of arguments, inlining must be forced, and it is actually beneficial
     // because passing so much data is costly. Verified with samply.
     #[inline(always)]

crates/vm/levm/src/constants.rs

@@ -51,7 +51,7 @@ pub const VERSIONED_HASH_VERSION_KZG: u8 = 0x01;
 pub const TARGET_BLOB_GAS_PER_BLOCK: u32 = 393216; // TARGET_BLOB_NUMBER_PER_BLOCK * GAS_PER_BLOB
 pub const TARGET_BLOB_GAS_PER_BLOCK_PECTRA: u32 = 786432; // TARGET_BLOB_NUMBER_PER_BLOCK * GAS_PER_BLOB
 
-pub const MIN_BASE_FEE_PER_BLOB_GAS: U256 = U256::one();
+pub const MIN_BASE_FEE_PER_BLOB_GAS: u64 = 1;
 
 // WARNING: Do _not_ use the BLOB_BASE_FEE_UPDATE_FRACTION_* family of
 // constants as is. Use the `get_blob_base_fee_update_fraction_value`
@@ -69,7 +69,7 @@ pub const MAX_BLOB_COUNT_TX: usize = 6;
 pub const VALID_BLOB_PREFIXES: [u8; 2] = [0x01, 0x02];
 
 // Block constants
-pub const LAST_AVAILABLE_BLOCK_LIMIT: U256 = U256([256, 0, 0, 0]);
+pub const LAST_AVAILABLE_BLOCK_LIMIT: u64 = 256;
 
 // EIP7702 - EOA Load Code
 pub static SECP256K1_ORDER: LazyLock<U256> = LazyLock::new(||

crates/vm/levm/src/environment.rs

@@ -20,19 +20,19 @@ pub struct Environment {
     /// Gas limit of the Transaction
     pub gas_limit: u64,
     pub config: EVMConfig,
-    pub block_number: U256,
-    /// Coinbase is the block's beneficiary - the address that receives the block rewards (priority fees).
+    pub block_number: u64,
+    /// Coinbase is the block's beneficiary - the address that receives the block rewards and fees.
     pub coinbase: Address,
-    pub timestamp: U256,
+    pub timestamp: u64,
     pub prev_randao: Option<H256>,
     pub difficulty: U256,
     pub slot_number: U256,
     pub chain_id: U256,
     pub base_fee_per_gas: U256,
     pub base_blob_fee_per_gas: U256,
     pub gas_price: U256, // Effective gas price
-    pub block_excess_blob_gas: Option<U256>,
-    pub block_blob_gas_used: Option<U256>,
+    pub block_excess_blob_gas: Option<u64>,
+    pub block_blob_gas_used: Option<u64>,
     pub tx_blob_hashes: Vec<H256>,
     pub tx_max_priority_fee_per_gas: Option<U256>,
     pub tx_max_fee_per_gas: Option<U256>,

crates/vm/levm/src/hooks/default_hook.rs

@@ -353,6 +353,7 @@ pub fn validate_max_fee_per_blob_gas(
         }
         .into());
     }
+
     Ok(())
 }
 

crates/vm/levm/src/hooks/l2_hook.rs

@@ -234,7 +234,7 @@ fn validate_sufficient_max_fee_per_gas_l2(
     let total_fee = vm
         .env
         .base_fee_per_gas
-        .checked_add(U256::from(fee_config.operator_fee_per_gas))
+        .checked_add(fee_config.operator_fee_per_gas.into())
         .ok_or(TxValidationError::InsufficientMaxFeePerGas)?;
 
     if vm.env.tx_max_fee_per_gas.unwrap_or(vm.env.gas_price) < total_fee {