fix(chainbase,net,plugins): defensive numeric and structural fixes

- TransactionTrace: add zero-check guard before newArea/newSize division
  in resetAccountUsage() and resetAccountUsageV2() to prevent
  ArithmeticException when window size is zero
- ResilienceService: replace all new Random() with
  ThreadLocalRandom.current() to avoid unnecessary object allocation;
  remove Random field from WeightedRandom inner class
- DbConvert: merge parallel List<byte[]> (keys/values) into single
  List<Map.Entry<byte[], byte[]>> to eliminate index-mismatch risk

Author: Barbatos

chainbase/src/main/java/org/tron/core/db/TransactionTrace.java

@@ -300,6 +300,11 @@ private void resetAccountUsage(AccountCapsule accountCap,
         - (mergedUsage * mergedSize - usage * size);
     // If area merging happened during suicide, use the current window size
     long newSize = mergedSize == currentSize ? size : currentSize;
+    if (newSize == 0) {
+      accountCap.setEnergyUsage(0);
+      accountCap.setNewWindowSize(ENERGY, 0L);
+      return;
+    }
     // Calc new usage by fixed x-axes
     long newUsage = max(0, newArea / newSize, dynamicPropertiesStore.disableJavaLangMath());
     // Reset account usage and window size
@@ -317,6 +322,11 @@ private void resetAccountUsageV2(AccountCapsule accountCap,
     // If area merging happened during suicide, use the current window size
     long newSize = mergedSize == currentSize ? size : currentSize;
     long newSize2 = mergedSize == currentSize ? size2 : currentSize2;
+    if (newSize == 0) {
+      accountCap.setEnergyUsage(0);
+      accountCap.setNewWindowSizeV2(ENERGY, 0L);
+      return;
+    }
     // Calc new usage by fixed x-axes
     long newUsage = max(0, newArea / newSize, dynamicPropertiesStore.disableJavaLangMath());
     // Reset account usage and window size

framework/src/main/java/org/tron/core/net/service/effective/ResilienceService.java

@@ -8,8 +8,8 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.Random;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 import lombok.extern.slf4j.Slf4j;
@@ -114,7 +114,7 @@ private void disconnectRandom() {
           .collect(Collectors.toList());
     }
     if (!peers.isEmpty()) {
-      int index = new Random().nextInt(peers.size());
+      int index = ThreadLocalRandom.current().nextInt(peers.size());
       disconnectFromPeer(peers.get(index), ReasonCode.RANDOM_ELIMINATION,
           DisconnectCause.RANDOM_ELIMINATION);
     }
@@ -236,19 +236,17 @@ private enum DisconnectCause {
   static class WeightedRandom {
 
     private final Map<Object, Integer> weights;
-    private final Random random;
 
     public WeightedRandom(Map<Object, Integer> weights) {
       this.weights = weights;
-      this.random = new Random();
     }
 
     public Object next() {
       int totalWeight = 0;
       for (int weight : weights.values()) {
         totalWeight += weight;
       }
-      int randomNum = random.nextInt(totalWeight);
+      int randomNum = ThreadLocalRandom.current().nextInt(totalWeight);
       for (Object key : weights.keySet()) {
         randomNum -= weights.get(key);
         if (randomNum < 0) {

framework/src/test/java/org/tron/core/db/TransactionTraceTest.java

@@ -18,6 +18,7 @@
 import com.google.protobuf.Any;
 import com.google.protobuf.ByteString;
 import com.google.protobuf.InvalidProtocolBufferException;
+import java.lang.reflect.Method;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
@@ -45,6 +46,7 @@
 import org.tron.protos.Protocol.Transaction.Contract.ContractType;
 import org.tron.protos.Protocol.Transaction.raw;
 import org.tron.protos.contract.SmartContractOuterClass.CreateSmartContract;
+import org.tron.protos.contract.Common.ResourceCode;
 import org.tron.protos.contract.SmartContractOuterClass.SmartContract;
 import org.tron.protos.contract.SmartContractOuterClass.TriggerSmartContract;
 
@@ -446,4 +448,76 @@ public void testTriggerUseUsageInWindowSizeV2() throws VMIllegalException, Contr
     dbManager.getDynamicPropertiesStore().saveUnfreezeDelayDays(0);
     dbManager.getDynamicPropertiesStore().saveAllowCancelAllUnfreezeV2(0);
   }
+
+  @Test
+  public void testResetAccountUsage_zeroNewSize() throws Exception {
+    // Ensure V1 path (not V2)
+    dbManager.getDynamicPropertiesStore().saveAllowCancelAllUnfreezeV2(0);
+
+    AccountCapsule account = new AccountCapsule(
+        ByteString.copyFromUtf8("testZeroSize"),
+        ByteString.copyFrom(ByteArray.fromInt(99)),
+        AccountType.Normal,
+        0L);
+    // currentSize = 100, currentUsage = 500
+    account.setNewWindowSize(ResourceCode.ENERGY, 100L);
+    account.setEnergyUsage(500L);
+
+    // Build a minimal TransactionTrace to access the private method
+    Transaction trxn = Transaction.newBuilder().setRawData(
+        raw.newBuilder().addContract(
+            Contract.newBuilder().setType(ContractType.TransferContract))).build();
+    TransactionCapsule trxCap = new TransactionCapsule(trxn);
+    TransactionTrace trace = new TransactionTrace(trxCap, StoreFactory.getInstance(),
+        new RuntimeImpl());
+
+    // Use reflection to call private resetAccountUsage
+    Method method = TransactionTrace.class.getDeclaredMethod("resetAccountUsage",
+        AccountCapsule.class, long.class, long.class, long.class, long.class, long.class);
+    method.setAccessible(true);
+
+    // mergedSize == currentSize (100) and size == 0 → newSize = 0
+    method.invoke(trace, account, /*usage=*/0L, /*size=*/0L,
+        /*mergedUsage=*/0L, /*mergedSize=*/100L, /*size2=*/0L);
+
+    // energyUsage should be reset to 0 by the newSize == 0 guard
+    Assert.assertEquals(0L, account.getEnergyUsage());
+    // windowSize internal value is 0, but getWindowSize() returns default 28800 when 0
+    Assert.assertEquals(0L,
+        account.getInstance().getAccountResource().getEnergyWindowSize());
+  }
+
+  @Test
+  public void testResetAccountUsageV2_zeroNewSize() throws Exception {
+    // Ensure V2 path
+    dbManager.getDynamicPropertiesStore().saveAllowCancelAllUnfreezeV2(1);
+
+    AccountCapsule account = new AccountCapsule(
+        ByteString.copyFromUtf8("testZeroSizeV2"),
+        ByteString.copyFrom(ByteArray.fromInt(98)),
+        AccountType.Normal,
+        0L);
+    account.setNewWindowSize(ResourceCode.ENERGY, 100L);
+    account.setEnergyUsage(500L);
+
+    Transaction trxn = Transaction.newBuilder().setRawData(
+        raw.newBuilder().addContract(
+            Contract.newBuilder().setType(ContractType.TransferContract))).build();
+    TransactionCapsule trxCap = new TransactionCapsule(trxn);
+    TransactionTrace trace = new TransactionTrace(trxCap, StoreFactory.getInstance(),
+        new RuntimeImpl());
+
+    Method method = TransactionTrace.class.getDeclaredMethod("resetAccountUsage",
+        AccountCapsule.class, long.class, long.class, long.class, long.class, long.class);
+    method.setAccessible(true);
+
+    // mergedSize == currentSize (100) and size == 0 → newSize = 0
+    method.invoke(trace, account, /*usage=*/0L, /*size=*/0L,
+        /*mergedUsage=*/0L, /*mergedSize=*/100L, /*size2=*/0L);
+
+    Assert.assertEquals(0L, account.getEnergyUsage());
+
+    // Restore
+    dbManager.getDynamicPropertiesStore().saveAllowCancelAllUnfreezeV2(0);
+  }
 }

plugins/src/main/java/common/org/tron/plugins/DbConvert.java

@@ -3,6 +3,7 @@
 import java.io.File;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.AbstractMap;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -201,18 +202,15 @@ public String name() {
       return dbName;
     }
 
-    private void batchInsert(RocksDB rocks, List<byte[]> keys, List<byte[]> values)
+    private void batchInsert(RocksDB rocks, List<Map.Entry<byte[], byte[]>> entries)
         throws Exception {
       try (org.rocksdb.WriteBatch batch = new org.rocksdb.WriteBatch()) {
-        for (int i = 0; i < keys.size(); i++) {
-          byte[] k = keys.get(i);
-          byte[] v = values.get(i);
-          batch.put(k, v);
+        for (Map.Entry<byte[], byte[]> entry : entries) {
+          batch.put(entry.getKey(), entry.getValue());
         }
         write(rocks, batch);
       }
-      keys.clear();
-      values.clear();
+      entries.clear();
     }
 
     /**
@@ -254,8 +252,7 @@ private boolean maybeRetry(RocksDBException e) {
      * @return if ok
      */
     public void convertLevelToRocks() throws Exception {
-      List<byte[]> keys = new ArrayList<>(BATCH);
-      List<byte[]> values = new ArrayList<>(BATCH);
+      List<Map.Entry<byte[], byte[]>> entries = new ArrayList<>(BATCH);
       JniDBFactory.pushMemoryPool(1024 * 1024);
       try (
           DB level = DBUtils.newLevelDb(srcDbPath);
@@ -273,15 +270,14 @@ public void convertLevelToRocks() throws Exception {
           srcDbKeyCount++;
           srcDbKeySum = byteArrayToIntWithOne(srcDbKeySum, key);
           srcDbValueSum = byteArrayToIntWithOne(srcDbValueSum, value);
-          keys.add(key);
-          values.add(value);
-          if (keys.size() >= BATCH) {
-            batchInsert(rocks, keys, values);
+          entries.add(new AbstractMap.SimpleEntry<>(key, value));
+          if (entries.size() >= BATCH) {
+            batchInsert(rocks, entries);
           }
         }
         // clear
-        if (!keys.isEmpty()) {
-          batchInsert(rocks, keys, values);
+        if (!entries.isEmpty()) {
+          batchInsert(rocks, entries);
         }
       } finally {
         JniDBFactory.popMemoryPool();