feat: A0-A4 - LOG0-4 Opcode

crates/evm/src/errors.cairo

@@ -14,12 +14,16 @@ const TYPE_CONVERSION_ERROR: felt252 = 'Kakarot: type conversion error';
 // RETURNDATA
 const RETURNDATA_OUT_OF_BOUNDS_ERROR: felt252 = 'Kakarot: ReturnDataOutOfBounds';
 
+// EVM STATE
+const STATE_MODIFICATION_ERROR: felt252 = 'Kakarot: StateModificationError';
+
 #[derive(Drop, Copy, PartialEq)]
 enum EVMError {
     StackError: felt252,
     InvalidProgramCounter: felt252,
     TypeConversionError: felt252,
-    ReturnDataError: felt252
+    ReturnDataError: felt252,
+    StateModificationError: felt252
 }
 
 
@@ -30,6 +34,7 @@ impl EVMErrorIntoU256 of Into<EVMError, u256> {
             EVMError::InvalidProgramCounter(error_message) => error_message.into(),
             EVMError::TypeConversionError(error_message) => error_message.into(),
             EVMError::ReturnDataError(error_message) => error_message.into(),
+            EVMError::StateModificationError(error_message) => error_message.into(),
         }
     }
 }

crates/evm/src/instructions.cairo

@@ -14,6 +14,7 @@ use environmental_information::EnvironmentInformationTrait;
 mod exchange_operations;
 
 mod logging_operations;
+use logging_operations::LoggingOperationsTrait;
 
 mod memory_operations;
 use memory_operations::MemoryOperationTrait;

crates/evm/src/instructions/logging_operations.cairo

@@ -2,49 +2,115 @@
 
 // Internal imports
 use evm::context::ExecutionContext;
-use evm::context::ExecutionContextTrait;
+use evm::errors::EVMError;
 
 mod internal {
-    use evm::context::ExecutionContext;
-    use evm::context::ExecutionContextTrait;
+    use evm::context::{ExecutionContext, ExecutionContextTrait, BoxDynamicExecutionContextDestruct};
+    use evm::stack::StackTrait;
+    use evm::memory::MemoryTrait;
+    use evm::model::Event;
+    use evm::errors::{EVMError, STATE_MODIFICATION_ERROR};
+    use evm::helpers::U256IntoResultU32;
+    use utils::helpers::u256_to_bytes_array;
 
     /// Generic logging operation.
     /// Append log record with n topics.
-    fn exec_log_i(ref context: ExecutionContext, topics_len: u8) {}
-}
+    fn exec_log_i(ref self: ExecutionContext, topics_len: u8) -> Result<(), EVMError> {
+        // Revert if the transaction is in a read only context
+        if self.read_only() {
+            return Result::Err(EVMError::StateModificationError(STATE_MODIFICATION_ERROR));
+        }
 
-/// 0xA0 - LOG0 operation
-/// Append log record with no topic.
-/// # Specification: https://www.evm.codes/#a0?fork=shanghai
-fn exec_log0(ref context: ExecutionContext) {
-    internal::exec_log_i(ref context, 0);
-}
+        let popped = self.stack.pop_n(2 + topics_len.into())?;
+        let offset: u32 = Into::<u256, Result<u32, EVMError>>::into(*popped[0])?;
+        let size: u32 = Into::<u256, Result<u32, EVMError>>::into(*popped[1])?;
 
+        // Feed topics array for the new event
+        let mut topics: Array<u256> = Default::default();
+        let mut i = 0;
+        loop {
+            if i == topics_len {
+                break;
+            }
+            topics.append(*popped[2 + i.into()]);
 
-/// 0xA1 - LOG1 
-/// Append log record with one topic.
-/// # Specification: https://www.evm.codes/#a1?fork=shanghai
-fn exec_log1(ref context: ExecutionContext) {
-    internal::exec_log_i(ref context, 1);
-}
+            i += 1;
+        };
 
-/// 0xA2 - LOG2 
-/// Append log record with two topics.
-/// # Specification: https://www.evm.codes/#a2?fork=shanghai
-fn exec_log2(ref context: ExecutionContext) {
-    internal::exec_log_i(ref context, 2);
-}
+        // Feed data array for the new event
+        let mut datas: Array<felt252> = Default::default();
+        let mut i = 0;
+        loop {
+            if 31 + i > size {
+                if i != size {
+                    let (mut loaded, _) = self.memory.load(offset + i);
+                    let mut chunk: Array<u8> = u256_to_bytes_array(loaded);
+                    let mut last_elem = 0;
+                    let mut j = 0;
+                    loop {
+                        if j + i == size {
+                            break;
+                        }
+                        last_elem *= 256;
+                        last_elem += (*chunk[j]).into();
+                        j += 1;
+                    };
+                    datas.append(last_elem);
+                }
+                break;
+            };
+            let (mut loaded, _) = self.memory.load(offset + i);
+            loaded /= 256;
+            datas.append(loaded.try_into().unwrap());
+            i += 31;
+        };
+
+        // Create and store the new event in the dynamic context
+        let event: Event = Event { keys: topics, data: datas };
+
+        let mut dyn_ctx = self.dynamic_context.unbox();
+        dyn_ctx.events.append(event);
+        self.dynamic_context = BoxTrait::new(dyn_ctx);
 
-/// 0xA3 - LOG3 
-/// Append log record with three topics.
-/// # Specification: https://www.evm.codes/#a3?fork=shanghai
-fn exec_log3(ref context: ExecutionContext) {
-    internal::exec_log_i(ref context, 3);
+        Result::Ok(())
+    }
 }
 
-/// 0xA4 - LOG4 
-/// Append log record with 4 topics.
-/// # Specification: https://www.evm.codes/#a4?fork=shanghai
-fn exec_log4(ref context: ExecutionContext) {
-    internal::exec_log_i(ref context, 4);
+#[generate_trait]
+impl LoggingOperations of LoggingOperationsTrait {
+    /// 0xA0 - LOG0 operation
+    /// Append log record with no topic.
+    /// # Specification: https://www.evm.codes/#a0?fork=shanghai
+    fn exec_log0(ref self: ExecutionContext) -> Result<(), EVMError> {
+        internal::exec_log_i(ref self, 0)
+    }
+
+
+    /// 0xA1 - LOG1 
+    /// Append log record with one topic.
+    /// # Specification: https://www.evm.codes/#a1?fork=shanghai
+    fn exec_log1(ref self: ExecutionContext) -> Result<(), EVMError> {
+        internal::exec_log_i(ref self, 1)
+    }
+
+    /// 0xA2 - LOG2 
+    /// Append log record with two topics.
+    /// # Specification: https://www.evm.codes/#a2?fork=shanghai
+    fn exec_log2(ref self: ExecutionContext) -> Result<(), EVMError> {
+        internal::exec_log_i(ref self, 2)
+    }
+
+    /// 0xA3 - LOG3 
+    /// Append log record with three topics.
+    /// # Specification: https://www.evm.codes/#a3?fork=shanghai
+    fn exec_log3(ref self: ExecutionContext) -> Result<(), EVMError> {
+        internal::exec_log_i(ref self, 3)
+    }
+
+    /// 0xA4 - LOG4 
+    /// Append log record with 4 topics.
+    /// # Specification: https://www.evm.codes/#a4?fork=shanghai
+    fn exec_log4(ref self: ExecutionContext) -> Result<(), EVMError> {
+        internal::exec_log_i(ref self, 4)
+    }
 }

crates/evm/src/interpreter.cairo

@@ -13,9 +13,10 @@ use utils::{helpers::u256_to_bytes_array};
 use evm::errors::{EVMError, PC_OUT_OF_BOUNDS};
 use evm::instructions::{
     duplication_operations, environmental_information, exchange_operations, logging_operations,
-    memory_operations, sha3, StopAndArithmeticOperationsTrait, ComparisonAndBitwiseOperationsTrait,
-    system_operations, BlockInformationTrait, DuplicationOperationsTrait,
-    EnvironmentInformationTrait, PushOperationsTrait, MemoryOperationTrait
+    LoggingOperationsTrait, memory_operations, sha3, StopAndArithmeticOperationsTrait,
+    ComparisonAndBitwiseOperationsTrait, system_operations, BlockInformationTrait,
+    DuplicationOperationsTrait, EnvironmentInformationTrait, PushOperationsTrait,
+    MemoryOperationTrait
 };
 use result::ResultTrait;
 
@@ -603,23 +604,23 @@ impl EVMInterpreterImpl of EVMInterpreterTrait {
         }
         if opcode == 160 {
             // LOG0
-            logging_operations::exec_log0(ref context);
+            return context.exec_log0();
         }
         if opcode == 161 {
             // LOG1
-            logging_operations::exec_log1(ref context);
+            return context.exec_log1();
         }
         if opcode == 162 {
             // LOG2
-            logging_operations::exec_log2(ref context);
+            return context.exec_log2();
         }
         if opcode == 163 {
             // LOG3
-            logging_operations::exec_log3(ref context);
+            return context.exec_log3();
         }
         if opcode == 164 {
             // LOG4
-            logging_operations::exec_log4(ref context);
+            return context.exec_log4();
         }
         if opcode == 240 {
             // CREATE

crates/evm/src/tests/test_instructions.cairo

@@ -5,3 +5,4 @@ mod test_block_information;
 mod test_environment_information;
 mod test_push_operations;
 mod test_memory_operations;
+mod test_logging_operations;