fix(levm): change gas type from U256 to u64

cmd/ef_tests/levm/deserialize.rs

@@ -264,10 +264,11 @@ impl<'de> Deserialize<'de> for EFTests {
             // 111, 112, 121, 122, 211, 212, 221, 222
             for (data_id, data) in raw_tx.data.iter().enumerate() {
                 for (gas_limit_id, gas_limit) in raw_tx.gas_limit.iter().enumerate() {
+                    let gas_limit_u64: u64 = (*gas_limit).as_u64();
                     for (value_id, value) in raw_tx.value.iter().enumerate() {
                         let tx = EFTestTransaction {
                             data: data.clone(),
-                            gas_limit: *gas_limit,
+                            gas_limit: gas_limit_u64,
                             gas_price: raw_tx.gas_price,
                             nonce: raw_tx.nonce,
                             secret_key: raw_tx.secret_key,

cmd/ef_tests/levm/runner/levm_runner.rs

@@ -94,7 +94,7 @@ pub fn prepare_vm_for_tx(vector: &TestVector, test: &EFTest) -> Result<VM, EFTes
         tx.to.clone(),
         Environment {
             origin: tx.sender,
-            refunded_gas: U256::default(),
+            refunded_gas: 0,
             gas_limit: tx.gas_limit,
             block_number: test.env.current_number,
             coinbase: test.env.current_coinbase,
@@ -109,7 +109,7 @@ pub fn prepare_vm_for_tx(vector: &TestVector, test: &EFTest) -> Result<VM, EFTes
             tx_max_priority_fee_per_gas: tx.max_priority_fee_per_gas,
             tx_max_fee_per_gas: tx.max_fee_per_gas,
             tx_max_fee_per_blob_gas: tx.max_fee_per_blob_gas,
-            block_gas_limit: test.env.current_gas_limit,
+            block_gas_limit: test.env.current_gas_limit.as_u64(),
         },
         tx.value,
         tx.data.clone(),

cmd/ef_tests/levm/runner/revm_runner.rs

@@ -8,7 +8,7 @@ use crate::{
     utils::{effective_gas_price, load_initial_state},
 };
 use bytes::Bytes;
-use ethrex_core::{types::TxKind, Address, H256};
+use ethrex_core::{types::TxKind, Address, H256, U256};
 use ethrex_levm::{
     errors::{TransactionReport, TxResult},
     Account, StorageSlot,
@@ -101,11 +101,13 @@ pub fn prepare_revm_for_tx<'state>(
     let chain_spec = initial_state
         .chain_config()
         .map_err(|err| EFTestRunnerError::VMInitializationFailed(err.to_string()))?;
+
+    let gas_limit: U256 = test.env.current_gas_limit;
     let block_env = RevmBlockEnv {
         number: RevmU256::from_limbs(test.env.current_number.0),
         coinbase: RevmAddress(test.env.current_coinbase.0.into()),
         timestamp: RevmU256::from_limbs(test.env.current_timestamp.0),
-        gas_limit: RevmU256::from_limbs(test.env.current_gas_limit.0),
+        gas_limit: RevmU256::from_limbs(gas_limit.0),
         basefee: RevmU256::from_limbs(test.env.current_base_fee.unwrap_or_default().0),
         difficulty: RevmU256::from_limbs(test.env.current_difficulty.0),
         prevrandao: test.env.current_random.map(|v| v.0.into()),
@@ -137,7 +139,7 @@ pub fn prepare_revm_for_tx<'state>(
 
     let tx_env = RevmTxEnv {
         caller: tx.sender.0.into(),
-        gas_limit: tx.gas_limit.as_u64(),
+        gas_limit: tx.gas_limit,
         gas_price: RevmU256::from_limbs(effective_gas_price(test, tx)?.0),
         transact_to: match tx.to {
             TxKind::Call(to) => RevmTxKind::Call(to.0.into()),

cmd/ef_tests/levm/types.rs

@@ -295,7 +295,7 @@ pub struct EFTestRawTransaction {
 #[serde(rename_all = "camelCase")]
 pub struct EFTestTransaction {
     pub data: Bytes,
-    pub gas_limit: U256,
+    pub gas_limit: u64,
     pub gas_price: Option<U256>,
     #[serde(deserialize_with = "deserialize_u256_safe")]
     pub nonce: U256,

crates/vm/levm/src/call_frame.rs

@@ -56,9 +56,9 @@ impl Stack {
 /// the EVM is currently executing.
 pub struct CallFrame {
     /// Max gas a callframe can use
-    pub gas_limit: U256,
+    pub gas_limit: u64,
     /// Keeps track of the gas that's been used in current context
-    pub gas_used: U256,
+    pub gas_used: u64,
     /// Program Counter
     pub pc: usize,
     /// Address of the account that sent the message
@@ -95,7 +95,7 @@ impl CallFrame {
     pub fn new_from_bytecode(bytecode: Bytes) -> Self {
         let valid_jump_destinations = get_valid_jump_destinations(&bytecode).unwrap_or_default();
         Self {
-            gas_limit: U256::MAX,
+            gas_limit: u64::MAX,
             bytecode,
             valid_jump_destinations,
             ..Default::default()
@@ -117,8 +117,8 @@ impl CallFrame {
         msg_value: U256,
         calldata: Bytes,
         is_static: bool,
-        gas_limit: U256,
-        gas_used: U256,
+        gas_limit: u64,
+        gas_used: u64,
         depth: usize,
         create_op_called: bool,
     ) -> Self {

crates/vm/levm/src/constants.rs

@@ -21,7 +21,7 @@ pub const EMPTY_CODE_HASH: H256 = H256([
 pub const MEMORY_EXPANSION_QUOTIENT: usize = 512;
 
 // Transaction costs in gas (in wei)
-pub const TX_BASE_COST: U256 = U256([21000, 0, 0, 0]);
+pub const TX_BASE_COST: u64 = 21000;
 
 pub const MAX_CODE_SIZE: usize = 0x6000;
 pub const INIT_CODE_MAX_SIZE: usize = 49152;

crates/vm/levm/src/environment.rs

@@ -5,8 +5,8 @@ pub struct Environment {
     /// The sender address of the transaction that originated
     /// this execution.
     pub origin: Address,
-    pub refunded_gas: U256,
-    pub gas_limit: U256,
+    pub refunded_gas: u64,
+    pub gas_limit: u64,
     pub block_number: U256,
     pub coinbase: Address,
     pub timestamp: U256,
@@ -20,15 +20,15 @@ pub struct Environment {
     pub tx_max_priority_fee_per_gas: Option<U256>,
     pub tx_max_fee_per_gas: Option<U256>,
     pub tx_max_fee_per_blob_gas: Option<U256>,
-    pub block_gas_limit: U256,
+    pub block_gas_limit: u64,
 }
 
 impl Environment {
     pub fn default_from_address(origin: Address) -> Self {
         Self {
             origin,
-            refunded_gas: U256::default(),
-            gas_limit: U256::MAX,
+            refunded_gas: 0,
+            gas_limit: u64::MAX,
             block_number: Default::default(),
             coinbase: Default::default(),
             timestamp: Default::default(),