feat: implement 0x3E - RETURNDATACOPY Opcode

crates/evm/src/errors.cairo

@@ -11,11 +11,15 @@ const PC_OUT_OF_BOUNDS: felt252 = 'Kakarot: pc >= bytecode length';
 // TYPE CONVERSION
 const TYPE_CONVERSION_ERROR: felt252 = 'Kakarot: type conversion error';
 
+// RETURNDATA
+const RETURNDATA_OUT_OF_BOUNDS_ERROR: felt252 = 'Kakarot: ReturnDataOutOfBounds';
+
 #[derive(Drop, Copy, PartialEq)]
 enum EVMError {
     StackError: felt252,
     InvalidProgramCounter: felt252,
-    TypeConversionError: felt252
+    TypeConversionError: felt252,
+    ReturnDataError: felt252
 }
 
 
@@ -25,6 +29,7 @@ impl EVMErrorIntoU256 of Into<EVMError, u256> {
             EVMError::StackError(error_message) => error_message.into(),
             EVMError::InvalidProgramCounter(error_message) => error_message.into(),
             EVMError::TypeConversionError(error_message) => error_message.into(),
+            EVMError::ReturnDataError(error_message) => error_message.into(),
         }
     }
 }

crates/evm/src/instructions/environmental_information.cairo

@@ -2,13 +2,14 @@
 use starknet::{EthAddressIntoFelt252};
 use result::ResultTrait;
 use evm::stack::StackTrait;
+use evm::errors::{EVMError, RETURNDATA_OUT_OF_BOUNDS_ERROR};
+use evm::helpers::U256IntoResultU32;
 use evm::context::{
     ExecutionContext, ExecutionContextTrait, BoxDynamicExecutionContextDestruct, CallContextTrait
 };
-use evm::errors::EVMError;
 use utils::helpers::EthAddressIntoU256;
-use evm::helpers::U256IntoResultU32;
 use evm::memory::MemoryTrait;
+use integer::u32_overflowing_add;
 
 #[generate_trait]
 impl EnvironmentInformationImpl of EnvironmentInformationTrait {
@@ -149,6 +150,27 @@ impl EnvironmentInformationImpl of EnvironmentInformationTrait {
     /// Save word to memory.
     /// # Specification: https://www.evm.codes/#3e?fork=shanghai
     fn exec_returndatacopy(ref self: ExecutionContext) -> Result<(), EVMError> {
+        let popped = self.stack.pop_n(3)?;
+        let dest_offset: u32 = Into::<u256, Result<u32, EVMError>>::into((*popped[0]))?;
+        let offset: u32 = Into::<u256, Result<u32, EVMError>>::into((*popped[1]))?;
+        let size: u32 = Into::<u256, Result<u32, EVMError>>::into((*popped[2]))?;
+
+        let return_data: Span<u8> = self.return_data();
+
+        match u32_overflowing_add(offset, size) {
+            Result::Ok(x) => {
+                if (x > return_data.len()) {
+                    return Result::Err(EVMError::ReturnDataError(RETURNDATA_OUT_OF_BOUNDS_ERROR));
+                }
+            },
+            Result::Err(x) => {
+                return Result::Err(EVMError::ReturnDataError(RETURNDATA_OUT_OF_BOUNDS_ERROR));
+            }
+        }
+
+        let data_to_copy: Span<u8> = return_data.slice(offset, size);
+        self.memory.store_n(data_to_copy, dest_offset);
+
         Result::Ok(())
     }
 

crates/evm/src/memory.cairo

@@ -262,7 +262,7 @@ impl InternalMemoryMethods of InternalMemoryTrait {
 
             self.items.insert(chunk_index.into(), current.try_into().unwrap());
             chunk_index += 1;
-            elements = elements.slice(0, 16);
+            elements = elements.slice(16, elements.len() - 16);
         }
     }
 

crates/evm/src/tests/test_instructions/test_environment_information.cairo

@@ -1,16 +1,22 @@
 use evm::instructions::EnvironmentInformationTrait;
+use evm::memory::{InternalMemoryTrait, MemoryTrait};
 use evm::tests::test_utils::{
     setup_execution_context, setup_execution_context_with_bytecode, evm_address, callvalue
 };
 use evm::stack::StackTrait;
-use evm::memory::{InternalMemoryTrait, MemoryTrait};
 use option::OptionTrait;
 use starknet::EthAddressIntoFelt252;
 use utils::helpers::{EthAddressIntoU256, u256_to_bytes_array};
-use evm::errors::{EVMError, TYPE_CONVERSION_ERROR};
+use evm::errors::{EVMError, TYPE_CONVERSION_ERROR, RETURNDATA_OUT_OF_BOUNDS_ERROR};
 use evm::context::{
     ExecutionContext, ExecutionContextTrait, BoxDynamicExecutionContextDestruct, CallContextTrait
 };
+use utils::helpers::{ArrayExtension, ArrayExtensionTrait};
+use integer::u32_overflowing_add;
+
+// *************************************************************************
+// 0x30: ADDRESS
+// *************************************************************************
 
 #[test]
 #[available_gas(20000000)]
@@ -34,6 +40,10 @@ fn test_address_nested_call() { // A (EOA) -(calls)-> B (smart contract) -(calls
 // ref: https://github.com/kkrt-labs/kakarot-ssj/issues/183
 }
 
+// *************************************************************************
+// 0x34: CALLVALUE
+// *************************************************************************
+
 #[test]
 #[available_gas(120000)]
 fn test__exec_callvalue() {
@@ -48,19 +58,9 @@ fn test__exec_callvalue() {
     assert(ctx.stack.pop().unwrap() == callvalue(), 'should be `123456789');
 }
 
-#[test]
-#[available_gas(20000000)]
-fn test_gasprice() {
-    // Given
-    let mut ctx = setup_execution_context();
-
-    // When
-    ctx.exec_gasprice();
-
-    // Then
-    assert(ctx.stack.len() == 1, 'stack should have one element');
-    assert(ctx.stack.peek().unwrap() == 10, 'stack top should be 10');
-}
+// *************************************************************************
+// 0x36: CALLDATASIZE
+// *************************************************************************
 
 #[test]
 #[available_gas(20000000)]
@@ -77,6 +77,10 @@ fn test_calldata_size() {
     assert(ctx.stack.peek().unwrap() == calldata.len().into(), 'stack top is not calldatasize');
 }
 
+// *************************************************************************
+// 0x38: CODESIZE
+// *************************************************************************
+
 #[test]
 #[available_gas(20000000)]
 fn test_codesize() {
@@ -92,6 +96,10 @@ fn test_codesize() {
     assert(ctx.stack.pop().unwrap() == bytecode.len().into(), 'wrong codesize');
 }
 
+// *************************************************************************
+// 0x39: CODECOPY
+// *************************************************************************
+
 #[test]
 #[available_gas(20000000)]
 fn test_codecopy_type_conversion_error() {
@@ -186,6 +194,28 @@ fn test_codecopy(dest_offset: u32, offset: u32, mut size: u32) {
     };
 }
 
+// *************************************************************************
+// 0x3A: GASPRICE
+// *************************************************************************
+
+#[test]
+#[available_gas(20000000)]
+fn test_gasprice() {
+    // Given
+    let mut ctx = setup_execution_context();
+
+    // When
+    ctx.exec_gasprice();
+
+    // Then
+    assert(ctx.stack.len() == 1, 'stack should have one element');
+    assert(ctx.stack.peek().unwrap() == 10, 'stack top should be 10');
+}
+
+// *************************************************************************
+// 0x3D: RETURNDATASIZE
+// *************************************************************************
+
 #[test]
 #[available_gas(20000000)]
 fn test_returndatasize() {
@@ -202,3 +232,160 @@ fn test_returndatasize() {
     assert(ctx.stack.len() == 1, 'stack should have one element');
     assert(ctx.stack.pop().unwrap() == size.into(), 'wrong returndatasize');
 }
+
+// *************************************************************************
+// 0x3E: RETURNDATACOPY
+// *************************************************************************
+
+#[test]
+#[available_gas(20000000)]
+fn test_returndata_copy_type_conversion_error() {
+    // Given
+    let mut ctx = setup_execution_context();
+
+    ctx.stack.push(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+    ctx.stack.push(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+    ctx.stack.push(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+
+    // When
+    let res = ctx.exec_returndatacopy();
+
+    // Then
+    assert(
+        res.unwrap_err() == EVMError::TypeConversionError(TYPE_CONVERSION_ERROR),
+        'should return ConversionError'
+    );
+}
+
+#[test]
+#[available_gas(20000000)]
+fn test_returndata_copy_overflowing_add_error() {
+    test_returndata_copy(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+}
+
+#[test]
+#[available_gas(20000000)]
+fn test_returndata_copy_basic() {
+    test_returndata_copy(32, 0, 0);
+}
+
+#[test]
+#[available_gas(20000000)]
+fn test_returndata_copy_with_offset() {
+    test_returndata_copy(32, 2, 0);
+}
+
+#[test]
+#[available_gas(20000000)]
+fn test_returndata_copy_with_out_of_bound_bytes() {
+    test_returndata_copy(32, 30, 10);
+}
+
+#[test]
+#[available_gas(20000000)]
+fn test_returndata_copy_with_multiple_words() {
+    test_returndata_copy(32, 0, 33);
+}
+
+fn test_returndata_copy(dest_offset: u32, offset: u32, mut size: u32) {
+    // Given
+    let mut ctx = setup_execution_context();
+    ctx
+        .set_return_data(
+            array![
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+                21,
+                22,
+                23,
+                24,
+                25,
+                26,
+                27,
+                28,
+                29,
+                30,
+                31,
+                32,
+                33,
+                34,
+                35,
+                36
+            ]
+        );
+
+    let return_data: Span<u8> = ctx.return_data();
+
+    if (size == 0) {
+        size = return_data.len() - offset;
+    }
+
+    ctx.stack.push(size.into());
+    ctx.stack.push(offset.into());
+    ctx.stack.push(dest_offset.into());
+
+    // When
+    let res = ctx.exec_returndatacopy();
+
+    // Then
+    assert(ctx.stack.is_empty(), 'stack should be empty');
+
+    match u32_overflowing_add(offset, size) {
+        Result::Ok(x) => {
+            if (x > return_data.len()) {
+                assert(
+                    res.unwrap_err() == EVMError::ReturnDataError(RETURNDATA_OUT_OF_BOUNDS_ERROR),
+                    'should return out of bounds'
+                );
+                return;
+            }
+        },
+        Result::Err(x) => {
+            assert(
+                res.unwrap_err() == EVMError::ReturnDataError(RETURNDATA_OUT_OF_BOUNDS_ERROR),
+                'should return out of bounds'
+            );
+            return;
+        }
+    }
+
+    let result: u256 = ctx.memory.load_internal(dest_offset).into();
+    let mut results: Array<u8> = ArrayTrait::new();
+
+    let mut i = 0;
+    loop {
+        if i == (size / 32) + 1 {
+            break;
+        }
+
+        let result: u256 = ctx.memory.load_internal(dest_offset + (i * 32)).into();
+        let result_span = u256_to_bytes_array(result).span();
+
+        if ((i + 1) * 32 > size) {
+            ArrayExtensionTrait::concat(ref results, result_span.slice(0, size - (i * 32)));
+        } else {
+            ArrayExtensionTrait::concat(ref results, result_span);
+        }
+
+        i += 1;
+    };
+    assert(results.span() == return_data.slice(offset, size), 'wrong data value');
+}

crates/utils/src/helpers.cairo

@@ -7,6 +7,7 @@ use starknet::{EthAddress, EthAddressIntoFelt252};
 use cmp::min;
 use utils::constants;
 
+
 /// Ceils a number of bits to the next word (32 bytes)
 ///
 /// # Arguments