New cli options to limit rewards return by eth_feeHistory

besu/src/main/java/org/hyperledger/besu/cli/BesuCommand.java

@@ -1217,6 +1217,27 @@ static class PermissionsOptionGroup {
       description = "Maximum gas price for eth_gasPrice (default: ${DEFAULT-VALUE})")
   private final Long apiGasPriceMax = 500_000_000_000L;
 
+  @CommandLine.Option(
+      names = {"--api-priority-fee-limiting-enabled"},
+      hidden = true,
+      description =
+          "Set to enable priority fee limit in eth_feeHistory (default: ${DEFAULT-VALUE})")
+  private final Boolean apiPriorityFeeLimitingEnabled = false;
+
+  @CommandLine.Option(
+      names = {"--api-priority-fee-lower-bound-coefficient"},
+      hidden = true,
+      description =
+          "Coefficient for setting the lower limit of minimum priority fee in eth_feeHistory (default: ${DEFAULT-VALUE})")
+  private final Long apiPriorityFeeLowerBoundCoefficient = 100L;
+
+  @CommandLine.Option(
+      names = {"--api-priority-fee-upper-bound-coefficient"},
+      hidden = true,
+      description =
+          "Coefficient for setting the upper limit of minimum priority fee in eth_feeHistory (default: ${DEFAULT-VALUE})")
+  private final Long apiPriorityFeeUpperBoundCoefficient = 100L;
+
   @CommandLine.Option(
       names = {"--static-nodes-file"},
       paramLabel = MANDATORY_FILE_FORMAT_HELP,
@@ -2493,6 +2514,9 @@ private ApiConfiguration apiConfiguration() {
         .gasPriceMax(apiGasPriceMax)
         .maxLogsRange(rpcMaxLogsRange)
         .gasCap(rpcGasCap)
+        .isPriorityFeeLimitingEnabled(apiPriorityFeeLimitingEnabled)
+        .lowerBoundPriorityFeeCoefficient(apiPriorityFeeLowerBoundCoefficient)
+        .upperBoundPriorityFeeCoefficient(apiPriorityFeeUpperBoundCoefficient)
         .build();
   }
 

besu/src/test/java/org/hyperledger/besu/cli/BesuCommandTest.java

@@ -1609,6 +1609,50 @@ public void rpcGasCapOptionMustBeUsed() {
     assertThat(commandErrorOutput.toString(UTF_8)).isEmpty();
   }
 
+  @Test
+  public void apiPriorityFeeLimitingEnabledOptionMustBeUsed() {
+    parseCommand("--api-priority-fee-limiting-enabled");
+    verify(mockRunnerBuilder).apiConfiguration(apiConfigurationCaptor.capture());
+    verify(mockRunnerBuilder).build();
+    assertThat(apiConfigurationCaptor.getValue())
+        .isEqualTo(ImmutableApiConfiguration.builder().isPriorityFeeLimitingEnabled(true).build());
+
+    assertThat(commandOutput.toString(UTF_8)).isEmpty();
+    assertThat(commandErrorOutput.toString(UTF_8)).isEmpty();
+  }
+
+  @Test
+  public void apiPriorityFeeLowerBoundCoefficientOptionMustBeUsed() {
+    final long lowerBound = 150L;
+    parseCommand("--api-priority-fee-lower-bound-coefficient", Long.toString(lowerBound));
+    verify(mockRunnerBuilder).apiConfiguration(apiConfigurationCaptor.capture());
+    verify(mockRunnerBuilder).build();
+    assertThat(apiConfigurationCaptor.getValue())
+        .isEqualTo(
+            ImmutableApiConfiguration.builder()
+                .lowerBoundPriorityFeeCoefficient(lowerBound)
+                .build());
+
+    assertThat(commandOutput.toString(UTF_8)).isEmpty();
+    assertThat(commandErrorOutput.toString(UTF_8)).isEmpty();
+  }
+
+  @Test
+  public void apiPriorityFeeUpperBoundCoefficientsOptionMustBeUsed() {
+    final long upperBound = 200L;
+    parseCommand("--api-priority-fee-upper-bound-coefficient", Long.toString(upperBound));
+    verify(mockRunnerBuilder).apiConfiguration(apiConfigurationCaptor.capture());
+    verify(mockRunnerBuilder).build();
+    assertThat(apiConfigurationCaptor.getValue())
+        .isEqualTo(
+            ImmutableApiConfiguration.builder()
+                .upperBoundPriorityFeeCoefficient(upperBound)
+                .build());
+
+    assertThat(commandOutput.toString(UTF_8)).isEmpty();
+    assertThat(commandErrorOutput.toString(UTF_8)).isEmpty();
+  }
+
   @Test
   public void p2pPeerUpperBound_without_p2pPeerLowerBound_shouldSetLowerBoundEqualToUpperBound() {
 

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/ApiConfiguration.java

@@ -59,4 +59,19 @@ public Long getMaxLogsRange() {
   public Long getGasCap() {
     return 0L;
   }
+
+  @Value.Default
+  public boolean isPriorityFeeLimitingEnabled() {
+    return false;
+  }
+
+  @Value.Default
+  public Long getLowerBoundPriorityFeeCoefficient() {
+    return 100L;
+  }
+
+  @Value.Default
+  public Long getUpperBoundPriorityFeeCoefficient() {
+    return 100L;
+  }
 }

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/EthFeeHistory.java

@@ -18,6 +18,7 @@
 
 import org.hyperledger.besu.datatypes.Hash;
 import org.hyperledger.besu.datatypes.Wei;
+import org.hyperledger.besu.ethereum.api.ApiConfiguration;
 import org.hyperledger.besu.ethereum.api.jsonrpc.RpcMethod;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.JsonRpcRequestContext;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.parameters.BlockParameter;
@@ -28,6 +29,7 @@
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.response.RpcErrorType;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.FeeHistory;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.ImmutableFeeHistory;
+import org.hyperledger.besu.ethereum.blockcreation.MiningCoordinator;
 import org.hyperledger.besu.ethereum.chain.Blockchain;
 import org.hyperledger.besu.ethereum.core.Block;
 import org.hyperledger.besu.ethereum.core.BlockHeader;
@@ -53,14 +55,22 @@
 public class EthFeeHistory implements JsonRpcMethod {
   private final ProtocolSchedule protocolSchedule;
   private final Blockchain blockchain;
+  private final MiningCoordinator miningCoordinator;
+  private final ApiConfiguration apiConfiguration;
   private final Cache<RewardCacheKey, List<Wei>> cache;
   private static final int MAXIMUM_CACHE_SIZE = 100_000;
 
   record RewardCacheKey(Hash blockHash, List<Double> rewardPercentiles) {}
 
-  public EthFeeHistory(final ProtocolSchedule protocolSchedule, final Blockchain blockchain) {
+  public EthFeeHistory(
+      final ProtocolSchedule protocolSchedule,
+      final Blockchain blockchain,
+      final MiningCoordinator miningCoordinator,
+      final ApiConfiguration apiConfiguration) {
     this.protocolSchedule = protocolSchedule;
     this.blockchain = blockchain;
+    this.miningCoordinator = miningCoordinator;
+    this.apiConfiguration = apiConfiguration;
     this.cache = Caffeine.newBuilder().maximumSize(MAXIMUM_CACHE_SIZE).build();
   }
 
@@ -203,7 +213,16 @@ public List<Wei> computeRewards(final List<Double> rewardPercentiles, final Bloc
     final List<Long> transactionsGasUsed = calculateTransactionsGasUsed(block);
     final List<TransactionInfo> transactionsInfo =
         generateTransactionsInfo(transactions, transactionsGasUsed, baseFee);
-    return calculateRewards(rewardPercentiles, block, transactionsInfo);
+
+    var realRewards = calculateRewards(rewardPercentiles, block, transactionsInfo);
+
+    // If the priority fee boundary is set, return the bounded rewards. Otherwise, return the real
+    // rewards.
+    if (apiConfiguration.isPriorityFeeLimitingEnabled()) {
+      return boundRewards(realRewards);
+    } else {
+      return realRewards;
+    }
   }
 
   private List<Wei> calculateRewards(
@@ -235,6 +254,46 @@ private List<Wei> calculateRewards(
     return rewards;
   }
 
+  /**
+   * This method returns a list of bounded rewards.
+   *
+   * @param rewards The list of rewards to be bounded.
+   * @return The list of bounded rewards.
+   */
+  private List<Wei> boundRewards(final List<Wei> rewards) {
+    Wei minPriorityFee = miningCoordinator.getMinTransactionGasPrice();
+    Wei lowerBound =
+        minPriorityFee.multiply(apiConfiguration.getLowerBoundPriorityFeeCoefficient()).divide(100);
+    Wei upperBound =
+        minPriorityFee.multiply(apiConfiguration.getUpperBoundPriorityFeeCoefficient()).divide(100);
+
+    return rewards.stream().map(reward -> boundReward(reward, lowerBound, upperBound)).toList();
+  }
+
+  /**
+   * This method bounds the reward between a lower and upper limit.
+   *
+   * @param reward The reward to be bounded.
+   * @param lowerBound The lower limit for the reward.
+   * @param upperBound The upper limit for the reward.
+   * @return The bounded reward.
+   */
+  private Wei boundReward(final Wei reward, final Wei lowerBound, final Wei upperBound) {
+
+    // If the reward is less than the lower bound, return the lower bound.
+    if (reward.compareTo(lowerBound) <= 0) {
+      return lowerBound;
+    }
+
+    // If the reward is greater than the upper bound, return the upper bound.
+    if (reward.compareTo(upperBound) > 0) {
+      return upperBound;
+    }
+
+    // If the reward is within the bounds, return the reward as is.
+    return reward;
+  }
+
   private List<Long> calculateTransactionsGasUsed(final Block block) {
     final List<Long> transactionsGasUsed = new ArrayList<>();
     long cumulativeGasUsed = 0L;

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/methods/EthJsonRpcMethods.java

@@ -130,7 +130,11 @@ protected Map<String, JsonRpcMethod> create() {
                 blockchainQueries.getWorldStateArchive(),
                 protocolSchedule,
                 apiConfiguration.getGasCap())),
-        new EthFeeHistory(protocolSchedule, blockchainQueries.getBlockchain()),
+        new EthFeeHistory(
+            protocolSchedule,
+            blockchainQueries.getBlockchain(),
+            miningCoordinator,
+            apiConfiguration),
         new EthGetCode(blockchainQueries),
         new EthGetLogs(blockchainQueries, apiConfiguration.getMaxLogsRange()),
         new EthGetProof(blockchainQueries),

ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/EthFeeHistoryTest.java

@@ -23,8 +23,11 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
+import org.hyperledger.besu.consensus.merge.blockcreation.MergeCoordinator;
 import org.hyperledger.besu.datatypes.Hash;
 import org.hyperledger.besu.datatypes.Wei;
+import org.hyperledger.besu.ethereum.api.ApiConfiguration;
+import org.hyperledger.besu.ethereum.api.ImmutableApiConfiguration;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.JsonRpcRequest;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.JsonRpcRequestContext;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.exception.InvalidJsonRpcParameters;
@@ -35,6 +38,7 @@
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.FeeHistory;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.ImmutableFeeHistory;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.ImmutableFeeHistoryResult;
+import org.hyperledger.besu.ethereum.blockcreation.MiningCoordinator;
 import org.hyperledger.besu.ethereum.chain.Blockchain;
 import org.hyperledger.besu.ethereum.chain.MutableBlockchain;
 import org.hyperledger.besu.ethereum.core.Block;
@@ -64,6 +68,7 @@ public class EthFeeHistoryTest {
   private MutableBlockchain blockchain;
   private EthFeeHistory method;
   private ProtocolSchedule protocolSchedule;
+  private MiningCoordinator miningCoordinator;
 
   @BeforeEach
   public void setUp() {
@@ -72,7 +77,15 @@ public void setUp() {
     blockchain = createInMemoryBlockchain(genesisBlock);
     gen.blockSequence(genesisBlock, 10)
         .forEach(block -> blockchain.appendBlock(block, gen.receipts(block)));
-    method = new EthFeeHistory(protocolSchedule, blockchain);
+    miningCoordinator = mock(MergeCoordinator.class);
+    when(miningCoordinator.getMinTransactionGasPrice()).thenReturn(Wei.ONE);
+
+    method =
+        new EthFeeHistory(
+            protocolSchedule,
+            blockchain,
+            miningCoordinator,
+            ImmutableApiConfiguration.builder().build());
   }
 
   @Test
@@ -121,12 +134,63 @@ public void allFieldsPresentForLatestBlock() {
   public void shouldComputeRewardsCorrectly() {
     // Define the percentiles of rewards we want to compute
     List<Double> rewardPercentiles =
-        Arrays.asList(0.0, 5.0, 10.0, 30.0, 31.0, 59.0, 60.0, 61.0, 100.0);
+        Arrays.asList(0.0, 5.0, 10.0, 27.50, 31.0, 59.0, 60.0, 61.0, 100.0);
+
+    Block block = mock(Block.class);
+    Blockchain blockchain = mockBlockchainTransactionsWithPriorityFee(block);
+
+    EthFeeHistory ethFeeHistory =
+        new EthFeeHistory(
+            null, blockchain, miningCoordinator, ImmutableApiConfiguration.builder().build());
+
+    List<Wei> rewards = ethFeeHistory.computeRewards(rewardPercentiles, block);
 
     // Define the expected rewards for each percentile
     // The expected rewards match the fees of the transactions at each percentile in the
     // rewardPercentiles list
-    List<Wei> expectedRewards = Stream.of(1, 1, 2, 5, 5, 6, 6, 7, 7).map(Wei::of).toList();
+    List<Wei> expectedRewards = Stream.of(1, 1, 2, 4, 5, 6, 6, 7, 7).map(Wei::of).toList();
+
+    // Check that the number of computed rewards is equal to the number of requested percentiles
+    assertThat(rewards.size()).isEqualTo(rewardPercentiles.size());
+    assertThat(expectedRewards).isEqualTo(rewards);
+  }
+
+  @Test
+  public void shouldBoundRewardsCorrectly() {
+    // This test checks that the rewards are correctly bounded by the lower and upper limits.
+    // The lower and upper limits are defined by the lowerBoundPriorityFeeCoefficient and
+    // upperBoundPriorityFeeCoefficient in the ApiConfiguration.
+    // The lower limit is 2.0 (Wei.One * 200L / 100) and the upper limit is 5.0 (Wei.One * 500L /
+    // 100).
+    // The rewards are computed for a list of percentiles, and the expected bounded rewards are
+    // defined for each percentile.
+    // The test checks that the computed rewards match the expected bounded rewards.
+
+    List<Double> rewardPercentiles =
+        Arrays.asList(0.0, 5.0, 10.0, 27.50, 31.0, 59.0, 60.0, 61.0, 100.0);
+
+    Block block = mock(Block.class);
+    Blockchain blockchain = mockBlockchainTransactionsWithPriorityFee(block);
+
+    ApiConfiguration apiConfiguration =
+        ImmutableApiConfiguration.builder()
+            .isPriorityFeeLimitingEnabled(true)
+            .lowerBoundPriorityFeeCoefficient(200L) // Min reward = Wei.One * 200L / 100 = 2.0
+            .upperBoundPriorityFeeCoefficient(500L)
+            .build(); // Max reward = Wei.One * 500L / 100 = 5.0
+
+    EthFeeHistory ethFeeHistory =
+        new EthFeeHistory(null, blockchain, miningCoordinator, apiConfiguration);
+
+    List<Wei> rewards = ethFeeHistory.computeRewards(rewardPercentiles, block);
+
+    // Define the expected bounded rewards for each percentile
+    List<Wei> expectedBoundedRewards = Stream.of(2, 2, 2, 4, 5, 5, 5, 5, 5).map(Wei::of).toList();
+    assertThat(expectedBoundedRewards).isEqualTo(rewards);
+  }
+
+  private Blockchain mockBlockchainTransactionsWithPriorityFee(final Block block) {
+    final Blockchain blockchain = mock(Blockchain.class);
 
     // Define a list of gas used and fee pairs. Each pair represents a transaction in the block.
     // The first number is the gas used by the transaction, and the second number the fee.
@@ -141,21 +205,6 @@ public void shouldComputeRewardsCorrectly() {
     gasUsedAndFee.add(new Object[] {800, 7L}); // 100.0%
     Collections.shuffle(gasUsedAndFee);
 
-    Block block = mock(Block.class);
-    Blockchain blockchain = mockBlockchainTransactionsWithPriorityFee(gasUsedAndFee, block);
-    EthFeeHistory ethFeeHistory = new EthFeeHistory(null, blockchain);
-
-    List<Wei> rewards = ethFeeHistory.computeRewards(rewardPercentiles, block);
-
-    // Check that the number of computed rewards is equal to the number of requested percentiles
-    assertThat(rewards.size()).isEqualTo(rewardPercentiles.size());
-    assertThat(rewards).isEqualTo(expectedRewards);
-  }
-
-  private Blockchain mockBlockchainTransactionsWithPriorityFee(
-      final List<Object[]> gasUsedAndFee, final Block block) {
-    final Blockchain blockchain = mock(Blockchain.class);
-
     when(block.getHash()).thenReturn(Hash.wrap(Bytes32.wrap(Bytes.random(32))));
     BlockBody body = mock(BlockBody.class);
     BlockHeader blockHeader = mock(BlockHeader.class);