feat: (levm) Implement different call types (lambdaclass#583)

**Motivation**

Implement `CALLCODE`, `DELEGATECALL` and `STATICCALL`

**Description**
- `CALL`, `STATICCALL`, `DELEGATECALL` and `CALLCODE` are similar but
have some key differences, for example:
1) `StaticCall` does the same as `Call`, but changes the config of the
`CallFrame` to be static
2) `DelegateCall` is used to execute code from another contract, but
changing the storage of the actual address. This is done by having an
`Option<Address>` in the `CallFrame`. `CallCode` does the same as
`DelegateCall` but changes value and msg_sender.
- Created the `generic_call` function to provide a standard on
performing calls.

more info in [EVM Deep
Dives](https://noxx.substack.com/p/evm-deep-dives-the-path-to-shadowy-a5f?utm_source=%2Fprofile%2F80455042-noxx&utm_medium=reader2&s=r)

Closes lambdaclass#530 
Closes lambdaclass#532 
Closes lambdaclass#534

---------

Co-authored-by: Paolo Belforte <[email protected]>
Co-authored-by: Paolo Belforte <[email protected]>
Co-authored-by: Juan Ignacio Medone Sabatini <[email protected]>

crates/levm/.gitignore

@@ -0,0 +1 @@
+ethtests

crates/levm/src/call_frame.rs

@@ -18,14 +18,15 @@ pub struct Log {
     pub data: Bytes,
 }
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, PartialEq)]
 pub struct CallFrame {
     pub gas: U256,
     pub pc: usize,
     pub msg_sender: Address,
-    pub callee: Address,
-    pub bytecode: Bytes,
+    pub to: Address,
+    pub code_address: Address,
     pub delegate: Option<Address>,
+    pub bytecode: Bytes,
     pub msg_value: U256,
     pub stack: Vec<U256>, // max 1024 in the future
     pub memory: Memory,
@@ -34,15 +35,41 @@ pub struct CallFrame {
     // where to store return data of subcall
     pub return_data_offset: Option<usize>,
     pub return_data_size: Option<usize>,
+    pub is_static: bool,
     pub transient_storage: TransientStorage,
     pub logs: Vec<Log>,
-    pub is_static: bool,
 }
 
 impl CallFrame {
-    pub fn new(bytecode: Bytes) -> Self {
+    pub fn new_from_bytecode(bytecode: Bytes) -> Self {
+        Self {
+            bytecode,
+            ..Default::default()
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        gas: U256,
+        msg_sender: Address,
+        to: Address,
+        code_address: Address,
+        delegate: Option<Address>,
+        bytecode: Bytes,
+        msg_value: U256,
+        calldata: Bytes,
+        is_static: bool,
+    ) -> Self {
         Self {
+            gas,
+            msg_sender,
+            to,
+            code_address,
+            delegate,
             bytecode,
+            msg_value,
+            calldata,
+            is_static,
             ..Default::default()
         }
     }

crates/levm/src/memory.rs

@@ -1,6 +1,6 @@
 use crate::primitives::U256;
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, PartialEq)]
 pub struct Memory {
     data: Vec<u8>,
 }
@@ -16,6 +16,10 @@ impl Memory {
         Self { data: Vec::new() }
     }
 
+    pub fn new_from_vec(data: Vec<u8>) -> Self {
+        Self { data }
+    }
+
     fn resize(&mut self, offset: usize) {
         if offset.next_multiple_of(32) > self.data.len() {
             self.data.resize(offset.next_multiple_of(32), 0);

crates/levm/src/opcodes.rs

@@ -158,11 +158,11 @@ pub enum Opcode {
     // // System Operations
     // CREATE = 0xF0,
     CALL = 0xF1,
-    // CALLCODE = 0xF2,
+    CALLCODE = 0xF2,
     RETURN = 0xF3,
-    // DELEGATECALL = 0xF4,
+    DELEGATECALL = 0xF4,
     // CREATE2 = 0xF5,
-    // STATICCALL = 0xFA,
+    STATICCALL = 0xFA,
     // REVERT = 0xFD,
     // INVALID = 0xFE,
     // SELFDESTRUCT = 0xFF,
@@ -301,7 +301,10 @@ impl From<u8> for Opcode {
             x if x == Opcode::TLOAD as u8 => Opcode::TLOAD,
             x if x == Opcode::TSTORE as u8 => Opcode::TSTORE,
             0xF1 => Opcode::CALL,
+            0xF2 => Opcode::CALLCODE,
             0xF3 => Opcode::RETURN,
+            0xF4 => Opcode::DELEGATECALL,
+            0xFA => Opcode::STATICCALL,
             _ => panic!("Unknown opcode: 0x{:02X}", byte),
         }
     }

crates/levm/src/operations.rs

@@ -91,11 +91,11 @@ pub enum Operation {
     Log(u8),
     // Create,
     Call,
-    // CallCode,
+    CallCode,
     Return,
-    // DelegateCall,
+    DelegateCall,
     // Create2,
-    // StaticCall,
+    StaticCall,
     // Revert,
     // Invalid,
     // SelfDestruct,
@@ -222,11 +222,11 @@ impl Operation {
                 Bytes::copy_from_slice(&[Opcode::LOG0 as u8 + n])
             } // Operation::Create => Bytes::copy_from_slice(&[Opcode::CREATE as u8]),
             Operation::Call => Bytes::copy_from_slice(&[Opcode::CALL as u8]),
-            // Operation::CallCode => Bytes::copy_from_slice(&[Opcode::CALLCODE as u8]),
+            Operation::CallCode => Bytes::copy_from_slice(&[Opcode::CALLCODE as u8]),
             Operation::Return => Bytes::copy_from_slice(&[Opcode::RETURN as u8]),
-            // Operation::DelegateCall => Bytes::copy_from_slice(&[Opcode::DELEGATECALL as u8]),
+            Operation::DelegateCall => Bytes::copy_from_slice(&[Opcode::DELEGATECALL as u8]),
             // Operation::Create2 => Bytes::copy_from_slice(&[Opcode::CREATE2 as u8]),
-            // Operation::StaticCall => Bytes::copy_from_slice(&[Opcode::STATICCALL as u8]),
+            Operation::StaticCall => Bytes::copy_from_slice(&[Opcode::STATICCALL as u8]),
             // Operation::Revert => Bytes::copy_from_slice(&[Opcode::REVERT as u8]),
             // Operation::Invalid => Bytes::copy_from_slice(&[Opcode::INVALID as u8]),
             // Operation::SelfDestruct => Bytes::copy_from_slice(&[Opcode::SELFDESTRUCT as u8]),

crates/levm/src/primitives.rs

@@ -1,2 +1,2 @@
 pub use bytes::Bytes;
-pub use ethereum_types::{Address, H160, H256, U256, U512};
+pub use ethereum_types::{Address, H160, H256, H32, U256, U512};