Task: clean-up and de-duplicate code (#90)

* deduplicate and fix bug in one of the memory expansion gas formulas
removed the now vestigial MemoryGas struct in gas.zig
deduplicate runSystemCall, runSystemCallCapture, applying fix in runSystemCall from #81 to runSystemCallCapture also
deduplicate signingHash, txHash
* fix overflow potential in memory.expandWithGas

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

Author: garyschulte

src/evm/interpreter/gas.zig

@@ -28,8 +28,6 @@ pub const Gas = struct {
     /// amount, matching the reference (vm charge_state_gas / credit_state_gas_refund), so a
     /// spilled-then-refunded charge restores regular gas for subsequent 63/64 forwarding.
     state_gas_spilled: u64 = 0,
-    /// Memoisation of values for memory expansion cost.
-    memory: MemoryGas,
 
     /// Creates a new `Gas` struct with the given gas limit.
     pub fn new(limit: u64) Gas {
@@ -41,7 +39,6 @@ pub const Gas = struct {
             .reservoir = 0,
             .state_gas_spent = 0,
             .state_gas_refunded = 0,
-            .memory = MemoryGas.new(),
         };
     }
 
@@ -55,7 +52,6 @@ pub const Gas = struct {
             .reservoir = 0,
             .state_gas_spent = 0,
             .state_gas_refunded = 0,
-            .memory = MemoryGas.new(),
         };
     }
 
@@ -64,16 +60,6 @@ pub const Gas = struct {
         return self.limit;
     }
 
-    /// Returns the memory gas.
-    pub fn getMemory(self: Gas) MemoryGas {
-        return self.memory;
-    }
-
-    /// Returns the memory gas mutably.
-    pub fn getMemoryMut(self: *Gas) *MemoryGas {
-        return &self.memory;
-    }
-
     /// Returns the total amount of gas that was refunded.
     pub fn getRefunded(self: Gas) i64 {
         return self.refunded;
@@ -192,32 +178,6 @@ pub const Gas = struct {
         self.refunded = refund_amount;
     }
 
-    /// Load gas with memory
-    pub fn loadGasWithMemory(self: *Gas, amount: u64, memory: MemoryGas) void {
-        self.remaining = amount;
-        self.memory = memory;
-    }
-
-    /// Load gas with memory and refund
-    pub fn loadGasWithMemoryAndRefund(self: *Gas, amount: u64, memory: MemoryGas, refund_amount: i64) void {
-        self.remaining = amount;
-        self.memory = memory;
-        self.refunded = refund_amount;
-    }
-
-    /// Load gas with limit and memory
-    pub fn loadGasWithLimitAndMemory(self: *Gas, amount: u64, limit: u64, memory: MemoryGas) void {
-        self.remaining = @min(amount, limit);
-        self.memory = memory;
-    }
-
-    /// Load gas with limit, memory and refund
-    pub fn loadGasWithLimitMemoryAndRefund(self: *Gas, amount: u64, limit: u64, memory: MemoryGas, refund_amount: i64) void {
-        self.remaining = @min(amount, limit);
-        self.memory = memory;
-        self.refunded = refund_amount;
-    }
-
     /// Apply EIP-3529 refund cap in-place.
     /// Pre-London: cap at gas_spent / 2. London+: cap at gas_spent / 5.
     pub fn setFinalRefund(self: *Gas, is_london: bool) void {
@@ -234,63 +194,3 @@ pub const Gas = struct {
         return if (spent > ref) spent - ref else 0;
     }
 };
-
-/// Memory gas tracking for memory expansion costs
-pub const MemoryGas = struct {
-    /// The current memory size in words
-    size: u64,
-    /// The maximum memory size reached during execution
-    max_size: u64,
-
-    pub fn new() MemoryGas {
-        return MemoryGas{
-            .size = 0,
-            .max_size = 0,
-        };
-    }
-
-    /// Get the current memory size in words
-    pub fn getSize(self: MemoryGas) u64 {
-        return self.size;
-    }
-
-    /// Get the maximum memory size reached
-    pub fn maxSize(self: MemoryGas) u64 {
-        return self.max_size;
-    }
-
-    /// Set the memory size
-    pub fn setSize(self: *MemoryGas, size: u64) void {
-        self.size = size;
-        self.max_size = @max(self.max_size, size);
-    }
-
-    /// Calculate memory expansion cost
-    pub fn expansionCost(self: MemoryGas, new_size: u64) u64 {
-        if (new_size <= self.size) {
-            return 0;
-        }
-
-        // std.math.divCeil(u64, n, 32) avoids (n + 31) overflow for large n.
-        const new_words = std.math.divCeil(u64, new_size, 32) catch return std.math.maxInt(u64);
-        const current_words = std.math.divCeil(u64, self.size, 32) catch return std.math.maxInt(u64);
-
-        if (new_words <= current_words) {
-            return 0;
-        }
-
-        const sq_new = std.math.mul(u64, new_words, new_words) catch return std.math.maxInt(u64);
-        const cost = std.math.add(u64, sq_new / 512, 3 * new_words) catch return std.math.maxInt(u64);
-        const sq_cur = std.math.mul(u64, current_words, current_words) catch return std.math.maxInt(u64);
-        const current_cost = std.math.add(u64, sq_cur / 512, 3 * current_words) catch return std.math.maxInt(u64);
-
-        return cost - current_cost;
-    }
-
-    /// Record memory expansion
-    pub fn recordExpansion(self: *MemoryGas, new_size: u64) u64 {
-        const cost = self.expansionCost(new_size);
-        self.setSize(new_size);
-        return cost;
-    }
-};

src/evm/interpreter/gas_costs.zig

@@ -134,9 +134,11 @@ fn memoryCost(num_words: usize) u64 {
     return std.math.add(u64, linear, quadratic) catch std.math.maxInt(u64);
 }
 
-// Calculate memory size in words (rounded up)
+// Calculate memory size in words (rounded up).
+// Uses divCeil rather than (size + 31) / 32: a huge size must saturate, not
+// overflow-panic, on the intermediate +31.
 pub fn toWordSize(size: usize) usize {
-    return (size + 31) / 32;
+    return std.math.divCeil(usize, size, 32) catch std.math.maxInt(usize);
 }
 
 // Get SLOAD gas cost based on spec and cold/warm access

src/evm/interpreter/instruction_context.zig

@@ -16,3 +16,10 @@ pub const InstructionContext = struct {
 
 /// Function pointer type for all opcode handlers.
 pub const InstructionFn = *const fn (ctx: *InstructionContext) void;
+
+/// Shared memory-expansion helper for opcode handlers: grows memory to `new_size`
+/// bytes, charging the expansion gas cost. Returns false (OOG) without mutating
+/// memory if gas or the resize fails.
+pub fn expandMemory(ctx: *InstructionContext, new_size: usize) bool {
+    return ctx.interpreter.memory.expandWithGas(&ctx.interpreter.gas, new_size);
+}

src/evm/interpreter/memory.zig

@@ -1,6 +1,8 @@
 const std = @import("std");
 const primitives = @import("primitives");
 const alloc_mod = @import("zesu_allocator");
+const gas_costs = @import("gas_costs.zig");
+const Gas = @import("gas.zig").Gas;
 
 /// EVM memory implementation using a shared buffer
 pub const Memory = struct {
@@ -278,28 +280,41 @@ pub const Memory = struct {
         try self.set(offset, &[_]u8{byte});
     }
 
-    /// Calculate memory expansion cost
+    /// Calculate memory expansion cost. Single source of truth for the
+    /// `3*words + words^2/512` formula lives in gas_costs.memoryExpansionCost;
+    /// this just converts the byte sizes involved to word counts.
     pub fn expansionCost(self: Memory, new_size: usize) u64 {
         if (new_size <= self.buffer.items.len) {
             return 0;
         }
+        return gas_costs.memoryExpansionCost(
+            gas_costs.toWordSize(self.buffer.items.len),
+            gas_costs.toWordSize(new_size),
+        );
+    }
 
-        // std.math.divCeil avoids (n + 31) overflow when n is near maxInt(usize).
-        const new_words = std.math.divCeil(usize, new_size, 32) catch return std.math.maxInt(u64);
-        const current_words = std.math.divCeil(usize, self.buffer.items.len, 32) catch return std.math.maxInt(u64);
-
-        if (new_words <= current_words) {
-            return 0;
-        }
-
-        const n: u64 = @intCast(new_words);
-        const c: u64 = @intCast(current_words);
-        const sq_n = std.math.mul(u64, n, n) catch return std.math.maxInt(u64);
-        const cost = std.math.add(u64, sq_n / 512, 3 * n) catch return std.math.maxInt(u64);
-        const sq_c = std.math.mul(u64, c, c) catch return std.math.maxInt(u64);
-        const current_cost = std.math.add(u64, sq_c / 512, 3 * c) catch return std.math.maxInt(u64);
-
-        return cost - current_cost;
+    /// Grow memory to at least `new_size` bytes, charging the expansion cost against
+    /// `gas`. Returns false if `gas` can't cover the cost, if rounding `new_size` up to
+    /// a 32-byte boundary would overflow, or if the resize fails. Note gas charged via
+    /// `spend` is not refunded on a later failure — this is consistent with EVM
+    /// out-of-gas semantics (a frame that fails to expand memory halts and forfeits its
+    /// remaining gas regardless).
+    /// New bytes are zero-initialized per EVM memory semantics.
+    pub fn expandWithGas(self: *Memory, gas: *Gas, new_size: usize) bool {
+        if (new_size == 0 or new_size <= self.buffer.items.len) return true;
+
+        const cost = self.expansionCost(new_size);
+        if (!gas.spend(cost)) return false;
+
+        // Checked: toWordSize used in expansionCost saturates rather than overflow-panics
+        // on huge new_size, so the round-trip back to an aligned byte size must be
+        // checked separately — words*32 can still exceed usize
+        const new_words = std.math.divCeil(usize, new_size, 32) catch return false;
+        const aligned_size = std.math.mul(usize, new_words, 32) catch return false;
+        const old_size = self.buffer.items.len;
+        self.buffer.resize(alloc_mod.get(), aligned_size) catch return false;
+        @memset(self.buffer.items[old_size..aligned_size], 0);
+        return true;
     }
 
     /// Resize memory to a new size

src/evm/interpreter/opcodes/call.zig

@@ -1,9 +1,10 @@
 const std = @import("std");
 const primitives = @import("primitives");
-const InstructionContext = @import("../instruction_context.zig").InstructionContext;
+const instruction_context = @import("../instruction_context.zig");
+const InstructionContext = instruction_context.InstructionContext;
+const expandMemory = instruction_context.expandMemory;
 const gas_costs = @import("../gas_costs.zig");
 const host_module = @import("../host.zig");
-const alloc_mod = @import("zesu_allocator");
 const CallScheme = @import("../interpreter_action.zig").CallScheme;
 const CreateScheme = @import("../interpreter_action.zig").CreateScheme;
 const CreateInputs = @import("../interpreter_action.zig").CreateInputs;
@@ -12,34 +13,6 @@ const Interpreter = interp_mod.Interpreter;
 const PendingCallData = interp_mod.PendingCallData;
 const PendingCreateData = interp_mod.PendingCreateData;
 
-// ---------------------------------------------------------------------------
-// Memory expansion helper
-// ---------------------------------------------------------------------------
-
-fn memoryCostWords(num_words: usize) u64 {
-    const n: u64 = @intCast(num_words);
-    const linear = std.math.mul(u64, n, gas_costs.G_MEMORY) catch return std.math.maxInt(u64);
-    const quadratic = (std.math.mul(u64, n, n) catch return std.math.maxInt(u64)) / 512;
-    return std.math.add(u64, linear, quadratic) catch std.math.maxInt(u64);
-}
-
-fn expandMemory(ctx: *InstructionContext, new_size: usize) bool {
-    if (new_size == 0) return true;
-    const current = ctx.interpreter.memory.size();
-    if (new_size <= current) return true;
-    const current_words = (current + 31) / 32;
-    const new_words = (std.math.add(usize, new_size, 31) catch return false) / 32;
-    if (new_words > current_words) {
-        const cost = memoryCostWords(new_words) - memoryCostWords(current_words);
-        if (!ctx.interpreter.gas.spend(cost)) return false;
-    }
-    const aligned_size = new_words * 32;
-    const old_size = ctx.interpreter.memory.size();
-    ctx.interpreter.memory.buffer.resize(alloc_mod.get(), aligned_size) catch return false;
-    @memset(ctx.interpreter.memory.buffer.items[old_size..aligned_size], 0);
-    return true;
-}
-
 // ---------------------------------------------------------------------------
 // Common call dispatch helper
 // ---------------------------------------------------------------------------

src/evm/interpreter/opcodes/environment.zig

@@ -1,37 +1,10 @@
 const std = @import("std");
 const primitives = @import("primitives");
-const InstructionContext = @import("../instruction_context.zig").InstructionContext;
+const instruction_context = @import("../instruction_context.zig");
+const InstructionContext = instruction_context.InstructionContext;
+const expandMemory = instruction_context.expandMemory;
 const gas_costs = @import("../gas_costs.zig");
 const host_module = @import("../host.zig");
-const alloc_mod = @import("zesu_allocator");
-
-// ---------------------------------------------------------------------------
-// Memory expansion helper (shared pattern from other opcode files)
-// ---------------------------------------------------------------------------
-
-fn memoryCostWords(num_words: usize) u64 {
-    const n: u64 = @intCast(num_words);
-    const linear = std.math.mul(u64, n, gas_costs.G_MEMORY) catch return std.math.maxInt(u64);
-    const quadratic = (std.math.mul(u64, n, n) catch return std.math.maxInt(u64)) / 512;
-    return std.math.add(u64, linear, quadratic) catch std.math.maxInt(u64);
-}
-
-fn expandMemory(ctx: *InstructionContext, new_size: usize) bool {
-    if (new_size == 0) return true;
-    const current = ctx.interpreter.memory.size();
-    if (new_size <= current) return true;
-    const current_words = (current + 31) / 32;
-    const new_words = (std.math.add(usize, new_size, 31) catch return false) / 32;
-    if (new_words > current_words) {
-        const cost = memoryCostWords(new_words) - memoryCostWords(current_words);
-        if (!ctx.interpreter.gas.spend(cost)) return false;
-    }
-    const aligned_size = new_words * 32;
-    const old_size = ctx.interpreter.memory.size();
-    ctx.interpreter.memory.buffer.resize(alloc_mod.get(), aligned_size) catch return false;
-    @memset(ctx.interpreter.memory.buffer.items[old_size..aligned_size], 0);
-    return true;
-}
 
 // ---------------------------------------------------------------------------
 // Opcodes that read from interpreter.input (no Host required)

src/evm/interpreter/opcodes/host_ops.zig

@@ -1,39 +1,12 @@
 const std = @import("std");
 const primitives = @import("primitives");
-const InstructionContext = @import("../instruction_context.zig").InstructionContext;
+const instruction_context = @import("../instruction_context.zig");
+const InstructionContext = instruction_context.InstructionContext;
+const expandMemory = instruction_context.expandMemory;
 const gas_costs = @import("../gas_costs.zig");
 const host_module = @import("../host.zig");
 const alloc_mod = @import("zesu_allocator");
 
-// ---------------------------------------------------------------------------
-// Memory expansion helper
-// ---------------------------------------------------------------------------
-
-fn memoryCostWords(num_words: usize) u64 {
-    const n: u64 = @intCast(num_words);
-    // Use checked arithmetic: a huge offset must yield OOG, not a panic.
-    const linear = std.math.mul(u64, n, gas_costs.G_MEMORY) catch return std.math.maxInt(u64);
-    const quadratic = (std.math.mul(u64, n, n) catch return std.math.maxInt(u64)) / 512;
-    return std.math.add(u64, linear, quadratic) catch std.math.maxInt(u64);
-}
-
-fn expandMemory(ctx: *InstructionContext, new_size: usize) bool {
-    if (new_size == 0) return true;
-    const current = ctx.interpreter.memory.size();
-    if (new_size <= current) return true;
-    const current_words = (current + 31) / 32;
-    const new_words = (std.math.add(usize, new_size, 31) catch return false) / 32;
-    if (new_words > current_words) {
-        const cost = memoryCostWords(new_words) - memoryCostWords(current_words);
-        if (!ctx.interpreter.gas.spend(cost)) return false;
-    }
-    const aligned_size = new_words * 32;
-    const old_size = ctx.interpreter.memory.size();
-    ctx.interpreter.memory.buffer.resize(alloc_mod.get(), aligned_size) catch return false;
-    @memset(ctx.interpreter.memory.buffer.items[old_size..aligned_size], 0);
-    return true;
-}
-
 // ---------------------------------------------------------------------------
 // Account balance / code opcodes
 // ---------------------------------------------------------------------------