feat: A0-A4 - LOG0-4 Opcode

crates/evm/src/errors.cairo

@@ -14,6 +14,9 @@ const RETURNDATA_OUT_OF_BOUNDS_ERROR: felt252 = 'KKT: ReturnDataOutOfBounds';
 // JUMP
 const INVALID_DESTINATION: felt252 = 'KKT: invalid JUMP destination';
 
+// EVM STATE
+const STATE_MODIFICATION_ERROR: felt252 = 'KKT: StateModificationError';
+
 #[derive(Drop, Copy, PartialEq)]
 enum EVMError {
     StackError: felt252,
@@ -22,7 +25,8 @@ enum EVMError {
     ReturnDataError: felt252,
     JumpError: felt252,
     NotImplemented,
-    UnknownOpcode: u8
+    UnknownOpcode: u8,
+    StateModificationError: felt252
 }
 
 
@@ -36,7 +40,8 @@ impl EVMErrorIntoU256 of Into<EVMError, u256> {
             EVMError::JumpError(error_message) => error_message.into(),
             EVMError::NotImplemented => 'NotImplemented'.into(),
             // TODO: refactor with dynamic strings once supported
-            EVMError::UnknownOpcode => 'UnknownOpcode'.into()
+            EVMError::UnknownOpcode => 'UnknownOpcode'.into(),
+            EVMError::StateModificationError(error_message) => error_message.into(),
         }
     }
 }

crates/evm/src/instructions.cairo

@@ -17,6 +17,7 @@ use comparison_operations::ComparisonAndBitwiseOperationsTrait;
 use duplication_operations::DuplicationOperationsTrait;
 use environmental_information::EnvironmentInformationTrait;
 use exchange_operations::ExchangeOperationsTrait;
+use logging_operations::LoggingOperationsTrait;
 use memory_operations::MemoryOperationTrait;
 use push_operations::PushOperationsTrait;
 use sha3::Sha3Trait;

crates/evm/src/instructions/logging_operations.cairo

@@ -1,48 +1,77 @@
+use evm::errors::EVMError;
 //! Logging Operations.
 
 // Internal imports
 use evm::machine::Machine;
 
-mod internal {
-    use evm::machine::Machine;
+#[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: Machine) -> Result<(), EVMError> {
+        internal::exec_log_i(ref self, 0)
+    }
 
-    /// Generic logging operation.
-    /// Append log record with n topics.
-    fn exec_log_i(ref machine: Machine, topics_len: u8) {}
-}
+    /// 0xA1 - LOG1 
+    /// Append log record with one topic.
+    /// # Specification: https://www.evm.codes/#a1?fork=shanghai
+    fn exec_log1(ref self: Machine) -> Result<(), EVMError> {
+        internal::exec_log_i(ref self, 1)
+    }
 
-/// 0xA0 - LOG0 operation
-/// Append log record with no topic.
-/// # Specification: https://www.evm.codes/#a0?fork=shanghai
-fn exec_log0(ref machine: Machine) {
-    internal::exec_log_i(ref machine, 0);
-}
+    /// 0xA2 - LOG2 
+    /// Append log record with two topics.
+    /// # Specification: https://www.evm.codes/#a2?fork=shanghai
+    fn exec_log2(ref self: Machine) -> 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: Machine) -> Result<(), EVMError> {
+        internal::exec_log_i(ref self, 3)
+    }
 
-/// 0xA1 - LOG1
-/// Append log record with one topic.
-/// # Specification: https://www.evm.codes/#a1?fork=shanghai
-fn exec_log1(ref machine: Machine) {
-    internal::exec_log_i(ref machine, 1);
+    /// 0xA4 - LOG4 
+    /// Append log record with four topics.
+    /// # Specification: https://www.evm.codes/#a4?fork=shanghai
+    fn exec_log4(ref self: Machine) -> Result<(), EVMError> {
+        internal::exec_log_i(ref self, 4)
+    }
 }
 
-/// 0xA2 - LOG2
-/// Append log record with two topics.
-/// # Specification: https://www.evm.codes/#a2?fork=shanghai
-fn exec_log2(ref machine: Machine) {
-    internal::exec_log_i(ref machine, 2);
-}
+mod internal {
+    use evm::errors::{EVMError, STATE_MODIFICATION_ERROR};
+    use evm::machine::{Machine, MachineCurrentContextTrait};
+    use evm::memory::MemoryTrait;
+    use evm::model::Event;
+    use evm::stack::StackTrait;
 
-/// 0xA3 - LOG3
-/// Append log record with three topics.
-/// # Specification: https://www.evm.codes/#a3?fork=shanghai
-fn exec_log3(ref machine: Machine) {
-    internal::exec_log_i(ref machine, 3);
-}
+    /// Store a new event in the dynamic context using topics
+    /// popped from the stack and data from the memory.
+    ///
+    /// # Arguments
+    ///
+    /// * `self` - The context to which the event will be added
+    /// * `topics_len` - The amount of topics to pop from the stack
+    fn exec_log_i(ref self: Machine, 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));
+        }
+
+        let offset = self.stack.pop_usize()?;
+        let size = self.stack.pop_usize()?;
+        let topics: Array<u256> = self.stack.pop_n(topics_len.into())?;
+
+        let mut data: Array<u8> = Default::default();
+        self.memory.load_n(size, ref data, offset);
+
+        let event: Event = Event { keys: topics, data };
+        self.append_event(event);
 
-/// 0xA4 - LOG4
-/// Append log record with 4 topics.
-/// # Specification: https://www.evm.codes/#a4?fork=shanghai
-fn exec_log4(ref machine: Machine) {
-    internal::exec_log_i(ref machine, 4);
+        Result::Ok(())
+    }
 }

crates/evm/src/interpreter.cairo

@@ -4,9 +4,11 @@
 use evm::context::{CallContextTrait,};
 use evm::errors::{EVMError, PC_OUT_OF_BOUNDS};
 use evm::instructions::{
-    ExchangeOperationsTrait, StopAndArithmeticOperationsTrait, ComparisonAndBitwiseOperationsTrait,
-    SystemOperationsTrait, BlockInformationTrait, DuplicationOperationsTrait,
-    EnvironmentInformationTrait, PushOperationsTrait, MemoryOperationTrait, logging_operations
+    duplication_operations, environmental_information, ExchangeOperationsTrait, logging_operations,
+    LoggingOperationsTrait, memory_operations, sha3, StopAndArithmeticOperationsTrait,
+    ComparisonAndBitwiseOperationsTrait, SystemOperationsTrait, BlockInformationTrait,
+    DuplicationOperationsTrait, EnvironmentInformationTrait, PushOperationsTrait,
+    MemoryOperationTrait
 };
 use evm::machine::{Machine, MachineCurrentContextTrait};
 use utils::{helpers::u256_to_bytes_array};
@@ -586,23 +588,23 @@ impl EVMInterpreterImpl of EVMInterpreterTrait {
         }
         if opcode == 160 {
             // LOG0
-            logging_operations::exec_log0(ref machine);
+            return machine.exec_log0();
         }
         if opcode == 161 {
             // LOG1
-            logging_operations::exec_log1(ref machine);
+            return machine.exec_log1();
         }
         if opcode == 162 {
             // LOG2
-            logging_operations::exec_log2(ref machine);
+            return machine.exec_log2();
         }
         if opcode == 163 {
             // LOG3
-            logging_operations::exec_log3(ref machine);
+            return machine.exec_log3();
         }
         if opcode == 164 {
             // LOG4
-            logging_operations::exec_log4(ref machine);
+            return machine.exec_log4();
         }
         if opcode == 240 {
             // CREATE

crates/evm/src/machine.cairo

@@ -189,6 +189,22 @@ impl MachineCurrentContextImpl of MachineCurrentContextTrait {
         current_call_ctx.read_only()
     }
 
+    #[inline(always)]
+    fn set_read_only(ref self: Machine, value: bool) {
+        let mut current_call_ctx = self.call_context();
+        let mut current_execution_ctx = self.current_context.unbox();
+        current_call_ctx.read_only = value;
+        current_execution_ctx.call_context = BoxTrait::new(current_call_ctx);
+        self.current_context = BoxTrait::new(current_execution_ctx);
+    }
+
+    #[inline(always)]
+    fn append_event(ref self: Machine, event: Event) {
+        let mut current_execution_ctx = self.current_context.unbox();
+        current_execution_ctx.events.append(event);
+        self.current_context = BoxTrait::new(current_execution_ctx);
+    }
+
     #[inline(always)]
     fn gas_limit(ref self: Machine) -> u64 {
         let current_call_ctx = self.call_context();

crates/evm/src/model.cairo

@@ -1,5 +1,5 @@
 #[derive(Drop)]
 struct Event {
     keys: Array<u256>,
-    data: Array<felt252>,
+    data: Array<u8>,
 }

crates/evm/src/tests/test_instructions.cairo

@@ -3,6 +3,7 @@ mod test_comparison_operations;
 mod test_duplication_operations;
 mod test_environment_information;
 mod test_exchange_operations;
+mod test_logging_operations;
 mod test_memory_operations;
 mod test_push_operations;
 mod test_sha3;