fix(consensus): use Locale.ROOT for case-insensitive string operations

String.toLowerCase()/toUpperCase() without an explicit Locale uses
Locale.getDefault(), which on Turkish (tr) or Azerbaijani (az) systems
folds 'I' to dotless-ı (U+0131) instead of 'i' (U+0069). This caused
AccountIdIndexStore to generate different index keys on tr/az nodes,
enabling a consensus split where tr/az nodes accept duplicate accountId
transactions that other nodes reject.

Fix AccountIdIndexStore.getLowerCaseAccountId to use Locale.ROOT, and
add a legacy fallback in get()/has() so that tr/az nodes can still
read old data stored with the locale-sensitive key.

Also fix all other toLowerCase()/toUpperCase() calls across the
codebase and enable the built-in ErrorProne StringCaseLocaleUsage
checker at ERROR level to prevent future regressions at compile time.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: halibobo1205

actuator/src/main/java/org/tron/core/actuator/AssetIssueActuator.java

@@ -22,6 +22,7 @@
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Locale;
 import java.util.Objects;
 import lombok.extern.slf4j.Slf4j;
 import org.tron.common.math.StrictMathWrapper;
@@ -166,7 +167,7 @@ public boolean validate() throws ContractValidateException {
     }
 
     if (dynamicStore.getAllowSameTokenName() != 0) {
-      String name = assetIssueContract.getName().toStringUtf8().toLowerCase();
+      String name = assetIssueContract.getName().toStringUtf8().toLowerCase(Locale.ROOT);
       if (("trx").equals(name)) {
         throw new ContractValidateException("assetName can't be trx");
       }

build.gradle

@@ -1,10 +1,16 @@
 import org.gradle.nativeplatform.platform.internal.Architectures
 import org.gradle.internal.os.OperatingSystem
+
+plugins {
+    id 'net.ltgt.errorprone' version '5.0.0' apply false
+}
+
 allprojects {
     version = "1.0.0"
     apply plugin: "java-library"
     ext {
         springVersion = "5.3.39"
+        errorproneVersion = "2.42.0"
     }
 }
 def arch = System.getProperty("os.arch").toLowerCase()
@@ -107,6 +113,26 @@ subprojects {
         testImplementation "org.mockito:mockito-core:4.11.0"
         testImplementation "org.mockito:mockito-inline:4.11.0"
     }
+    if (project.name != 'protocol' && project.name != 'errorprone'
+            && javaVersion.isJava11Compatible()) {
+        apply plugin: 'net.ltgt.errorprone'
+        dependencies {
+            errorprone "com.google.errorprone:error_prone_core:${errorproneVersion}"
+            errorprone rootProject.project(':errorprone')
+        }
+        tasks.withType(JavaCompile).configureEach {
+            options.errorprone {
+                enabled = true
+                disableWarningsInGeneratedCode = true
+                disableAllChecks = true
+                excludedPaths = '.*/generated/.*'
+                errorproneArgs.addAll([
+                        '-Xep:StringCaseLocaleUsage:ERROR',
+                        '-Xep:StringCaseLocaleUsageMethodRef:ERROR',
+                ])
+            }
+        }
+    }
 
     task sourcesJar(type: Jar, dependsOn: classes) {
         classifier = "sources"

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

@@ -2,6 +2,7 @@
 
 import com.google.protobuf.InvalidProtocolBufferException;
 import java.nio.file.Paths;
+import java.util.Locale;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -37,10 +38,10 @@ protected TronDatabase(String dbName) {
     this.dbName = dbName;
 
     if ("LEVELDB".equals(CommonParameter.getInstance().getStorage()
-        .getDbEngine().toUpperCase())) {
+        .getDbEngine().toUpperCase(Locale.ROOT))) {
       dbSource = new LevelDbDataSourceImpl(StorageUtils.getOutputDirectoryByDbName(dbName), dbName);
     } else if ("ROCKSDB".equals(CommonParameter.getInstance()
-        .getStorage().getDbEngine().toUpperCase())) {
+        .getStorage().getDbEngine().toUpperCase(Locale.ROOT))) {
       String parentName = Paths.get(StorageUtils.getOutputDirectoryByDbName(dbName),
           CommonParameter.getInstance().getStorage().getDbDirectory()).toString();
       dbSource = new RocksDbDataSourceImpl(parentName, dbName);

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

@@ -5,6 +5,7 @@
 import com.google.common.collect.Streams;
 import com.google.common.reflect.TypeToken;
 import java.io.IOException;
+import java.util.Locale;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.nio.file.Paths;
@@ -54,10 +55,10 @@ public abstract class TronStoreWithRevoking<T extends ProtoCapsule> implements I
 
   protected TronStoreWithRevoking(String dbName) {
     String dbEngine = CommonParameter.getInstance().getStorage().getDbEngine();
-    if ("LEVELDB".equals(dbEngine.toUpperCase())) {
+    if ("LEVELDB".equals(dbEngine.toUpperCase(Locale.ROOT))) {
       this.db =  new LevelDB(
           new LevelDbDataSourceImpl(StorageUtils.getOutputDirectoryByDbName(dbName), dbName));
-    } else if ("ROCKSDB".equals(dbEngine.toUpperCase())) {
+    } else if ("ROCKSDB".equals(dbEngine.toUpperCase(Locale.ROOT))) {
       String parentPath = Paths
           .get(StorageUtils.getOutputDirectoryByDbName(dbName), CommonParameter
               .getInstance().getStorage().getDbDirectory()).toString();

chainbase/src/main/java/org/tron/core/db2/common/TxCacheDB.java

@@ -20,6 +20,7 @@
 import java.nio.file.Paths;
 import java.nio.file.StandardOpenOption;
 import java.util.Iterator;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Objects;
@@ -102,10 +103,10 @@ public TxCacheDB(String name, RecentTransactionStore recentTransactionStore,
     this.recentTransactionStore = recentTransactionStore;
     this.dynamicPropertiesStore = dynamicPropertiesStore;
     String dbEngine = CommonParameter.getInstance().getStorage().getDbEngine();
-    if ("LEVELDB".equals(dbEngine.toUpperCase())) {
+    if ("LEVELDB".equals(dbEngine.toUpperCase(Locale.ROOT))) {
       this.persistentStore = new LevelDB(
           new LevelDbDataSourceImpl(StorageUtils.getOutputDirectoryByDbName(name), name));
-    } else if ("ROCKSDB".equals(dbEngine.toUpperCase())) {
+    } else if ("ROCKSDB".equals(dbEngine.toUpperCase(Locale.ROOT))) {
       String parentPath = Paths
           .get(StorageUtils.getOutputDirectoryByDbName(name), CommonParameter
               .getInstance().getStorage().getDbDirectory()).toString();

chainbase/src/main/java/org/tron/core/store/AccountIdIndexStore.java

@@ -1,6 +1,8 @@
 package org.tron.core.store;
 
 import com.google.protobuf.ByteString;
+import java.util.Arrays;
+import java.util.Locale;
 import java.util.Objects;
 import org.apache.commons.lang3.ArrayUtils;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -14,14 +16,42 @@
 @Component
 public class AccountIdIndexStore extends TronStoreWithRevoking<BytesCapsule> {
 
+  private static final Locale TURKISH = Locale.forLanguageTag("tr");
+
+  /**
+   * True when this JVM runs under a Turkish or Azerbaijani locale,
+   * meaning legacy data with dotless-ı keys may exist in the local database.
+   */
+  private static final boolean IS_TURKISH_LIKE_LOCALE;
+
+  static {
+    String lang = Locale.getDefault().getLanguage();
+    IS_TURKISH_LIKE_LOCALE = "tr".equals(lang) || "az".equals(lang);
+  }
+
   @Autowired
   public AccountIdIndexStore(@Value("accountid-index") String dbName) {
     super(dbName);
   }
 
-  private static byte[] getLowerCaseAccountId(byte[] bsAccountId) {
+  public static byte[] getLowerCaseAccountId(byte[] bsAccountId) {
     return ByteString
-        .copyFromUtf8(ByteString.copyFrom(bsAccountId).toStringUtf8().toLowerCase()).toByteArray();
+        .copyFromUtf8(ByteString.copyFrom(bsAccountId).toStringUtf8().toLowerCase(Locale.ROOT))
+        .toByteArray();
+  }
+
+  /**
+   * Compute the legacy Turkish-locale key: uppercase with ROOT first to
+   * normalize case, then lowercase with Turkish locale ('I' → 'ı').
+   * This produces the same key a pre-fix tr/az node would have stored,
+   * regardless of the input's original case.
+   */
+  @SuppressWarnings("StringCaseLocaleUsage")
+  private static byte[] getTurkishLegacyKey(byte[] bsAccountId) {
+    String str = ByteString.copyFrom(bsAccountId).toStringUtf8();
+    return ByteString
+        .copyFromUtf8(str.toUpperCase(Locale.ROOT).toLowerCase(TURKISH))
+        .toByteArray();
   }
 
   public void put(AccountCapsule accountCapsule) {
@@ -41,6 +71,12 @@ public byte[] get(ByteString name) {
   public BytesCapsule get(byte[] key) {
     byte[] lowerCaseKey = getLowerCaseAccountId(key);
     byte[] value = revokingDB.getUnchecked(lowerCaseKey);
+    if (ArrayUtils.isEmpty(value) && IS_TURKISH_LIKE_LOCALE) {
+      byte[] legacyKey = getTurkishLegacyKey(key);
+      if (!Arrays.equals(lowerCaseKey, legacyKey)) {
+        value = revokingDB.getUnchecked(legacyKey);
+      }
+    }
     if (ArrayUtils.isEmpty(value)) {
       return null;
     }
@@ -51,7 +87,13 @@ public BytesCapsule get(byte[] key) {
   public boolean has(byte[] key) {
     byte[] lowerCaseKey = getLowerCaseAccountId(key);
     byte[] value = revokingDB.getUnchecked(lowerCaseKey);
+    if (ArrayUtils.isEmpty(value) && IS_TURKISH_LIKE_LOCALE) {
+      byte[] legacyKey = getTurkishLegacyKey(key);
+      if (!Arrays.equals(lowerCaseKey, legacyKey)) {
+        value = revokingDB.getUnchecked(legacyKey);
+      }
+    }
     return !ArrayUtils.isEmpty(value);
   }
 
-}
+}

common/src/main/java/org/tron/common/args/Account.java

@@ -17,6 +17,7 @@
 
 import com.google.protobuf.ByteString;
 import java.io.Serializable;
+import java.util.Locale;
 import lombok.Getter;
 import org.apache.commons.lang3.StringUtils;
 import org.tron.common.utils.ByteArray;
@@ -120,7 +121,7 @@ public boolean isAccountType(final String accountType) {
       return false;
     }
 
-    switch (accountType.toUpperCase()) {
+    switch (accountType.toUpperCase(Locale.ROOT)) {
       case ACCOUNT_TYPE_NORMAL:
       case ACCOUNT_TYPE_ASSETISSUE:
       case ACCOUNT_TYPE_CONTRACT:
@@ -138,7 +139,7 @@ public AccountType getAccountTypeByString(final String accountType) {
       throw new IllegalArgumentException("Account type error: Not a Normal/AssetIssue/Contract");
     }
 
-    switch (accountType.toUpperCase()) {
+    switch (accountType.toUpperCase(Locale.ROOT)) {
       case ACCOUNT_TYPE_NORMAL:
         return AccountType.Normal;
       case ACCOUNT_TYPE_ASSETISSUE:

common/src/main/java/org/tron/common/runtime/vm/DataWord.java

@@ -23,6 +23,7 @@
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonValue;
 import java.math.BigInteger;
+import java.util.Locale;
 import java.nio.ByteBuffer;
 import org.bouncycastle.util.Arrays;
 import org.bouncycastle.util.encoders.Hex;
@@ -121,7 +122,7 @@ public static boolean isZero(byte[] data) {
 
   public static String shortHex(byte[] data) {
     byte[] bytes = ByteUtil.stripLeadingZeroes(data);
-    String hexValue = Hex.toHexString(bytes).toUpperCase();
+    String hexValue = Hex.toHexString(bytes).toUpperCase(Locale.ROOT);
     return "0x" + hexValue.replaceFirst("^0+(?!$)", "");
   }
 
@@ -451,7 +452,7 @@ public String toPrefixString() {
   }
 
   public String shortHex() {
-    String hexValue = Hex.toHexString(getNoLeadZeroesData()).toUpperCase();
+    String hexValue = Hex.toHexString(getNoLeadZeroesData()).toUpperCase(Locale.ROOT);
     return "0x" + hexValue.replaceFirst("^0+(?!$)", "");
   }
 

errorprone/build.gradle

@@ -0,0 +1,13 @@
+if (!JavaVersion.current().isJava11Compatible()) {
+    // ErrorProne core requires JDK 11+; skip this module on JDK 8
+    tasks.withType(JavaCompile).configureEach { enabled = false }
+    tasks.withType(Jar).configureEach { enabled = false }
+} else {
+    dependencies {
+        compileOnly "com.google.errorprone:error_prone_annotations:${errorproneVersion}"
+        compileOnly "com.google.errorprone:error_prone_check_api:${errorproneVersion}"
+        compileOnly "com.google.errorprone:error_prone_core:${errorproneVersion}"
+        compileOnly "com.google.auto.service:auto-service:1.1.1"
+        annotationProcessor "com.google.auto.service:auto-service:1.1.1"
+    }
+}

errorprone/src/main/java/errorprone/StringCaseLocaleUsageMethodRef.java

@@ -0,0 +1,56 @@
+package errorprone;
+
+import com.google.auto.service.AutoService;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.MemberReferenceTree;
+import com.sun.tools.javac.code.Symbol;
+import com.sun.tools.javac.code.Type;
+
+/**
+ * Flags method references {@code String::toLowerCase} and {@code String::toUpperCase}
+ * that resolve to the no-arg overload (which uses {@code Locale.getDefault()}).
+ *
+ * <p>The built-in ErrorProne {@code StringCaseLocaleUsage} checker only catches
+ * direct method invocations ({@code s.toLowerCase()}), not method references
+ * ({@code String::toLowerCase}). This checker closes that gap.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+    name = "StringCaseLocaleUsageMethodRef",
+    summary = "String::toLowerCase and String::toUpperCase method references use "
+        + "Locale.getDefault(). Replace with a lambda that specifies Locale.ROOT, "
+        + "e.g. s -> s.toLowerCase(Locale.ROOT).",
+    severity = BugPattern.SeverityLevel.ERROR
+)
+public class StringCaseLocaleUsageMethodRef extends BugChecker
+    implements BugChecker.MemberReferenceTreeMatcher {
+
+  @Override
+  public Description matchMemberReference(MemberReferenceTree tree, VisitorState state) {
+    String name = tree.getName().toString();
+    if (!"toLowerCase".equals(name) && !"toUpperCase".equals(name)) {
+      return Description.NO_MATCH;
+    }
+    // Verify the qualifier type is java.lang.String
+    Type qualifierType = ((com.sun.tools.javac.tree.JCTree) tree.getQualifierExpression())
+        .type;
+    if (qualifierType == null) {
+      return Description.NO_MATCH;
+    }
+    if (!state.getTypes().isSameType(
+        qualifierType, state.getSymtab().stringType)) {
+      return Description.NO_MATCH;
+    }
+    // Only flag the no-arg overload; the Locale-taking overload is safe
+    Symbol sym = ASTHelpers.getSymbol(tree);
+    if (sym instanceof Symbol.MethodSymbol
+        && ((Symbol.MethodSymbol) sym).getParameters().isEmpty()) {
+      return describeMatch(tree);
+    }
+    return Description.NO_MATCH;
+  }
+}