Reuse --bonsai-historical-block-limit for limit trie logs feature

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

@@ -3555,12 +3555,12 @@ private String generateConfigurationOverview() {
       builder.setHighSpecEnabled();
     }
 
-    if (dataStorageOptions.toDomainObject().getUnstable().getBonsaiTrieLogPruningEnabled()) {
-      builder.setTrieLogPruningEnabled();
-      builder.setTrieLogRetentionThreshold(
-          dataStorageOptions.toDomainObject().getUnstable().getBonsaiTrieLogRetentionThreshold());
-      builder.setTrieLogPruningLimit(
-          dataStorageOptions.toDomainObject().getUnstable().getBonsaiTrieLogPruningLimit());
+    if (dataStorageOptions.toDomainObject().getUnstable().getBonsaiLimitTrieLogsEnabled()) {
+      builder.setLimitTrieLogsEnabled();
+      builder.setTrieLogRetentionLimit(
+          dataStorageOptions.toDomainObject().getBonsaiMaxLayersToLoad());
+      builder.setTrieLogsPruningWindowSize(
+          dataStorageOptions.toDomainObject().getUnstable().getBonsaiTrieLogPruningWindowSize());
     }
 
     builder.setTxPoolImplementation(buildTransactionPoolConfiguration().getTxPoolImplementation());

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

@@ -52,9 +52,9 @@ public class ConfigurationOverviewBuilder {
   private Collection<String> engineApis;
   private String engineJwtFilePath;
   private boolean isHighSpec = false;
-  private boolean isTrieLogPruningEnabled = false;
-  private long trieLogRetentionThreshold = 0;
-  private Integer trieLogPruningLimit = null;
+  private boolean isBonsaiLimitTrieLogsEnabled = false;
+  private long trieLogRetentionLimit = 0;
+  private Integer trieLogsPruningWindowSize = null;
   private TransactionPoolConfiguration.Implementation txPoolImplementation;
   private EvmConfiguration.WorldUpdaterMode worldStateUpdateMode;
   private Map<String, String> environment;
@@ -199,34 +199,34 @@ public ConfigurationOverviewBuilder setHighSpecEnabled() {
   }
 
   /**
-   * Sets trie log pruning enabled
+   * Sets limit trie logs enabled
    *
    * @return the builder
    */
-  public ConfigurationOverviewBuilder setTrieLogPruningEnabled() {
-    isTrieLogPruningEnabled = true;
+  public ConfigurationOverviewBuilder setLimitTrieLogsEnabled() {
+    isBonsaiLimitTrieLogsEnabled = true;
     return this;
   }
 
   /**
-   * Sets trie log retention threshold
+   * Sets trie log retention limit
    *
-   * @param threshold the number of blocks to retain trie logs for
+   * @param limit the number of blocks to retain trie logs for
    * @return the builder
    */
-  public ConfigurationOverviewBuilder setTrieLogRetentionThreshold(final long threshold) {
-    trieLogRetentionThreshold = threshold;
+  public ConfigurationOverviewBuilder setTrieLogRetentionLimit(final long limit) {
+    trieLogRetentionLimit = limit;
     return this;
   }
 
   /**
-   * Sets trie log pruning limit
+   * Sets trie logs pruning window size
    *
-   * @param limit the max number of blocks to load and prune trie logs for at startup
+   * @param size the max number of blocks to load and prune trie logs for at startup
    * @return the builder
    */
-  public ConfigurationOverviewBuilder setTrieLogPruningLimit(final int limit) {
-    trieLogPruningLimit = limit;
+  public ConfigurationOverviewBuilder setTrieLogsPruningWindowSize(final int size) {
+    trieLogsPruningWindowSize = size;
     return this;
   }
 
@@ -339,13 +339,13 @@ public String build() {
 
     lines.add("Using " + worldStateUpdateMode + " worldstate update mode");
 
-    if (isTrieLogPruningEnabled) {
+    if (isBonsaiLimitTrieLogsEnabled) {
       final StringBuilder trieLogPruningString = new StringBuilder();
       trieLogPruningString
-          .append("Trie log pruning enabled: retention: ")
-          .append(trieLogRetentionThreshold);
-      if (trieLogPruningLimit != null) {
-        trieLogPruningString.append("; prune limit: ").append(trieLogPruningLimit);
+          .append("Limit trie logs enabled: retention: ")
+          .append(trieLogRetentionLimit);
+      if (trieLogsPruningWindowSize != null) {
+        trieLogPruningString.append("; prune window: ").append(trieLogsPruningWindowSize);
       }
       lines.add(trieLogPruningString.toString());
     }

besu/src/main/java/org/hyperledger/besu/cli/options/stable/DataStorageOptions.java

@@ -17,10 +17,9 @@
 package org.hyperledger.besu.cli.options.stable;
 
 import static org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration.DEFAULT_BONSAI_MAX_LAYERS_TO_LOAD;
-import static org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration.Unstable.DEFAULT_BONSAI_TRIE_LOG_PRUNING_ENABLED;
-import static org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration.Unstable.DEFAULT_BONSAI_TRIE_LOG_PRUNING_LIMIT;
-import static org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration.Unstable.DEFAULT_BONSAI_TRIE_LOG_RETENTION_THRESHOLD;
-import static org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration.Unstable.MINIMUM_BONSAI_TRIE_LOG_RETENTION_THRESHOLD;
+import static org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration.Unstable.DEFAULT_BONSAI_LIMIT_TRIE_LOGS_ENABLED;
+import static org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration.Unstable.DEFAULT_BONSAI_TRIE_LOG_PRUNING_WINDOW_SIZE;
+import static org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration.Unstable.MINIMUM_BONSAI_TRIE_LOG_RETENTION_LIMIT;
 
 import org.hyperledger.besu.cli.options.CLIOptions;
 import org.hyperledger.besu.cli.util.CommandLineUtils;
@@ -39,7 +38,8 @@ public class DataStorageOptions implements CLIOptions<DataStorageConfiguration>
 
   private static final String DATA_STORAGE_FORMAT = "--data-storage-format";
 
-  private static final String BONSAI_STORAGE_FORMAT_MAX_LAYERS_TO_LOAD =
+  /** The maximum number of historical layers to load. */
+  public static final String BONSAI_STORAGE_FORMAT_MAX_LAYERS_TO_LOAD =
       "--bonsai-historical-block-limit";
 
   // Use Bonsai DB
@@ -54,39 +54,37 @@ public class DataStorageOptions implements CLIOptions<DataStorageConfiguration>
       names = {BONSAI_STORAGE_FORMAT_MAX_LAYERS_TO_LOAD, "--bonsai-maximum-back-layers-to-load"},
       paramLabel = "<LONG>",
       description =
-          "Limit of historical layers that can be loaded with BONSAI (default: ${DEFAULT-VALUE}).",
+          "Limit of historical layers that can be loaded with BONSAI (default: ${DEFAULT-VALUE}). When using "
+              + Unstable.BONSAI_LIMIT_TRIE_LOGS_ENABLED
+              + " it will also be used as the number of layers of trie logs to retain.",
       arity = "1")
   private Long bonsaiMaxLayersToLoad = DEFAULT_BONSAI_MAX_LAYERS_TO_LOAD;
 
   @CommandLine.ArgGroup(validate = false)
   private final DataStorageOptions.Unstable unstableOptions = new Unstable();
 
-  static class Unstable {
+  /** The unstable options for data storage. */
+  public static class Unstable {
     private static final String BONSAI_LIMIT_TRIE_LOGS_ENABLED =
         "--Xbonsai-limit-trie-logs-enabled";
-    private static final String BONSAI_TRIE_LOGS_RETENTION_THRESHOLD =
-        "--Xbonsai-trie-logs-retention-threshold";
-    private static final String BONSAI_TRIE_LOG_PRUNING_LIMIT = "--Xbonsai-trie-logs-pruning-limit";
 
-    @CommandLine.Option(
-        hidden = true,
-        names = {BONSAI_LIMIT_TRIE_LOGS_ENABLED},
-        description = "Enable trie log pruning. (default: ${DEFAULT-VALUE})")
-    private boolean bonsaiTrieLogPruningEnabled = DEFAULT_BONSAI_TRIE_LOG_PRUNING_ENABLED;
+    /** The bonsai trie logs pruning window size. */
+    public static final String BONSAI_TRIE_LOG_PRUNING_WINDOW_SIZE =
+        "--Xbonsai-trie-logs-pruning-window-size";
 
     @CommandLine.Option(
         hidden = true,
-        names = {BONSAI_TRIE_LOGS_RETENTION_THRESHOLD},
+        names = {BONSAI_LIMIT_TRIE_LOGS_ENABLED},
         description =
-            "The number of blocks for which to retain trie logs. (default: ${DEFAULT-VALUE})")
-    private long bonsaiTrieLogRetentionThreshold = DEFAULT_BONSAI_TRIE_LOG_RETENTION_THRESHOLD;
+            "Limit the number of trie logs that are retained. (default: ${DEFAULT-VALUE})")
+    private boolean bonsaiLimitTrieLogsEnabled = DEFAULT_BONSAI_LIMIT_TRIE_LOGS_ENABLED;
 
     @CommandLine.Option(
         hidden = true,
-        names = {BONSAI_TRIE_LOG_PRUNING_LIMIT},
+        names = {BONSAI_TRIE_LOG_PRUNING_WINDOW_SIZE},
         description =
             "The max number of blocks to load and prune trie logs for at startup. (default: ${DEFAULT-VALUE})")
-    private int bonsaiTrieLogPruningLimit = DEFAULT_BONSAI_TRIE_LOG_PRUNING_LIMIT;
+    private int bonsaiTrieLogPruningWindowSize = DEFAULT_BONSAI_TRIE_LOG_PRUNING_WINDOW_SIZE;
   }
   /**
    * Create data storage options.
@@ -103,21 +101,31 @@ public static DataStorageOptions create() {
    * @param commandLine the full commandLine to check all the options specified by the user
    */
   public void validate(final CommandLine commandLine) {
-    if (unstableOptions.bonsaiTrieLogPruningEnabled) {
-      if (unstableOptions.bonsaiTrieLogRetentionThreshold
-          < MINIMUM_BONSAI_TRIE_LOG_RETENTION_THRESHOLD) {
+    if (unstableOptions.bonsaiLimitTrieLogsEnabled) {
+      if (bonsaiMaxLayersToLoad < MINIMUM_BONSAI_TRIE_LOG_RETENTION_LIMIT) {
+        throw new CommandLine.ParameterException(
+            commandLine,
+            String.format(
+                BONSAI_STORAGE_FORMAT_MAX_LAYERS_TO_LOAD + " minimum value is %d",
+                MINIMUM_BONSAI_TRIE_LOG_RETENTION_LIMIT));
+      }
+      if (unstableOptions.bonsaiTrieLogPruningWindowSize <= 0) {
         throw new CommandLine.ParameterException(
             commandLine,
             String.format(
-                "--Xbonsai-trie-log-retention-threshold minimum value is %d",
-                MINIMUM_BONSAI_TRIE_LOG_RETENTION_THRESHOLD));
+                Unstable.BONSAI_TRIE_LOG_PRUNING_WINDOW_SIZE + "=%d must be greater than 0",
+                unstableOptions.bonsaiTrieLogPruningWindowSize));
       }
-      if (unstableOptions.bonsaiTrieLogPruningLimit <= 0) {
+      if (unstableOptions.bonsaiTrieLogPruningWindowSize <= bonsaiMaxLayersToLoad) {
         throw new CommandLine.ParameterException(
             commandLine,
             String.format(
-                "--Xbonsai-trie-log-pruning-limit=%d must be greater than 0",
-                unstableOptions.bonsaiTrieLogPruningLimit));
+                Unstable.BONSAI_TRIE_LOG_PRUNING_WINDOW_SIZE
+                    + "=%d must be greater than "
+                    + BONSAI_STORAGE_FORMAT_MAX_LAYERS_TO_LOAD
+                    + "=%d",
+                unstableOptions.bonsaiTrieLogPruningWindowSize,
+                bonsaiMaxLayersToLoad));
       }
     }
   }
@@ -126,12 +134,10 @@ static DataStorageOptions fromConfig(final DataStorageConfiguration domainObject
     final DataStorageOptions dataStorageOptions = DataStorageOptions.create();
     dataStorageOptions.dataStorageFormat = domainObject.getDataStorageFormat();
     dataStorageOptions.bonsaiMaxLayersToLoad = domainObject.getBonsaiMaxLayersToLoad();
-    dataStorageOptions.unstableOptions.bonsaiTrieLogPruningEnabled =
-        domainObject.getUnstable().getBonsaiTrieLogPruningEnabled();
-    dataStorageOptions.unstableOptions.bonsaiTrieLogRetentionThreshold =
-        domainObject.getUnstable().getBonsaiTrieLogRetentionThreshold();
-    dataStorageOptions.unstableOptions.bonsaiTrieLogPruningLimit =
-        domainObject.getUnstable().getBonsaiTrieLogPruningLimit();
+    dataStorageOptions.unstableOptions.bonsaiLimitTrieLogsEnabled =
+        domainObject.getUnstable().getBonsaiLimitTrieLogsEnabled();
+    dataStorageOptions.unstableOptions.bonsaiTrieLogPruningWindowSize =
+        domainObject.getUnstable().getBonsaiTrieLogPruningWindowSize();
 
     return dataStorageOptions;
   }
@@ -143,9 +149,8 @@ public DataStorageConfiguration toDomainObject() {
         .bonsaiMaxLayersToLoad(bonsaiMaxLayersToLoad)
         .unstable(
             ImmutableDataStorageConfiguration.Unstable.builder()
-                .bonsaiTrieLogPruningEnabled(unstableOptions.bonsaiTrieLogPruningEnabled)
-                .bonsaiTrieLogRetentionThreshold(unstableOptions.bonsaiTrieLogRetentionThreshold)
-                .bonsaiTrieLogPruningLimit(unstableOptions.bonsaiTrieLogPruningLimit)
+                .bonsaiLimitTrieLogsEnabled(unstableOptions.bonsaiLimitTrieLogsEnabled)
+                .bonsaiTrieLogPruningWindowSize(unstableOptions.bonsaiTrieLogPruningWindowSize)
                 .build())
         .build();
   }