addressed pr comments

Signed-off-by: daniellehrner <daniel.lehrner@consensys.net>

Author: daniellehrner

config/src/main/java/org/hyperledger/besu/config/BlobSchedule.java

@@ -26,7 +26,7 @@ public class BlobSchedule {
   /** The constant PRAGUE_DEFAULT. */
   public static final BlobSchedule PRAGUE_DEFAULT = BlobSchedule.create(6, 9, 5007716);
 
-  /** The constant BPO2_DEFAULT. BPO2 through BPO5 and Amsterdam share these values. */
+  /** The constant BPO2_DEFAULT. */
   public static final BlobSchedule BPO2_DEFAULT = BlobSchedule.create(14, 21, 11684671);
 
   private final int target;

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/AmsterdamTargetingGasLimitCalculator.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright contributors to Besu.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.hyperledger.besu.ethereum.mainnet;
+
+import org.hyperledger.besu.ethereum.mainnet.feemarket.BaseFeeMarket;
+import org.hyperledger.besu.evm.gascalculator.GasCalculator;
+
+import java.util.OptionalInt;
+
+/** EIP-8037: Amsterdam disables the validation-time transaction gas limit cap. */
+public class AmsterdamTargetingGasLimitCalculator extends OsakaTargetingGasLimitCalculator {
+
+  public AmsterdamTargetingGasLimitCalculator(
+      final long londonForkBlock,
+      final BaseFeeMarket feeMarket,
+      final GasCalculator gasCalculator,
+      final int maxBlobsPerBlock,
+      final int targetBlobsPerBlock,
+      final OptionalInt maxBlobsPerTransaction,
+      final OptionalInt userMaxBlobsPerBlock) {
+    super(
+        londonForkBlock,
+        feeMarket,
+        gasCalculator,
+        maxBlobsPerBlock,
+        targetBlobsPerBlock,
+        maxBlobsPerTransaction,
+        userMaxBlobsPerBlock,
+        Long.MAX_VALUE);
+  }
+}

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetProtocolSpecs.java

@@ -1256,15 +1256,14 @@ static ProtocolSpecBuilder amsterdamDefinition(
         .gasLimitCalculatorBuilder(
             (feeMarket, gasCalculator, blobSchedule) -> {
               final long londonForkBlock = genesisConfigOptions.getLondonBlockNumber().orElse(0L);
-              return new OsakaTargetingGasLimitCalculator(
+              return new AmsterdamTargetingGasLimitCalculator(
                   londonForkBlock,
                   (BaseFeeMarket) feeMarket,
                   gasCalculator,
                   blobSchedule.getMax(),
                   blobSchedule.getTarget(),
                   miningConfiguration.getMaxBlobsPerTransaction(),
-                  miningConfiguration.getMaxBlobsPerBlock(),
-                  Long.MAX_VALUE);
+                  miningConfiguration.getMaxBlobsPerBlock());
             })
         // EIP-8037: Amsterdam gas calculator with state gas cost support
         .gasCalculator(AmsterdamGasCalculator::new)

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/mainnet/AmsterdamTargetingGasLimitCalculatorTest.java

@@ -25,7 +25,6 @@
 import java.util.Optional;
 import java.util.OptionalInt;
 
-import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -40,8 +39,8 @@ class AmsterdamTargetingGasLimitCalculatorTest {
   private static final int TARGET_BLOBS = 14;
   private static final int MAX_BLOBS = 21;
   private static final AmsterdamGasCalculator gasCalculator = new AmsterdamGasCalculator();
-  private final OsakaTargetingGasLimitCalculator gasLimitCalculator =
-      new OsakaTargetingGasLimitCalculator(
+  private final AmsterdamTargetingGasLimitCalculator gasLimitCalculator =
+      new AmsterdamTargetingGasLimitCalculator(
           0L,
           FeeMarket.cancun(0L, Optional.empty(), BlobSchedule.BPO2_DEFAULT),
           gasCalculator,
@@ -62,7 +61,7 @@ class AmsterdamTargetingGasLimitCalculatorTest {
    * where parent_excess_blobs=18 (=(21+14)//2+1), parent_blobs=0, block_base_fee_per_gas=7
    */
   @ParameterizedTest(name = "{index} - parent excess {0}, used gas {1}, base fee {2}")
-  @MethodSource("standardBranchBlobGasses")
+  @MethodSource("standardBranchBlobGases")
   public void shouldCalculateExcessBlobGasCorrectly_standardBranch(
       final long parentExcess,
       final long parentBlobGasUsed,
@@ -72,7 +71,7 @@ public void shouldCalculateExcessBlobGasCorrectly_standardBranch(
         .isEqualTo(expected);
   }
 
-  Iterable<Arguments> standardBranchBlobGasses() {
+  Iterable<Arguments> standardBranchBlobGases() {
     return List.of(
         // zero + zero: below target → 0
         Arguments.of(0L, 0L, 7L, 0L),
@@ -103,7 +102,7 @@ Iterable<Arguments> standardBranchBlobGasses() {
    * 14 = 7, so: excess = parentExcess + parentBlobGasUsed * 7 / 21
    */
   @ParameterizedTest(name = "{index} - parent excess {0}, used gas {1}, base fee {2}")
-  @MethodSource("eip7918BranchBlobGasses")
+  @MethodSource("eip7918BranchBlobGases")
   public void shouldCalculateExcessBlobGasCorrectly_eip7918Branch(
       final long parentExcess,
       final long parentBlobGasUsed,
@@ -113,7 +112,7 @@ public void shouldCalculateExcessBlobGasCorrectly_eip7918Branch(
         .isEqualTo(expected);
   }
 
-  Iterable<Arguments> eip7918BranchBlobGasses() {
+  Iterable<Arguments> eip7918BranchBlobGases() {
     // parentExcess = TARGET_GAS + 1 = 1835009, just above target so not clamped to 0
     // With base_fee=17: 17*8192=139264 > 1*131072=131072 → EIP-7918 branch
     // excess = 1835009 + parentBlobGasUsed * 7 / 21
@@ -131,7 +130,7 @@ Iterable<Arguments> eip7918BranchBlobGasses() {
   @Test
   void defaultGasLimit() {
     GasLimitCalculator calculator =
-        new OsakaTargetingGasLimitCalculator(
+        new AmsterdamTargetingGasLimitCalculator(
             0L,
             FeeMarket.cancun(0L, Optional.empty(), BlobSchedule.BPO2_DEFAULT),
             new AmsterdamGasCalculator(),
@@ -144,11 +143,4 @@ void defaultGasLimit() {
     // per-tx cap: DEFAULT_MAX_BLOBS_PER_TRANSACTION (6) * 131072 = 0xC0000
     assertThat(calculator.transactionBlobGasLimitCap()).isEqualTo(0xC0000);
   }
-
-  @Test
-  void dryRunDetector() {
-    Assertions.assertThat(true)
-        .withFailMessage("This test is here so gradle --dry-run executes this class")
-        .isTrue();
-  }
 }

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/mainnet/CancunTargetingGasLimitCalculatorTest.java

@@ -20,12 +20,10 @@
 import org.hyperledger.besu.ethereum.GasLimitCalculator;
 import org.hyperledger.besu.ethereum.mainnet.feemarket.FeeMarket;
 import org.hyperledger.besu.evm.gascalculator.CancunGasCalculator;
-import org.hyperledger.besu.evm.gascalculator.OsakaGasCalculator;
 import org.hyperledger.besu.evm.gascalculator.PragueGasCalculator;
 
 import java.util.List;
 import java.util.Optional;
-import java.util.OptionalInt;
 
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -147,47 +145,6 @@ void shouldCalculateCorrectlyPragueBlobGasPerBlob() {
     assertThat(pragueTargetingGasLimitCalculator.currentBlobGasLimit()).isEqualTo(1310720);
   }
 
-  long nineBlobTargetGas = TARGET_BLOB_GAS_PER_BLOCK_OSAKA;
-  int newTargetCount = 9;
-  public static final OsakaGasCalculator osakaGasCalculator = new OsakaGasCalculator();
-  // CancunTargetingGasLimitCalculator with Osaka numbers
-  private final OsakaTargetingGasLimitCalculator osakaGasLimitCalculator =
-      new OsakaTargetingGasLimitCalculator(
-          0L,
-          FeeMarket.cancunDefault(0L, Optional.empty()),
-          osakaGasCalculator,
-          BlobSchedule.PRAGUE_DEFAULT.getMax(),
-          newTargetCount,
-          OptionalInt.empty(),
-          OptionalInt.empty());
-
-  private static final long TARGET_BLOB_GAS_PER_BLOCK_OSAKA = 0x120000;
-
-  @ParameterizedTest(name = "{index} - parent gas {0}, used gas {1}, blob target {2}")
-  @MethodSource("osakaBlobGasses")
-  public void shouldCalculateOsakaExcessBlobGasCorrectly(
-      final long parentExcess, final long used, final long expected) {
-    final long usedBlobGas = osakaGasCalculator.blobGasCost(used);
-    assertThat(osakaGasLimitCalculator.computeExcessBlobGas(parentExcess, usedBlobGas, 0L))
-        .isEqualTo(expected);
-  }
-
-  Iterable<Arguments> osakaBlobGasses() {
-
-    return List.of(
-        // New target count
-        Arguments.of(0L, 0L, 0L),
-        Arguments.of(nineBlobTargetGas, 0L, 0L),
-        Arguments.of(newTargetCount, 0L, 0L),
-        Arguments.of(0L, newTargetCount, 0L),
-        Arguments.of(1L, newTargetCount, 1L),
-        Arguments.of(
-            osakaGasCalculator.blobGasCost(newTargetCount),
-            1L,
-            osakaGasLimitCalculator.getBlobGasPerBlob()),
-        Arguments.of(nineBlobTargetGas, newTargetCount, nineBlobTargetGas));
-  }
-
   @Test
   void cancunDefaultGasLimit() {
     GasLimitCalculator gasLimitCalculator =

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/mainnet/ProtocolScheduleBuilderTest.java

@@ -35,11 +35,11 @@
 import static org.hyperledger.besu.datatypes.HardforkId.MainnetHardforkId.PRAGUE;
 import static org.hyperledger.besu.datatypes.HardforkId.MainnetHardforkId.SHANGHAI;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.lenient;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
-import static org.mockito.Mockito.withSettings;
 
 import org.hyperledger.besu.config.BlobSchedule;
 import org.hyperledger.besu.config.BlobScheduleOptions;
@@ -557,12 +557,19 @@ void inactiveBpoForkBlobScheduleIsNotApplied() {
     when(configOptions.getWithdrawalRequestContractAddress()).thenReturn(Optional.of(Address.ZERO));
 
     // Set up blob schedule: BPO2 has max=21, BPO3-5 have max=9 (deliberately different)
-    final BlobScheduleOptions blobScheduleOptions =
-        mock(BlobScheduleOptions.class, withSettings().lenient());
+    final BlobScheduleOptions blobScheduleOptions = mock(BlobScheduleOptions.class);
     when(blobScheduleOptions.getBpo2()).thenReturn(Optional.of(BlobSchedule.BPO2_DEFAULT));
-    when(blobScheduleOptions.getBpo3()).thenReturn(Optional.of(BlobSchedule.PRAGUE_DEFAULT));
-    when(blobScheduleOptions.getBpo4()).thenReturn(Optional.of(BlobSchedule.PRAGUE_DEFAULT));
-    when(blobScheduleOptions.getBpo5()).thenReturn(Optional.of(BlobSchedule.PRAGUE_DEFAULT));
+    // BPO3-5 stubs are lenient because these forks lack timestamps, so the production code
+    // never calls getBpo3/4/5 — but we set them up to verify they are NOT applied.
+    lenient()
+        .when(blobScheduleOptions.getBpo3())
+        .thenReturn(Optional.of(BlobSchedule.PRAGUE_DEFAULT));
+    lenient()
+        .when(blobScheduleOptions.getBpo4())
+        .thenReturn(Optional.of(BlobSchedule.PRAGUE_DEFAULT));
+    lenient()
+        .when(blobScheduleOptions.getBpo5())
+        .thenReturn(Optional.of(BlobSchedule.PRAGUE_DEFAULT));
     when(configOptions.getBlobScheduleOptions()).thenReturn(Optional.of(blobScheduleOptions));
 
     final ProtocolSchedule protocolSchedule = builder.createProtocolSchedule();