Consistently handle log topics and data ownership (#8)

* consistently handle log topics and data deinit() throughout.  fixes some broken spec tests in zevm-stateless

Signed-off-by: garyschulte <garyschulte@gmail.com>

Author: garyschulte

src/context/journal.zig

@@ -397,12 +397,7 @@ pub const JournalInner = struct {
     pub fn deinit(self: *JournalInner) void {
         self.evm_state.deinit();
         self.transient_storage.deinit();
-        // Free heap-allocated topic slices before freeing the log list
-        for (self.logs.items) |log| {
-            if (log.topics.len > 0) {
-                alloc_mod.get().free(@constCast(log.topics));
-            }
-        }
+        for (self.logs.items) |log| log.deinit(alloc_mod.get());
         self.logs.deinit(alloc_mod.get());
         self.journal.deinit(alloc_mod.get());
         self.warm_addresses.deinit();
@@ -441,12 +436,8 @@ pub const JournalInner = struct {
         self.journal.clearRetainingCapacity();
         self.warm_addresses.clearCoinbaseAndAccessList();
         self.transaction_id += 1;
-        // Free heap-allocated topic slices (in case takeLogs() was not called)
-        for (self.logs.items) |log| {
-            if (log.topics.len > 0) {
-                alloc_mod.get().free(@constCast(log.topics));
-            }
-        }
+        // Free heap-allocated data/topics (in case takeLogs() was not called — e.g. failed tx)
+        for (self.logs.items) |log| log.deinit(alloc_mod.get());
         self.logs.clearRetainingCapacity();
     }
 
@@ -463,12 +454,8 @@ pub const JournalInner = struct {
         }
 
         self.transient_storage.clearRetainingCapacity();
-        // Free heap-allocated topic slices before clearing the log list
-        for (self.logs.items) |log| {
-            if (log.topics.len > 0) {
-                alloc_mod.get().free(@constCast(log.topics));
-            }
-        }
+        // Free heap-allocated data/topics before clearing the log list
+        for (self.logs.items) |log| log.deinit(alloc_mod.get());
         self.logs.clearRetainingCapacity();
         self.transaction_id += 1;
         self.warm_addresses.clearCoinbaseAndAccessList();
@@ -483,12 +470,7 @@ pub const JournalInner = struct {
 
         const evm_state = self.evm_state;
         self.evm_state = state.EvmState.init(alloc_mod.get());
-        // Free heap-allocated topic slices before clearing the log list.
-        for (self.logs.items) |log| {
-            if (log.topics.len > 0) {
-                alloc_mod.get().free(@constCast(log.topics));
-            }
-        }
+        for (self.logs.items) |log| log.deinit(alloc_mod.get());
         self.logs.clearRetainingCapacity();
         self.transient_storage.clearRetainingCapacity();
         self.journal.clearRetainingCapacity();
@@ -722,6 +704,8 @@ pub const JournalInner = struct {
     /// Reverts all changes to evm_state until given checkpoint.
     pub fn checkpointRevert(self: *JournalInner, checkpoint: JournalCheckpoint) void {
         const is_spurious_dragon_enabled = primitives.isEnabledIn(self.spec, .spurious_dragon);
+        // Free heap-allocated data/topics of logs being discarded by this revert.
+        for (self.logs.items[checkpoint.log_i..]) |log| log.deinit(alloc_mod.get());
         self.logs.shrinkRetainingCapacity(checkpoint.log_i);
 
         // iterate over last N journals sets and revert our global evm_state

src/handler/main.zig

@@ -60,12 +60,7 @@ pub const ExecutionResult = struct {
 
     /// Deinitialize execution result
     pub fn deinit(self: *ExecutionResult) void {
-        // Free topic slices (heap-allocated via page_allocator by the journal's LOG opcodes).
-        for (self.logs.items) |log| {
-            if (log.topics.len > 0) {
-                alloc_mod.get().free(@constCast(log.topics));
-            }
-        }
+        for (self.logs.items) |log| log.deinit(alloc_mod.get());
         self.logs.deinit(alloc_mod.get());
         // Free heap-allocated return data copy (len==0 means static empty slice, skip).
         if (self.return_data.len > 0) {

src/interpreter/opcodes/host_ops.zig

@@ -516,12 +516,19 @@ pub fn makeLogFn(comptime n: u8) *const fn (ctx: *InstructionContext) void {
 
             stack.shrinkUnsafe(2 + n);
 
-            // Get log data from memory (offset_u + size_u is safe; expandMemory verified it above)
+            // Get log data from memory — copy to heap so the data outlives the interpreter.
+            // The interpreter's memory buffer is freed when executeIterative returns (via defer),
+            // but log entries must remain valid until postExecution reads them from the journal.
             const log_end = offset_u + size_u; // won't overflow: expandMemory already checked this
-            const log_data: []const u8 = if (size_u > 0)
-                ctx.interpreter.memory.buffer.items[offset_u..log_end]
-            else
-                &[_]u8{};
+            const log_data: []const u8 = if (size_u > 0) blk: {
+                const src = ctx.interpreter.memory.buffer.items[offset_u..log_end];
+                const copy = alloc_mod.get().dupe(u8, src) catch {
+                    if (comptime n > 0) alloc_mod.get().free(topics);
+                    ctx.interpreter.halt(.out_of_gas);
+                    return;
+                };
+                break :blk copy;
+            } else &[_]u8{};
 
             // Emit the log
             const log_entry = primitives.Log{

src/primitives/main.zig

@@ -26,11 +26,22 @@ pub const StorageValue = U256;
 /// Type alias for byte arrays
 pub const Bytes = []u8;
 
-/// Log entry for EVM events
+/// Log entry for EVM events.
+///
+/// `data` and `topics` are heap-allocated (via the zevm_allocator) when non-empty,
+/// and must be freed with `deinit`. Zero-length slices use static empty literals and
+/// must NOT be freed.
 pub const Log = struct {
     address: Address,
     topics: []const Hash,
     data: []const u8,
+
+    /// Free heap-allocated data and topics. Safe to call on zero-length fields
+    /// because the LOG opcode uses static empty literals for those cases.
+    pub fn deinit(self: Log, alloc: std.mem.Allocator) void {
+        if (self.data.len > 0) alloc.free(@constCast(self.data));
+        if (self.topics.len > 0) alloc.free(@constCast(self.topics));
+    }
 };
 
 /// Optimize short address access.