Arm64-with check 4.8.0

.github/workflows/arm64-platform.yml

@@ -0,0 +1,54 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-gradle
+
+name: arm64-Platform Matrix
+
+on:
+  push:
+    branches: [ 'develop', 'master', 'release_**' ]
+  pull_request:
+    branches: [ 'develop', 'master', 'release_**' ]
+
+jobs:
+  build:
+
+    name: ${{ matrix.os }} - ${{ matrix.arch }}
+    runs-on: ${{ matrix.runner }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Apple Silicon runners (using latest available)
+          # see https://github.com/actions/runner-images?tab=readme-ov-file#available-images
+          - os: macOS
+            arch: arm64
+            runner: macos-latest
+          # Linux arm runners
+          - os: Linux
+            arch: arm64
+            runner: ubuntu-24.04-arm
+
+    permissions:
+      contents: read
+
+    steps:
+    - name: Checkout sources
+      uses: actions/checkout@v4
+    - name: Set up JDK 17
+      uses: actions/setup-java@v4
+      with:
+        java-version: '17'
+        distribution: 'temurin'
+
+    # Configure Gradle for optimal use in GitHub Actions, including caching of downloaded dependencies.
+    # See: https://github.com/gradle/actions/blob/main/setup-gradle/README.md
+    - name: Setup Gradle
+      uses: gradle/actions/setup-gradle@v4
+
+    - name: Build with Gradle Wrapper
+      run: ./gradlew clean build  --no-daemon

.github/workflows/x86_64-platform.yml

@@ -0,0 +1,54 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-gradle
+
+name: X86_64-Platform Matrix
+
+on:
+  push:
+    branches: [ 'develop', 'master', 'release_**' ]
+  pull_request:
+    branches: [ 'develop', 'master', 'release_**' ]
+
+jobs:
+  build:
+
+    name: ${{ matrix.os }} - ${{ matrix.arch }}
+    runs-on: ${{ matrix.runner }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          #  Macos Intel runners
+          # see https://github.com/actions/runner-images?tab=readme-ov-file#available-images
+          - os: macOS
+            arch: x86_64
+            runner: macos-13
+          # Linux x86_64 runners
+          - os: Linux
+            arch: x86_64
+            runner: ubuntu-latest
+
+    permissions:
+      contents: read
+
+    steps:
+    - name: Checkout sources
+      uses: actions/checkout@v4
+    - name: Set up JDK 8
+      uses: actions/setup-java@v4
+      with:
+        java-version: '8'
+        distribution: 'zulu'
+
+    # Configure Gradle for optimal use in GitHub Actions, including caching of downloaded dependencies.
+    # See: https://github.com/gradle/actions/blob/main/setup-gradle/README.md
+    - name: Setup Gradle
+      uses: gradle/actions/setup-gradle@v4
+
+    - name: Build with Gradle Wrapper
+      run: ./gradlew clean build  --no-daemon

actuator/src/main/java/org/tron/core/vm/VM.java

@@ -108,7 +108,10 @@ public static void play(Program program, JumpTable jumpTable) {
     } catch (JVMStackOverFlowException | OutOfTimeException e) {
       throw e;
     } catch (RuntimeException e) {
-      if (StringUtils.isEmpty(e.getMessage())) {
+      // https://openjdk.org/jeps/358
+      // https://bugs.openjdk.org/browse/JDK-8220715
+      // since jdk 14, the NullPointerExceptions message is not empty
+      if (e instanceof NullPointerException || StringUtils.isEmpty(e.getMessage())) {
         logger.warn("Unknown Exception occurred, tx id: {}",
             Hex.toHexString(program.getRootTransactionId()), e);
         program.setRuntimeFailure(new RuntimeException("Unknown Exception"));

actuator/src/main/java/org/tron/core/vm/program/invoke/ProgramInvokeImpl.java

@@ -314,7 +314,7 @@ public boolean equals(Object o) {
 
   @Override
   public int hashCode() {
-    return new Integer(Boolean.valueOf(byTestingSuite).hashCode()
+    return Integer.valueOf(Boolean.valueOf(byTestingSuite).hashCode()
         + Boolean.valueOf(byTransaction).hashCode()
         + address.hashCode()
         + balance.hashCode()

actuator/src/main/java/org/tron/core/vm/repository/Type.java

@@ -73,7 +73,7 @@ public boolean equals(Object obj) {
 
   @Override
   public int hashCode() {
-    return new Integer(type).hashCode();
+    return Integer.valueOf(type).hashCode();
   }
 
   @Override

actuator/src/main/java/org/tron/core/vm/repository/Value.java

@@ -58,6 +58,6 @@ public boolean equals(Object obj) {
 
   @Override
   public int hashCode() {
-    return new Integer(type.hashCode() + Objects.hashCode(value)).hashCode();
+    return Integer.valueOf(type.hashCode() + Objects.hashCode(value)).hashCode();
   }
 }

build.gradle

@@ -1,14 +1,35 @@
+import org.gradle.nativeplatform.platform.internal.Architectures
 allprojects {
     version = "1.0.0"
     apply plugin: "java-library"
 }
 
+static def isX86() {
+    def arch = System.getProperty("os.arch").toLowerCase()
+    return Architectures.X86_64.isAlias(arch) || Architectures.X86.isAlias(arch)
+}
+
+static def isArm64() {
+    def arch = System.getProperty("os.arch").toLowerCase()
+    return new Architectures.KnownArchitecture("arm64", "aarch64").isAlias(arch)
+}
+
+if (isArm64() && !JavaVersion.current().is(JavaVersion.VERSION_17)) {
+    throw new GradleException("Java 17 is required to build Java-Tron for arm64.\n" +
+            "  Detected version ${JavaVersion.current()}")
+}
+
+if (isX86() && !JavaVersion.current().isJava8()) {
+    throw new GradleException("Java 8 is required to build Java-Tron for x86.\n" +
+            "  Detected version ${JavaVersion.current()}")
+}
+
 subprojects {
     apply plugin: "jacoco"
     apply plugin: "maven-publish"
 
     sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.current()
 
     [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'
     jacoco {
@@ -49,10 +70,16 @@ subprojects {
         implementation group: 'joda-time', name: 'joda-time', version: '2.3'
         implementation group: 'org.bouncycastle', name: 'bcprov-jdk15on', version: '1.69'
 
-        compileOnly 'org.projectlombok:lombok:1.18.12'
-        annotationProcessor 'org.projectlombok:lombok:1.18.12'
-        testCompileOnly 'org.projectlombok:lombok:1.18.12'
-        testAnnotationProcessor 'org.projectlombok:lombok:1.18.12'
+        compileOnly 'org.projectlombok:lombok:1.18.34'
+        annotationProcessor 'org.projectlombok:lombok:1.18.34'
+        testCompileOnly 'org.projectlombok:lombok:1.18.34'
+        testAnnotationProcessor 'org.projectlombok:lombok:1.18.34'
+
+        // https://www.oracle.com/java/technologies/javase/11-relnote-issues.html#JDK-8190378
+        implementation group: 'javax.annotation', name: 'javax.annotation-api', version: '1.3.2'
+        // for json-rpc, see https://github.com/briandilley/jsonrpc4j/issues/278
+        implementation group: 'javax.jws', name: 'javax.jws-api', version: '1.1'
+        annotationProcessor group: 'javax.annotation', name: 'javax.annotation-api', version: '1.3.2'
 
         testImplementation group: 'junit', name: 'junit', version: '4.13.2'
         testImplementation "org.mockito:mockito-core:4.11.0"

common/src/main/java/org/tron/common/math/Maths.java → chainbase/src/main/java/org/tron/common/math/Maths.java

@@ -1,21 +1,89 @@
 package org.tron.common.math;
 
+import com.google.common.primitives.Bytes;
+import java.nio.ByteBuffer;
+import java.util.Optional;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.tron.common.context.GlobalContext;
+import org.tron.core.store.MathStore;
+import org.tron.core.store.StrictMathStore;
+
 /**
  * This class is deprecated and should not be used in new code,
  * for cross-platform consistency, please use {@link StrictMathWrapper} instead,
  * especially for floating-point calculations.
  */
 @Deprecated
+@Component
+@Slf4j(topic = "math")
 public class Maths {
 
+  private static Optional<MathStore> mathStore = Optional.empty();
+  private static Optional<StrictMathStore> strictMathStore = Optional.empty();
+
+  @Autowired
+  public Maths(@Autowired MathStore mathStore, @Autowired StrictMathStore strictMathStore) {
+    Maths.mathStore = Optional.ofNullable(mathStore);
+    Maths.strictMathStore = Optional.ofNullable(strictMathStore);
+  }
+
+  private enum Op {
+
+    POW((byte) 0x01);
+
+    private final byte code;
+
+    Op(byte code) {
+      this.code = code;
+    }
+  }
+
   /**
    * Returns the value of the first argument raised to the power of the second argument.
    * @param a the base.
    * @param b the exponent.
    * @return the value {@code a}<sup>{@code b}</sup>.
    */
   public static double pow(double a, double b, boolean useStrictMath) {
-    return useStrictMath ? StrictMathWrapper.pow(a, b) : MathWrapper.pow(a, b);
+    double result = MathWrapper.pow(a, b);
+    double strictResult = StrictMathWrapper.pow(a, b);
+    if (useStrictMath) {
+      return strictResult;
+    }
+    final boolean isNoStrict = Double.compare(result, strictResult) != 0;
+    Optional<Long> header = GlobalContext.getHeader();
+    header.ifPresent(h -> {
+      byte[] key = Bytes.concat(longToBytes(h), new byte[]{Op.POW.code},
+          doubleToBytes(a), doubleToBytes(b));
+      if (isNoStrict) {
+        logger.info("{}\t{}\t{}\t{}\t{}\t{}", h, Op.POW.code, doubleToHex(a), doubleToHex(b),
+            doubleToHex(result), doubleToHex(strictResult));
+      }
+      mathStore.ifPresent(s -> s.put(key, doubleToBytes(result)));
+      strictMathStore.ifPresent(s -> s.put(key, doubleToBytes(strictResult)));
+    });
+    return result;
+  }
+
+  static String doubleToHex(double input) {
+    // Convert the starting value to the equivalent value in a long
+    long doubleAsLong = Double.doubleToRawLongBits(input);
+    // and then convert the long to a hex string
+    return Long.toHexString(doubleAsLong);
+  }
+
+  private static byte[] doubleToBytes(double value) {
+    ByteBuffer buffer = ByteBuffer.allocate(Double.BYTES);
+    buffer.putDouble(value);
+    return buffer.array();
+  }
+
+  private static byte[] longToBytes(long value) {
+    ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
+    buffer.putLong(value);
+    return buffer.array();
   }
 
   /**

chainbase/src/main/java/org/tron/common/storage/OptionsPicker.java

@@ -0,0 +1,15 @@
+package org.tron.common.storage;
+
+import org.tron.common.setting.RocksDbSettings;
+import org.tron.common.utils.StorageUtils;
+
+public class OptionsPicker {
+
+  protected org.iq80.leveldb.Options getOptionsByDbNameForLevelDB(String dbName) {
+    return StorageUtils.getOptionsByDbName(dbName);
+  }
+
+  protected org.rocksdb.Options getOptionsByDbNameForRocksDB(String dbName) {
+    return RocksDbSettings.getOptionsByDbName(dbName);
+  }
+}