fix(levm): fix problems related to 32 bit architecture (#4104)

**Motivation**

- Find errors on 32 bit architecture

**Description**

<!-- A clear and concise general description of the changes this PR
introduces -->
- `u256_to_usize` now halts if the number doesn't fit in 32 bits instead
of 64.
- Memory size cost is computed using u64 instead of usize. The previous
implementation overflowed on 32 bit architectures in some edge cases.
Also I made it prettier :D


How this was tested: Adapting ethrex to run on 32 bit x86 in branch
[replay_32_bit_x86_testing](https://github.com/lambdaclass/ethrex/tree/replay_32_bit_x86_testing)
and running EFTests, both state and blockchain. After these changes they
all pass.
<!-- Link to issues: Resolves #111, Resolves #222 -->

Makes progress towards #4081

Author: JereSalo

crates/vm/levm/src/constants.rs

@@ -15,7 +15,7 @@ pub const EMPTY_CODE_HASH: H256 = H256([
     0xe5, 0x00, 0xb6, 0x53, 0xca, 0x82, 0x27, 0x3b, 0x7b, 0xfa, 0xd8, 0x04, 0x5d, 0x85, 0xa4, 0x70,
 ]);
 
-pub const MEMORY_EXPANSION_QUOTIENT: usize = 512;
+pub const MEMORY_EXPANSION_QUOTIENT: u64 = 512;
 
 // Dedicated gas limit for system calls according to EIPs 2935, 4788, 7002 and 7251
 pub const SYS_CALL_GAS_LIMIT: u64 = 30000000;

crates/vm/levm/src/memory.rs

@@ -1,11 +1,10 @@
 use std::{cell::RefCell, rc::Rc};
 
 use crate::{
-    constants::{MEMORY_EXPANSION_QUOTIENT, WORD_SIZE_IN_BYTES_USIZE},
+    constants::{MEMORY_EXPANSION_QUOTIENT, WORD_SIZE_IN_BYTES_U64, WORD_SIZE_IN_BYTES_USIZE},
     errors::{ExceptionalHalt, InternalError, VMError},
 };
 use ExceptionalHalt::OutOfBounds;
-use ExceptionalHalt::OutOfGas;
 use ethrex_common::{
     U256,
     utils::{u256_from_big_endian_const, u256_to_big_endian},
@@ -279,23 +278,20 @@ pub fn expansion_cost(new_memory_size: usize, current_memory_size: usize) -> Res
 }
 
 /// The total cost for a given memory size.
+/// Gas cost should always be computed in u64
 #[inline]
 fn cost(memory_size: usize) -> Result<u64, VMError> {
-    let memory_size_word = memory_size
-        .checked_add(WORD_SIZE_IN_BYTES_USIZE.wrapping_sub(1))
-        .ok_or(OutOfGas)?
-        / WORD_SIZE_IN_BYTES_USIZE;
-
-    let gas_cost = (memory_size_word
-        .checked_mul(memory_size_word)
-        .ok_or(OutOfGas)?
-        / MEMORY_EXPANSION_QUOTIENT)
-        .checked_add(3usize.checked_mul(memory_size_word).ok_or(OutOfGas)?)
-        .ok_or(OutOfGas)?;
-
-    gas_cost
-        .try_into()
-        .map_err(|_| ExceptionalHalt::VeryLargeNumber.into())
+    let memory_size = u64::try_from(memory_size).map_err(|_| InternalError::TypeConversion)?;
+
+    // memory size measured in 32 byte words
+    let words = memory_size.div_ceil(WORD_SIZE_IN_BYTES_U64);
+
+    // Cost(words) ≈ floor(words^2 / q) + 3 * words
+    // For this to overflow memory size in words should be 2^32, which is impossible.
+    #[expect(clippy::arithmetic_side_effects)]
+    let gas_cost = words * words / MEMORY_EXPANSION_QUOTIENT + 3 * words;
+
+    Ok(gas_cost)
 }
 
 #[inline]

crates/vm/levm/src/utils.rs

@@ -680,10 +680,11 @@ pub fn account_to_levm_account(account: Account) -> (LevmAccount, Bytes) {
     )
 }
 
-/// Converts a U256 value into usize, fails if the value is over 64 bytes
+/// Converts a U256 value into usize, returning an error if the value is over 32 bits
+/// This is generally used for memory offsets and sizes, 32 bits is more than enough for this purpose.
 #[expect(clippy::as_conversions)]
 pub fn u256_to_usize(val: U256) -> Result<usize, VMError> {
-    if val.0[1] != 0 || val.0[2] != 0 || val.0[3] != 0 {
+    if val.0[0] > u32::MAX as u64 || val.0[1] != 0 || val.0[2] != 0 || val.0[3] != 0 {
         return Err(VMError::ExceptionalHalt(ExceptionalHalt::VeryLargeNumber));
     }
     Ok(val.0[0] as usize)