fix(pr-review): address wurdum's PR 700 review comments

- Simplify GrowBacklog call by removing switch statement (comment 2)
  GrowBacklog internally routes based on GetGasModelToUse()
- Split GetGasModelToUse test into 3 focused tests (comment 3)
- Remove #region/#endregion blocks from L2PricingStateTests (comment 4)
- Delete PrecompileContextTests.cs with duplicate tests (comment 5)

feat(tests): add multi-gas refund integration tests

Port tests mirroring Nitro's tx_processor_multigas_test.go:
- MultiGasRefund_WhenExpensiveResourceNotUsed_ProducesPositiveRefund
- MultiGasRefund_ForRetryableTx_RefundToAddressReceivesRefund
- MultiGasRefund_WhenAllGasIsComputation_NoRefund

These verify multi-gas refund calculation for e2e compatibility.

Author: AnkushinDaniil

src/Nethermind

@@ -673,55 +673,54 @@ public void ShrinkBacklog_MultiGasConstraints_ReducesWeightedBacklog()
     }
 
     [Test]
-    public void GetGasModelToUse_BasedOnVersionAndConstraints_ReturnsCorrectModel()
+    public void GetGasModelToUse_WhenArbOS49_ReturnsLegacy()
     {
-        // Legacy model (v49, no constraints)
-        {
-            IWorldState worldState = TestWorldStateFactory.CreateForTest();
-            using IDisposable disposer = worldState.BeginScope(IWorldState.PreGenesis);
-            _ = ArbOSInitialization.Create(worldState);
+        IWorldState worldState = TestWorldStateFactory.CreateForTest();
+        using IDisposable disposer = worldState.BeginScope(IWorldState.PreGenesis);
+        _ = ArbOSInitialization.Create(worldState);
 
-            PrecompileTestContextBuilder context = new PrecompileTestContextBuilder(worldState, ulong.MaxValue)
-                .WithArbosState()
-                .WithArbosVersion(ArbosVersion.FortyNine)
-                .WithReleaseSpec();
+        PrecompileTestContextBuilder context = new PrecompileTestContextBuilder(worldState, ulong.MaxValue)
+            .WithArbosState()
+            .WithArbosVersion(ArbosVersion.FortyNine)
+            .WithReleaseSpec();
 
-            context.ArbosState.L2PricingState.GetGasModelToUse().Should().Be(GasModel.Legacy);
-        }
+        context.ArbosState.L2PricingState.GetGasModelToUse().Should().Be(GasModel.Legacy);
+    }
 
-        // Single constraints model (v50 with single-gas constraints)
-        {
-            IWorldState worldState = TestWorldStateFactory.CreateForTest();
-            using IDisposable disposer = worldState.BeginScope(IWorldState.PreGenesis);
-            _ = ArbOSInitialization.Create(worldState);
+    [Test]
+    public void GetGasModelToUse_WhenArbOS50WithConstraints_ReturnsSingleGasConstraints()
+    {
+        IWorldState worldState = TestWorldStateFactory.CreateForTest();
+        using IDisposable disposer = worldState.BeginScope(IWorldState.PreGenesis);
+        _ = ArbOSInitialization.Create(worldState);
 
-            PrecompileTestContextBuilder context = new PrecompileTestContextBuilder(worldState, ulong.MaxValue)
-                .WithArbosState()
-                .WithArbosVersion(ArbosVersion.Fifty)
-                .WithReleaseSpec();
+        PrecompileTestContextBuilder context = new PrecompileTestContextBuilder(worldState, ulong.MaxValue)
+            .WithArbosState()
+            .WithArbosVersion(ArbosVersion.Fifty)
+            .WithReleaseSpec();
 
-            context.ArbosState.L2PricingState.AddConstraint(7_000_000, 60, 0);
-            context.ArbosState.L2PricingState.GetGasModelToUse().Should().Be(GasModel.SingleGasConstraints);
-        }
+        context.ArbosState.L2PricingState.AddConstraint(7_000_000, 60, 0);
+        context.ArbosState.L2PricingState.GetGasModelToUse().Should().Be(GasModel.SingleGasConstraints);
+    }
 
-        // Multi-gas constraints model (v60 with multi-gas constraints)
-        {
-            IWorldState worldState = TestWorldStateFactory.CreateForTest();
-            using IDisposable disposer = worldState.BeginScope(IWorldState.PreGenesis);
-            _ = ArbOSInitialization.Create(worldState);
+    [Test]
+    public void GetGasModelToUse_WhenArbOS60WithMultiGasConstraints_ReturnsMultiGasConstraints()
+    {
+        IWorldState worldState = TestWorldStateFactory.CreateForTest();
+        using IDisposable disposer = worldState.BeginScope(IWorldState.PreGenesis);
+        _ = ArbOSInitialization.Create(worldState);
 
-            PrecompileTestContextBuilder context = new PrecompileTestContextBuilder(worldState, ulong.MaxValue)
-                .WithArbosState()
-                .WithArbosVersion(ArbosVersion.Sixty)
-                .WithReleaseSpec();
+        PrecompileTestContextBuilder context = new PrecompileTestContextBuilder(worldState, ulong.MaxValue)
+            .WithArbosState()
+            .WithArbosVersion(ArbosVersion.Sixty)
+            .WithReleaseSpec();
 
-            Dictionary<ResourceKind, ulong> weights = new()
-            {
-                { ResourceKind.Computation, 1 },
-            };
-            context.ArbosState.L2PricingState.AddMultiGasConstraint(7_000_000, 60, 0, weights);
-            context.ArbosState.L2PricingState.GetGasModelToUse().Should().Be(GasModel.MultiGasConstraints);
-        }
+        Dictionary<ResourceKind, ulong> weights = new()
+        {
+            { ResourceKind.Computation, 1 },
+        };
+        context.ArbosState.L2PricingState.AddMultiGasConstraint(7_000_000, 60, 0, weights);
+        context.ArbosState.L2PricingState.GetGasModelToUse().Should().Be(GasModel.MultiGasConstraints);
     }
 
     [Test]
@@ -785,7 +784,6 @@ public void GasPoolUpdateCost_ArbOS51WithConstraints_ReturnsCorrectCost()
         l2Pricing.GasPoolUpdateCost().Should().Be(constraintCost);
     }
 
-    #region Coverage: Exception Guards
 
     [Test]
     public void CalcMultiGasConstraintsExponents_DivisorZero_ThrowsException()
@@ -841,9 +839,7 @@ public void UpdatePricingModelMultiConstraints_DivisorZero_ThrowsException()
             .WithMessage("*divisor is zero*");
     }
 
-    #endregion
 
-    #region Coverage: Migration Path
 
     [Test]
     public void SetMultiGasConstraintsFromSingleGasConstraints_WhenCalled_ConvertsCorrectly()
@@ -958,9 +954,7 @@ public void SetMultiGasConstraintsFromSingleGasConstraints_WhenExistingConstrain
         mc.MaxWeight.Should().Be(1); // Not 5 from the old constraint
     }
 
-    #endregion
 
-    #region Coverage: Legacy Pricing Paths
 
     [Test]
     public void GasPoolUpdateCost_ArbOS50_ReturnsCorrectCost()
@@ -1133,9 +1127,7 @@ public void ShrinkBacklog_SingleGasConstraints_ReducesAllConstraintBacklogs()
         l2Pricing.OpenConstraintAt(1).Backlog.Should().Be(1700);
     }
 
-    #endregion
 
-    #region Coverage: Multi-Gas Fees and Base Fee Calculation
 
     [Test]
     public void CommitMultiGasFees_WhenNotMultiGasConstraints_DoesNothing()
@@ -1335,5 +1327,4 @@ public void UpdatePricingModelMultiGasConstraints_ZeroExponent_UsesMinBaseFee()
         l2Pricing.MultiGasFees.GetNextBlockFee(ResourceKind.Computation).Should().Be(minPrice);
     }
 
-    #endregion
 }

src/Nethermind.Arbitrum.Test/Arbos/Storage/L2PricingStateTests.cs

@@ -3,15 +3,18 @@
 
 using FluentAssertions;
 using Nethermind.Arbitrum.Arbos;
+using Nethermind.Arbitrum.Arbos.Storage;
 using Nethermind.Arbitrum.Evm;
 using Nethermind.Arbitrum.Execution;
 using Nethermind.Arbitrum.Test.Infrastructure;
 using Nethermind.Core;
+using Nethermind.Core.Test;
 using Nethermind.Core.Test.Builders;
 using Nethermind.Evm;
 using Nethermind.Evm.State;
 using Nethermind.Evm.Test;
 using Nethermind.Evm.TransactionProcessing;
+using Nethermind.Int256;
 
 namespace Nethermind.Arbitrum.Test.Execution;
 
@@ -115,4 +118,179 @@ public void Execute_SufficientGas_ChargesPosterGasAsL1Calldata()
 
         gas.Get(ResourceKind.L1Calldata).Should().BeGreaterThan(0UL, "expected L1Calldata > 0");
     }
+
+    /// <summary>
+    /// Tests multi-gas refund calculation for normal transactions.
+    /// Mirrors Nitro's TestEndTxHookMultiGasRefundNormalTx from tx_processor_multigas_test.go.
+    ///
+    /// When multi-gas constraints make certain resources expensive (e.g., StorageGrowth weight=10),
+    /// transactions that don't use those expensive resources should have multiDimensionalCost less than
+    /// singleGasCost, resulting in a positive refund.
+    /// </summary>
+    [Test]
+    public void MultiGasRefund_WhenExpensiveResourceNotUsed_ProducesPositiveRefund()
+    {
+        IWorldState worldState = TestWorldStateFactory.CreateForTest();
+        using IDisposable disposer = worldState.BeginScope(IWorldState.PreGenesis);
+        _ = ArbOSInitialization.Create(worldState);
+
+        PrecompileTestContextBuilder context = new PrecompileTestContextBuilder(worldState, ulong.MaxValue)
+            .WithArbosState()
+            .WithArbosVersion(ArbosVersion.Sixty)
+            .WithReleaseSpec();
+
+        L2PricingState l2Pricing = context.ArbosState.L2PricingState;
+
+        // Set up constraint that makes StorageGrowth expensive (weight=10) vs Computation (weight=1)
+        // This mirrors Nitro's test setup where StorageGrowth is heavily constrained
+        Dictionary<ResourceKind, ulong> weights = new()
+        {
+            { ResourceKind.Computation, 1 },
+            { ResourceKind.StorageGrowth, 10 },
+        };
+
+        // target=100000, window=10, backlog=200_000_000_000 (high backlog to elevate prices)
+        l2Pricing.AddMultiGasConstraint(100000, 10, 200_000_000_000, weights);
+
+        // Update pricing model to produce different per-resource fees
+        l2Pricing.UpdatePricingModel(100);
+        l2Pricing.CommitMultiGasFees();
+
+        UInt256 baseFee = l2Pricing.BaseFeeWeiStorage.Get();
+        baseFee.Should().BeGreaterThan(UInt256.Zero, "baseFee should be elevated due to high backlog");
+
+        // Simulate transaction that uses only Computation and StorageAccess (NOT StorageGrowth)
+        // This means the expensive resource (StorageGrowth) is not used
+        const ulong gasUsed = 1_000_000;
+        MultiGas usedMultiGas = default;
+        usedMultiGas.Increment(ResourceKind.Computation, gasUsed / 2);
+        usedMultiGas.Increment(ResourceKind.StorageAccess, gasUsed / 2);
+
+        // Calculate costs
+        UInt256 singleGasCost = baseFee * gasUsed;
+        UInt256 multiDimensionalCost = l2Pricing.MultiDimensionalPriceForRefund(usedMultiGas);
+
+        // Since StorageGrowth (the expensive resource) wasn't used, multiDimensionalCost should be less
+        multiDimensionalCost.Should().BeLessThan(singleGasCost,
+            "multiDimensionalCost should be less than singleGasCost when expensive resources aren't used");
+
+        // Calculate refund
+        UInt256 expectedRefund = singleGasCost - multiDimensionalCost;
+        expectedRefund.Should().BeGreaterThan(UInt256.Zero,
+            "refund should be positive when multiDimensionalCost < singleGasCost");
+    }
+
+    /// <summary>
+    /// Tests multi-gas refund calculation for retryable transactions.
+    /// Mirrors Nitro's TestEndTxHookMultiGasRefundRetryableTx from tx_processor_multigas_test.go.
+    ///
+    /// For retryable transactions, the refund goes to RefundTo address (up to MaxRefund),
+    /// with any excess going to the sender.
+    /// </summary>
+    [Test]
+    public void MultiGasRefund_ForRetryableTx_RefundToAddressReceivesRefund()
+    {
+        IWorldState worldState = TestWorldStateFactory.CreateForTest();
+        using IDisposable disposer = worldState.BeginScope(IWorldState.PreGenesis);
+        _ = ArbOSInitialization.Create(worldState);
+
+        PrecompileTestContextBuilder context = new PrecompileTestContextBuilder(worldState, ulong.MaxValue)
+            .WithArbosState()
+            .WithArbosVersion(ArbosVersion.Sixty)
+            .WithReleaseSpec();
+
+        L2PricingState l2Pricing = context.ArbosState.L2PricingState;
+
+        // Set up constraint that makes StorageGrowth expensive
+        Dictionary<ResourceKind, ulong> weights = new()
+        {
+            { ResourceKind.Computation, 1 },
+            { ResourceKind.StorageGrowth, 10 },
+        };
+        l2Pricing.AddMultiGasConstraint(100000, 10, 200_000_000_000, weights);
+
+        // Update pricing model
+        l2Pricing.UpdatePricingModel(100);
+        l2Pricing.CommitMultiGasFees();
+
+        UInt256 baseFee = l2Pricing.BaseFeeWeiStorage.Get();
+
+        // Simulate retryable transaction gas usage (similar to normal tx)
+        const ulong gasUsed = 1_000_000;
+        MultiGas usedMultiGas = default;
+        usedMultiGas.Increment(ResourceKind.Computation, gasUsed / 2);
+        usedMultiGas.Increment(ResourceKind.StorageAccess, gasUsed / 2);
+
+        // For retryables, gasFeeCap is used as the simple gas price
+        UInt256 gasFeeCap = baseFee;
+        UInt256 simpleGasCost = gasFeeCap * gasUsed;
+        UInt256 multiDimensionalCost = l2Pricing.MultiDimensionalPriceForRefund(usedMultiGas);
+
+        UInt256 expectedRefund = simpleGasCost - multiDimensionalCost;
+        expectedRefund.Should().BeGreaterThan(UInt256.Zero,
+            "retryable tx should have positive refund when expensive resources aren't used");
+
+        // Verify refund distribution logic:
+        // If MaxRefund >= expectedRefund: entire refund goes to RefundTo
+        // If MaxRefund < expectedRefund: MaxRefund to RefundTo, remainder to From
+        UInt256 maxRefund = expectedRefund * 10; // Large MaxRefund
+        UInt256 toRefundTo = UInt256.Min(expectedRefund, maxRefund);
+        UInt256 toFrom = expectedRefund - toRefundTo;
+
+        toRefundTo.Should().Be(expectedRefund, "with large MaxRefund, entire refund goes to RefundTo");
+        toFrom.Should().Be(UInt256.Zero, "with large MaxRefund, nothing goes to From");
+
+        // Test with small MaxRefund
+        UInt256 smallMaxRefund = expectedRefund / 2;
+        UInt256 toRefundToSmall = UInt256.Min(expectedRefund, smallMaxRefund);
+        UInt256 toFromSmall = expectedRefund - toRefundToSmall;
+
+        toRefundToSmall.Should().Be(smallMaxRefund, "with small MaxRefund, only MaxRefund goes to RefundTo");
+        toFromSmall.Should().Be(expectedRefund - smallMaxRefund, "remainder goes to From");
+    }
+
+    /// <summary>
+    /// Tests that when all gas goes to computation only, there's no refund
+    /// (multiDimensionalCost equals singleGasCost).
+    /// </summary>
+    [Test]
+    public void MultiGasRefund_WhenAllGasIsComputation_NoRefund()
+    {
+        IWorldState worldState = TestWorldStateFactory.CreateForTest();
+        using IDisposable disposer = worldState.BeginScope(IWorldState.PreGenesis);
+        _ = ArbOSInitialization.Create(worldState);
+
+        PrecompileTestContextBuilder context = new PrecompileTestContextBuilder(worldState, ulong.MaxValue)
+            .WithArbosState()
+            .WithArbosVersion(ArbosVersion.Sixty)
+            .WithReleaseSpec();
+
+        L2PricingState l2Pricing = context.ArbosState.L2PricingState;
+
+        // Set up constraint with only Computation (weight=1)
+        Dictionary<ResourceKind, ulong> weights = new()
+        {
+            { ResourceKind.Computation, 1 },
+        };
+        l2Pricing.AddMultiGasConstraint(7_000_000, 60, 0, weights);
+
+        // Use the initialized base fee from state (0.1 gwei = 100_000_000 wei)
+        UInt256 baseFee = l2Pricing.BaseFeeWeiStorage.Get();
+
+        // Set multi-gas base fee for computation to match
+        l2Pricing.SetNextBlockMultiGasBaseFee(ResourceKind.Computation, baseFee);
+        l2Pricing.CommitMultiGasFees();
+
+        // All gas goes to Computation
+        const ulong gasUsed = 100_000;
+        MultiGas usedMultiGas = default;
+        usedMultiGas.Increment(ResourceKind.Computation, gasUsed);
+
+        UInt256 singleGasCost = baseFee * gasUsed;
+        UInt256 multiDimensionalCost = l2Pricing.MultiDimensionalPriceForRefund(usedMultiGas);
+
+        // When all gas is computation at same base fee, costs should be equal
+        multiDimensionalCost.Should().Be(singleGasCost,
+            "when all gas is computation at base fee, no refund should occur");
+    }
 }