refactor(evm): remove chargeForWarm parameter from ConsumeAccountAccessGas

AccountAccessKind enum already encodes whether warm charge should be
applied — SelfDestructBeneficiary skips warm charge, Default always
charges. The chargeForWarm boolean was only ever false in the
SELFDESTRUCT context, making it fully redundant with the kind
discriminator.

Constraint: chargeForWarm was only false at the SELFDESTRUCT call site
Rejected: Keep both parameters for flexibility | no other caller needs chargeForWarm=false

Author: AnkushinDaniil

src/Nethermind/Nethermind.Evm/GasPolicy/AccountAccessKind.cs

@@ -0,0 +1,24 @@
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+namespace Nethermind.Evm.GasPolicy;
+
+/// <summary>
+/// Discriminator for account access gas charging.
+/// Allows <see cref="IGasPolicy{TSelf}.ConsumeAccountAccessGas"/> to vary
+/// its resource-kind split based on the calling opcode's semantics.
+/// </summary>
+public enum AccountAccessKind : byte
+{
+    /// <summary>
+    /// Regular account access (BALANCE, EXTCODESIZE, CALL, etc.).
+    /// </summary>
+    Default = 0,
+
+    /// <summary>
+    /// SELFDESTRUCT beneficiary access.
+    /// Cold access charges full cost to StorageAccess (no Computation split);
+    /// warm access charges nothing.
+    /// </summary>
+    SelfDestructBeneficiary = 1
+}

src/Nethermind/Nethermind.Evm/GasPolicy/EthereumGasPolicy.cs

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
 // SPDX-License-Identifier: LGPL-3.0-only
 
+using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
@@ -51,61 +52,46 @@ public static bool ConsumeAccountAccessGasWithDelegation(ref EthereumGasPolicy g
         ref readonly StackAccessTracker accessTracker,
         bool isTracingAccess,
         Address address,
-        Address? delegated,
-        bool chargeForWarm = true)
+        Address? delegated)
     {
         if (!spec.UseHotAndColdStorage)
             return true;
 
-        bool notOutOfGas = ConsumeAccountAccessGas(ref gas, spec, in accessTracker, isTracingAccess, address, chargeForWarm);
-        return notOutOfGas && (delegated is null || ConsumeAccountAccessGas(ref gas, spec, in accessTracker, isTracingAccess, delegated, chargeForWarm));
+        bool notOutOfGas = ConsumeAccountAccessGas(ref gas, spec, in accessTracker, isTracingAccess, address);
+        return notOutOfGas && (delegated is null || ConsumeAccountAccessGas(ref gas, spec, in accessTracker, isTracingAccess, delegated));
     }
 
     public static bool ConsumeAccountAccessGas(ref EthereumGasPolicy gas,
         IReleaseSpec spec,
         ref readonly StackAccessTracker accessTracker,
         bool isTracingAccess,
         Address address,
-        bool chargeForWarm = true)
+        AccountAccessKind kind = AccountAccessKind.Default)
     {
-        bool result = true;
-        if (spec.UseHotAndColdStorage)
+        if (!spec.UseHotAndColdStorage) return true;
+        if (isTracingAccess)
         {
-            if (isTracingAccess)
-            {
-                // Ensure that tracing simulates access-list behavior.
-                accessTracker.WarmUp(address);
-            }
+            // Ensure that tracing simulates access-list behavior.
+            accessTracker.WarmUp(address);
+        }
 
-            // If the account is cold (and not a precompile), charge the cold access cost.
-            if (!spec.IsPrecompile(address) && accessTracker.WarmUp(address))
-            {
-                result = UpdateGas(ref gas, GasCostOf.ColdAccountAccess);
-            }
-            else if (chargeForWarm)
+        bool result;
+        // If the account is cold (and not a precompile), charge the cold access cost.
+        if (!spec.IsPrecompile(address) && accessTracker.WarmUp(address))
+            result = UpdateGas(ref gas, GasCostOf.ColdAccountAccess);
+        else
+        {
+            result = kind switch
             {
-                // Otherwise, if warm access should be charged, apply the warm read cost.
-                result = UpdateGas(ref gas, GasCostOf.WarmStateRead);
-            }
+                AccountAccessKind.SelfDestructBeneficiary => true, // no warm charge
+                AccountAccessKind.Default => UpdateGas(ref gas, GasCostOf.WarmStateRead),
+                _ => throw new ArgumentOutOfRangeException(nameof(kind), kind, null)
+            };
         }
 
         return result;
     }
 
-    /// <summary>
-    /// For Ethereum, SELFDESTRUCT beneficiary access is the same as regular account access.
-    /// Arbitrum overrides this to charge cold access as full StorageAccess (no split).
-    /// </summary>
-    public static bool ConsumeSelfDestructBeneficiaryAccessGas(ref EthereumGasPolicy gas,
-        IReleaseSpec spec,
-        ref readonly StackAccessTracker accessTracker,
-        bool isTracingAccess,
-        Address address)
-    {
-        // For Ethereum, just use regular account access gas (no MultiGas tracking)
-        return ConsumeAccountAccessGas(ref gas, spec, in accessTracker, isTracingAccess, address, chargeForWarm: false);
-    }
-
     public static bool ConsumeStorageAccessGas(ref EthereumGasPolicy gas,
         ref readonly StackAccessTracker accessTracker,
         bool isTracingAccess,

src/Nethermind/Nethermind.Evm/GasPolicy/IGasPolicy.cs

@@ -81,49 +81,33 @@ public interface IGasPolicy<TSelf> where TSelf : struct, IGasPolicy<TSelf>
     /// <param name="isTracingAccess">Whether access tracing is enabled.</param>
     /// <param name="address">The target account address.</param>
     /// <param name="delegated">The delegated account address, if any.</param>
-    /// <param name="chargeForWarm">If true, charge even if the account is already warm.</param>
     /// <returns>True if gas was successfully charged; otherwise false.</returns>
     static abstract bool ConsumeAccountAccessGasWithDelegation(ref TSelf gas,
         IReleaseSpec spec,
         ref readonly StackAccessTracker accessTracker,
         bool isTracingAccess,
         Address address,
-        Address? delegated,
-        bool chargeForWarm = true);
+        Address? delegated);
 
     /// <summary>
     /// Charges gas for accessing an account based on its storage state (cold vs. warm).
     /// Precompiles are treated as exceptions to the cold/warm gas charge.
+    /// The <paramref name="kind"/> discriminator controls the multi-gas resource split
+    /// (e.g. SELFDESTRUCT beneficiary charges full cold cost to StorageAccess with no warm charge).
     /// </summary>
     /// <param name="gas">The gas state to update.</param>
     /// <param name="spec">The release specification governing gas costs.</param>
     /// <param name="accessTracker">The access tracker for cold/warm state.</param>
     /// <param name="isTracingAccess">Whether access tracing is enabled.</param>
     /// <param name="address">The target account address.</param>
-    /// <param name="chargeForWarm">If true, applies the warm read gas cost even if the account is warm.</param>
+    /// <param name="kind">Discriminator that varies resource-kind accounting per calling opcode.</param>
     /// <returns>True if the gas charge was successful; otherwise false.</returns>
     static abstract bool ConsumeAccountAccessGas(ref TSelf gas,
         IReleaseSpec spec,
         ref readonly StackAccessTracker accessTracker,
         bool isTracingAccess,
         Address address,
-        bool chargeForWarm = true);
-
-    /// <summary>
-    /// Charges gas for accessing the SELFDESTRUCT beneficiary account.
-    /// For Arbitrum, cold access is charged as FULL StorageAccess (no Computation split).
-    /// </summary>
-    /// <param name="gas">The gas state to update.</param>
-    /// <param name="spec">The release specification governing gas costs.</param>
-    /// <param name="accessTracker">The access tracker for cold/warm state.</param>
-    /// <param name="isTracingAccess">Whether access tracing is enabled.</param>
-    /// <param name="address">The beneficiary account address.</param>
-    /// <returns>True if the gas charge was successful; otherwise false.</returns>
-    static abstract bool ConsumeSelfDestructBeneficiaryAccessGas(ref TSelf gas,
-        IReleaseSpec spec,
-        ref readonly StackAccessTracker accessTracker,
-        bool isTracingAccess,
-        Address address);
+        AccountAccessKind kind = AccountAccessKind.Default);
 
     /// <summary>
     /// Charges the appropriate gas cost for accessing a storage cell, taking into account whether the access is cold or warm.

src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.ControlFlow.cs

@@ -229,9 +229,7 @@ private static EvmExceptionType InstructionSelfDestruct<TGasPolicy>(VirtualMachi
             goto StackUnderflow;
 
         // Charge gas for SELFDESTRUCT beneficiary access; if insufficient, signal out-of-gas.
-        // Uses ConsumeSelfDestructBeneficiaryAccessGas which charges cold access as full StorageAccess
-        // (no Computation split for Arbitrum).
-        if (!TGasPolicy.ConsumeSelfDestructBeneficiaryAccessGas(ref gas, spec, in vmState.AccessTracker, vm.TxTracer.IsTracingAccess, inheritor))
+        if (!TGasPolicy.ConsumeAccountAccessGas(ref gas, spec, in vmState.AccessTracker, vm.TxTracer.IsTracingAccess, inheritor, AccountAccessKind.SelfDestructBeneficiary))
             goto OutOfGas;
 
         Address executingAccount = vmState.Env.ExecutingAccount;