compare all bytes in tests + inlined app_event

crates/evm/src/context.cairo

@@ -358,6 +358,7 @@ impl ExecutionContextImpl of ExecutionContextTrait {
     ///
     /// * `self` - The context to which the event will be added
     /// * `event` - Event to append
+    #[inline(always)]
     fn append_event(ref self: ExecutionContext, event: Event) {
         let mut dyn_ctx = self.dynamic_context.unbox();
         dyn_ctx.events.append(event);

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

@@ -7,6 +7,7 @@ use evm::tests::test_utils::setup_execution_context;
 use evm::errors::{EVMError, STATE_MODIFICATION_ERROR};
 use evm::instructions::LoggingOperationsTrait;
 use integer::BoundedInt;
+use utils::helpers::u256_to_bytes_array;
 
 #[test]
 #[available_gas(20000000)]
@@ -31,10 +32,10 @@ fn test_exec_log0() {
 
     let event = events.pop_front().unwrap();
     assert(event.keys.len() == 0, 'event should not have keys');
+
     assert(event.data.len() == 31, 'event should have 31 bytes');
-    assert(*event.data[0] == 0xff, 'event byte should be max_u8');
-    assert(*event.data[15] == 0xff, 'event byte should be max_u8');
-    assert(*event.data[30] == 0xff, 'event byte should be max_u8');
+    let data_expected = u256_to_bytes_array(BoundedInt::<u256>::max()).span().slice(0, 31);
+    assert(event.data.span() == data_expected, 'event data are incorrect');
 }
 
 #[test]
@@ -62,10 +63,10 @@ fn test_exec_log1() {
     let event = events.pop_front().unwrap();
     assert(event.keys.len() == 1, 'event should have one key');
     assert(*event.keys[0] == 0x0123456789ABCDEF, 'event key is not correct');
+
     assert(event.data.len() == 32, 'event should have 32 bytes');
-    assert(*event.data[0] == 0xff, 'event byte should be max_u8');
-    assert(*event.data[15] == 0xff, 'event byte should be max_u8');
-    assert(*event.data[31] == 0xff, 'event byte should be max_u8');
+    let data_expected = u256_to_bytes_array(BoundedInt::<u256>::max()).span().slice(0, 32);
+    assert(event.data.span() == data_expected, 'event data are incorrect');
 }
 
 #[test]
@@ -95,9 +96,10 @@ fn test_exec_log2() {
     assert(event.keys.len() == 2, 'event should have two keys');
     assert(*event.keys[0] == 0x0123456789ABCDEF, 'event key is not correct');
     assert(*event.keys[1] == BoundedInt::<u256>::max(), 'event key is not correct');
+
     assert(event.data.len() == 5, 'event should have 5 bytes');
-    assert(*event.data[0] == 0xff, 'event byte should be max_u8');
-    assert(*event.data[4] == 0xff, 'event byte should be max_u8');
+    let data_expected = u256_to_bytes_array(BoundedInt::<u256>::max()).span().slice(0, 5);
+    assert(event.data.span() == data_expected, 'event data are incorrect');
 }
 
 #[test]
@@ -132,9 +134,14 @@ fn test_exec_log3() {
     assert(*event.keys[2] == 0x00, 'event key is not correct');
 
     assert(event.data.len() == 40, 'event should have 40 bytes');
-    assert(*event.data[0] == 0xff, 'event byte should be max_u8');
-    assert(*event.data[4] == 0xff, 'event byte should be max_u8');
-    assert(*event.data[39] == 0xef, 'event byte should be 0xEF');
+    let data_expected = u256_to_bytes_array(BoundedInt::<u256>::max()).span().slice(0, 32);
+    assert(event.data.span().slice(0, 32) == data_expected, 'event data are incorrect');
+    let data_expected = u256_to_bytes_array(
+        0x0123456789ABCDEF000000000000000000000000000000000000000000000000
+    )
+        .span()
+        .slice(0, 8);
+    assert(event.data.span().slice(32, 8) == data_expected, 'event data are incorrect');
 }
 
 #[test]
@@ -164,16 +171,19 @@ fn test_exec_log4() {
     assert(events.len() == 1, 'context should have one event');
 
     let event = events.pop_front().unwrap();
-    assert(event.keys.len() == 4, 'event2 should have 4 keys');
-    assert(*event.keys[0] == 0x0123456789ABCDEF, 'event2 key is not correct');
-    assert(*event.keys[1] == BoundedInt::<u256>::max(), 'event2 key is not correct');
-    assert(*event.keys[2] == 0x00, 'event2 key is not correct');
-    assert(*event.keys[3] == BoundedInt::<u256>::max(), 'event2 key is not correct');
-
-    assert(event.data.len() == 10, 'event2 should have 10 bytes');
-    assert(*event.data[0] == 0x01, 'event2 byte should be 0x01');
-    assert(*event.data[5] == 0xAB, 'event2 byte should be 0xAB');
-    assert(*event.data[9] == 0x00, 'event2 byte should be 0x00');
+    assert(event.keys.len() == 4, 'event should have 4 keys');
+    assert(*event.keys[0] == 0x0123456789ABCDEF, 'event key is not correct');
+    assert(*event.keys[1] == BoundedInt::<u256>::max(), 'event key is not correct');
+    assert(*event.keys[2] == 0x00, 'event key is not correct');
+    assert(*event.keys[3] == BoundedInt::<u256>::max(), 'event key is not correct');
+
+    assert(event.data.len() == 10, 'event should have 10 bytes');
+    let data_expected = u256_to_bytes_array(
+        0x0123456789ABCDEF000000000000000000000000000000000000000000000000
+    )
+        .span()
+        .slice(0, 10);
+    assert(event.data.span() == data_expected, 'event data are incorrect');
 }
 
 #[test]
@@ -239,9 +249,14 @@ fn test_exec_log_multiple_events() {
     assert(*event1.keys[2] == 0x00, 'event1 key is not correct');
 
     assert(event1.data.len() == 40, 'event1 should have 40 bytes');
-    assert(*event1.data[0] == 0xff, 'event1 byte should be max_u8');
-    assert(*event1.data[4] == 0xff, 'event1 byte should be max_u8');
-    assert(*event1.data[39] == 0xef, 'event1 byte should be 0xEF');
+    let data_expected = u256_to_bytes_array(BoundedInt::<u256>::max()).span().slice(0, 32);
+    assert(event1.data.span().slice(0, 32) == data_expected, 'event1 data are incorrect');
+    let data_expected = u256_to_bytes_array(
+        0x0123456789ABCDEF000000000000000000000000000000000000000000000000
+    )
+        .span()
+        .slice(0, 8);
+    assert(event1.data.span().slice(32, 8) == data_expected, 'event1 data are incorrect');
 
     let event2 = events.pop_front().unwrap();
     assert(event2.keys.len() == 4, 'event2 should have 4 keys');
@@ -251,7 +266,10 @@ fn test_exec_log_multiple_events() {
     assert(*event2.keys[3] == BoundedInt::<u256>::max(), 'event2 key is not correct');
 
     assert(event2.data.len() == 10, 'event2 should have 10 bytes');
-    assert(*event2.data[0] == 0x01, 'event2 byte should be 0x01');
-    assert(*event2.data[5] == 0xAB, 'event2 byte should be 0xAB');
-    assert(*event2.data[9] == 0x00, 'event2 byte should be 0x00');
+    let data_expected = u256_to_bytes_array(
+        0x0123456789ABCDEF000000000000000000000000000000000000000000000000
+    )
+        .span()
+        .slice(0, 10);
+    assert(event2.data.span() == data_expected, 'event2 data are incorrect');
 }