fix(levm): fixes several bugs found when running the EF tests

crates/vm/levm/src/call_frame.rs

@@ -36,8 +36,12 @@ impl Stack {
         self.stack.get(index).ok_or(VMError::StackUnderflow)
     }
 
-    pub fn swap(&mut self, a: usize, b: usize) {
-        self.stack.swap(a, b)
+    pub fn swap(&mut self, a: usize, b: usize) -> Result<(), VMError> {
+        if a >= self.stack.len() || b >= self.stack.len() {
+            return Err(VMError::StackUnderflow);
+        }
+        self.stack.swap(a, b);
+        Ok(())
     }
 }
 
@@ -144,6 +148,10 @@ impl CallFrame {
     }
 
     fn opcode_at(&self, offset: usize) -> Option<Opcode> {
-        self.bytecode.get(offset).copied().map(Opcode::from)
+        self.bytecode
+            .get(offset)
+            .copied()
+            .map(Opcode::try_from)?
+            .ok()
     }
 }

crates/vm/levm/src/constants.rs

@@ -126,6 +126,14 @@ pub fn init_code_cost(init_code_length: usize) -> u64 {
     INIT_WORD_COST as u64 * (init_code_length as u64 + 31) / 32
 }
 
+pub mod create_opcode {
+    use ethereum_rust_core::U256;
+
+    pub const INIT_CODE_WORD_COST: U256 = U256([2, 0, 0, 0]);
+    pub const CODE_DEPOSIT_COST: U256 = U256([200, 0, 0, 0]);
+    pub const CREATE_BASE_COST: U256 = U256([32000, 0, 0, 0]);
+}
+
 pub const VERSIONED_HASH_VERSION_KZG: u8 = 0x01;
 pub const MAX_BLOB_NUMBER_PER_BLOCK: usize = 6;
 
@@ -139,3 +147,4 @@ pub const COLD_STORAGE_ACCESS_COST: U256 = U256([2100, 0, 0, 0]);
 
 // Block constants
 pub const LAST_AVAILABLE_BLOCK_LIMIT: U256 = U256([256, 0, 0, 0]);
+pub const MAX_BLOCK_GAS_LIMIT: U256 = U256([30_000_000, 0, 0, 0]);

crates/vm/levm/src/errors.rs

@@ -31,8 +31,17 @@ pub enum VMError {
     InvalidInitialByte,
     NonceOverflow,
     InternalError,
+    MemoryLoadOutOfBounds,
+    GasLimitPriceProductOverflow,
+    DataSizeOverflow,
+    Internal,
+    GasCostOverflow,
+    OffsetOverflow,
+    CreationCostIsTooHigh,
+    MaxGasLimitExceeded,
 }
 
+#[derive(Debug, Clone)]
 pub enum OpcodeSuccess {
     Continue,
     Result(ResultReason),

crates/vm/levm/src/memory.rs

@@ -30,47 +30,116 @@ impl Memory {
         }
     }
 
-    pub fn load(&mut self, offset: usize) -> U256 {
-        self.resize(offset + 32);
+    pub fn load(&mut self, offset: usize) -> Result<U256, VMError> {
+        self.resize(
+            offset
+                .checked_add(32)
+                .ok_or(VMError::MemoryLoadOutOfBounds)?,
+        );
         let value_bytes: [u8; 32] = self
             .data
-            .get(offset..offset + 32)
-            .unwrap()
+            .get(
+                offset
+                    ..offset
+                        .checked_add(32)
+                        .ok_or(VMError::MemoryLoadOutOfBounds)?,
+            )
+            .ok_or(VMError::MemoryLoadOutOfBounds)?
             .try_into()
             .unwrap();
-        U256::from(value_bytes)
+        Ok(U256::from(value_bytes))
     }
 
-    pub fn load_range(&mut self, offset: usize, size: usize) -> Vec<u8> {
-        self.resize(offset + size);
-        self.data.get(offset..offset + size).unwrap().into()
+    pub fn load_range(&mut self, offset: usize, size: usize) -> Result<Vec<u8>, VMError> {
+        self.resize(
+            offset
+                .checked_add(size)
+                .ok_or(VMError::MemoryLoadOutOfBounds)?,
+        );
+        self.data
+            .get(
+                offset
+                    ..offset
+                        .checked_add(size)
+                        .ok_or(VMError::MemoryLoadOutOfBounds)?,
+            )
+            .ok_or(VMError::MemoryLoadOutOfBounds)
+            .map(|slice| slice.to_vec())
     }
 
-    pub fn store_bytes(&mut self, offset: usize, value: &[u8]) {
+    pub fn store_bytes(&mut self, offset: usize, value: &[u8]) -> Result<(), VMError> {
         let len = value.len();
-        self.resize(offset + len);
-        self.data
-            .splice(offset..offset + len, value.iter().copied());
+        self.resize(
+            offset
+                .checked_add(len)
+                .ok_or(VMError::MemoryLoadOutOfBounds)?,
+        );
+        self.data.splice(
+            offset
+                ..offset
+                    .checked_add(len)
+                    .ok_or(VMError::MemoryLoadOutOfBounds)?,
+            value.iter().copied(),
+        );
+        Ok(())
     }
 
-    pub fn store_n_bytes(&mut self, offset: usize, value: &[u8], size: usize) {
-        self.resize(offset + size);
-        self.data
-            .splice(offset..offset + size, value.iter().copied());
+    pub fn store_n_bytes(
+        &mut self,
+        offset: usize,
+        value: &[u8],
+        size: usize,
+    ) -> Result<(), VMError> {
+        self.resize(
+            offset
+                .checked_add(size)
+                .ok_or(VMError::MemoryLoadOutOfBounds)?,
+        );
+        self.data.splice(
+            offset
+                ..offset
+                    .checked_add(size)
+                    .ok_or(VMError::MemoryLoadOutOfBounds)?,
+            value.iter().copied(),
+        );
+        Ok(())
     }
 
     pub fn size(&self) -> U256 {
         U256::from(self.data.len())
     }
 
-    pub fn copy(&mut self, src_offset: usize, dest_offset: usize, size: usize) {
-        let max_size = std::cmp::max(src_offset + size, dest_offset + size);
+    pub fn copy(
+        &mut self,
+        src_offset: usize,
+        dest_offset: usize,
+        size: usize,
+    ) -> Result<(), VMError> {
+        let max_size = std::cmp::max(
+            src_offset
+                .checked_add(size)
+                .ok_or(VMError::MemoryLoadOutOfBounds)?,
+            dest_offset
+                .checked_add(size)
+                .ok_or(VMError::MemoryLoadOutOfBounds)?,
+        );
         self.resize(max_size);
         let mut temp = vec![0u8; size];
 
-        temp.copy_from_slice(&self.data[src_offset..src_offset + size]);
+        temp.copy_from_slice(
+            &self.data[src_offset
+                ..src_offset
+                    .checked_add(size)
+                    .ok_or(VMError::MemoryLoadOutOfBounds)?],
+        );
+
+        self.data[dest_offset
+            ..dest_offset
+                .checked_add(size)
+                .ok_or(VMError::MemoryLoadOutOfBounds)?]
+            .copy_from_slice(&temp);
 
-        self.data[dest_offset..dest_offset + size].copy_from_slice(&temp);
+        Ok(())
     }
 
     pub fn expansion_cost(&self, memory_byte_size: usize) -> Result<U256, VMError> {

crates/vm/levm/src/opcode_handlers/arithmetic.rs

@@ -56,7 +56,10 @@ impl VM {
             current_call_frame.stack.push(U256::zero())?;
             return Ok(OpcodeSuccess::Continue);
         }
-        let quotient = dividend / divisor;
+        let Some(quotient) = dividend.checked_div(divisor) else {
+            current_call_frame.stack.push(U256::zero())?;
+            return Ok(OpcodeSuccess::Continue);
+        };
         current_call_frame.stack.push(quotient)?;
 
         Ok(OpcodeSuccess::Continue)
@@ -88,7 +91,10 @@ impl VM {
         } else {
             divisor
         };
-        let quotient = dividend / divisor;
+        let Some(quotient) = dividend.checked_div(divisor) else {
+            current_call_frame.stack.push(U256::zero())?;
+            return Ok(OpcodeSuccess::Continue);
+        };
         let quotient_is_negative = dividend_is_negative ^ divisor_is_negative;
         let quotient = if quotient_is_negative {
             negate(quotient)
@@ -264,5 +270,6 @@ fn abs(value: U256) -> U256 {
 
 /// Negates a number in two's complement
 fn negate(value: U256) -> U256 {
-    !value + U256::one()
+    let inverted = !value;
+    inverted.saturating_add(U256::one())
 }