refactor(config): move storage clamp/validation into bean postProcess

Address PR review from lxcmyf (2026-04-22, Args.java:255) — architectural
consistency with NodeConfig / VmConfig / CommitteeConfig where clamps and
validation live in the bean's own postProcess().

Before: Args.applyStorageConfig held an inline clamp for
estimatedTransactions ([100, 10000]) and an inline range check for
maxFlushCount ((0, 500]). This was carried over from develop's static
Storage helpers during the bean-binding refactor.

Now:
- SnapshotConfig.postProcess() enforces maxFlushCount in (0, 500],
  throwing IllegalArgumentException on violation (same messages as develop).
- TxCacheConfig.postProcess() clamps estimatedTransactions to [100, 10000].
- StorageConfig.fromConfig() calls both alongside the existing
  dbSettings.postProcess().
- Args.applyStorageConfig now simply reads already-validated values.

This also lets StorageConfig enforce its invariants when loaded standalone
(e.g. in tests) without depending on the Args bridge.

Tests (StorageConfigTest):
- testSnapshotMaxFlushCountZeroRejected
- testSnapshotMaxFlushCountNegativeRejected
- testSnapshotMaxFlushCountOver500Rejected
- testTxCacheEstimatedClampedBelowMin
- testTxCacheEstimatedClampedAboveMax
- testTxCacheEstimatedWithinRangePreserved

Author: vividctrlalt

common/src/main/java/org/tron/core/config/args/StorageConfig.java

@@ -162,13 +162,32 @@ public static class CheckpointConfig {
   @Setter
   public static class SnapshotConfig {
     private int maxFlushCount = 1;
+
+    // Reject out-of-range values. Mirrors develop Storage.getSnapshotMaxFlushCountFromConfig.
+    void postProcess() {
+      if (maxFlushCount <= 0) {
+        throw new IllegalArgumentException("MaxFlushCount value can not be negative or zero!");
+      }
+      if (maxFlushCount > 500) {
+        throw new IllegalArgumentException("MaxFlushCount value must not exceed 500!");
+      }
+    }
   }
 
   @Getter
   @Setter
   public static class TxCacheConfig {
     private int estimatedTransactions = 1000;
     private boolean initOptimization = false;
+
+    // Clamp to [100, 10000]. Mirrors develop Storage.getEstimatedTransactionsFromConfig.
+    void postProcess() {
+      if (estimatedTransactions > 10000) {
+        estimatedTransactions = 10000;
+      } else if (estimatedTransactions < 100) {
+        estimatedTransactions = 100;
+      }
+    }
   }
 
   @Getter
@@ -200,6 +219,8 @@ public static StorageConfig fromConfig(Config config) {
     sc.defaultLDbOption = readDbOption(section, "defaultL");
 
     sc.dbSettings.postProcess();
+    sc.snapshot.postProcess();
+    sc.txCache.postProcess();
     return sc;
   }
 

common/src/test/java/org/tron/core/config/args/StorageConfigTest.java

@@ -103,4 +103,40 @@ public void testBalanceHistoryLookup() {
     StorageConfig sc = StorageConfig.fromConfig(config);
     assertTrue(sc.getBalance().getHistory().isLookup());
   }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testSnapshotMaxFlushCountZeroRejected() {
+    StorageConfig.fromConfig(withRef("storage.snapshot.maxFlushCount = 0"));
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testSnapshotMaxFlushCountNegativeRejected() {
+    StorageConfig.fromConfig(withRef("storage.snapshot.maxFlushCount = -1"));
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testSnapshotMaxFlushCountOver500Rejected() {
+    StorageConfig.fromConfig(withRef("storage.snapshot.maxFlushCount = 501"));
+  }
+
+  @Test
+  public void testTxCacheEstimatedClampedBelowMin() {
+    StorageConfig sc = StorageConfig.fromConfig(
+        withRef("storage.txCache.estimatedTransactions = 50"));
+    assertEquals(100, sc.getTxCache().getEstimatedTransactions());
+  }
+
+  @Test
+  public void testTxCacheEstimatedClampedAboveMax() {
+    StorageConfig sc = StorageConfig.fromConfig(
+        withRef("storage.txCache.estimatedTransactions = 99999"));
+    assertEquals(10000, sc.getTxCache().getEstimatedTransactions());
+  }
+
+  @Test
+  public void testTxCacheEstimatedWithinRangePreserved() {
+    StorageConfig sc = StorageConfig.fromConfig(
+        withRef("storage.txCache.estimatedTransactions = 5000"));
+    assertEquals(5000, sc.getTxCache().getEstimatedTransactions());
+  }
 }

framework/src/main/java/org/tron/core/config/args/Args.java

@@ -235,25 +235,11 @@ private static void applyStorageConfig(StorageConfig sc) {
     PARAMETER.storage.setCheckpointVersion(sc.getCheckpoint().getVersion());
     PARAMETER.storage.setCheckpointSync(sc.getCheckpoint().isSync());
 
-    // estimatedTransactions with range clamping [100, 10000]
-    int estimated = sc.getTxCache().getEstimatedTransactions();
-    if (estimated > 10000) {
-      estimated = 10000;
-    } else if (estimated < 100) {
-      estimated = 100;
-    }
-    PARAMETER.storage.setEstimatedBlockTransactions(estimated);
+    // estimatedTransactions / maxFlushCount clamping & validation run inside
+    // TxCacheConfig.postProcess / SnapshotConfig.postProcess during bean load.
+    PARAMETER.storage.setEstimatedBlockTransactions(sc.getTxCache().getEstimatedTransactions());
     PARAMETER.storage.setTxCacheInitOptimization(sc.getTxCache().isInitOptimization());
-
-    // snapshotMaxFlushCount with range validation
-    int maxFlush = sc.getSnapshot().getMaxFlushCount();
-    if (maxFlush <= 0) {
-      throw new IllegalArgumentException("MaxFlushCount value can not be negative or zero!");
-    }
-    if (maxFlush > 500) {
-      throw new IllegalArgumentException("MaxFlushCount value must not exceed 500!");
-    }
-    PARAMETER.storage.setMaxFlushCount(maxFlush);
+    PARAMETER.storage.setMaxFlushCount(sc.getSnapshot().getMaxFlushCount());
 
     // backup
     StorageConfig.BackupConfig backup = sc.getBackup();