reactor(math): rename allowStrictMath2 to disableJavaLangMath

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

@@ -122,7 +122,7 @@ public void adjustBalance(AccountStore accountStore, AccountCapsule account, lon
     Commons.adjustBalance(accountStore, account, amount, this.disableJavaLangMath());
   }
 
-  private boolean disableJavaLangMath() {
+  boolean disableJavaLangMath() {
     return chainBaseManager.getDynamicPropertiesStore().disableJavaLangMath();
   }
 }

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

@@ -162,7 +162,7 @@ public boolean validate() throws ContractValidateException {
         long netUsage = (long) (accountNetUsage * TRX_PRECISION * ((double)
             (dynamicStore.getTotalNetWeight()) / dynamicStore.getTotalNetLimit()));
         long v2NetUsage = getV2NetUsage(ownerCapsule, netUsage,
-            dynamicStore.disableJavaLangMath());
+            this.disableJavaLangMath());
         if (ownerCapsule.getFrozenV2BalanceForBandwidth() - v2NetUsage < delegateBalance) {
           throw new ContractValidateException(
               "delegateBalance must be less than or equal to available FreezeBandwidthV2 balance");
@@ -176,7 +176,7 @@ public boolean validate() throws ContractValidateException {
         long energyUsage = (long) (ownerCapsule.getEnergyUsage() * TRX_PRECISION * ((double)
             (dynamicStore.getTotalEnergyWeight()) / dynamicStore.getTotalEnergyCurrentLimit()));
         long v2EnergyUsage = getV2EnergyUsage(ownerCapsule, energyUsage,
-            dynamicStore.disableJavaLangMath());
+            this.disableJavaLangMath());
         if (ownerCapsule.getFrozenV2BalanceForEnergy() - v2EnergyUsage < delegateBalance) {
           throw new ContractValidateException(
                   "delegateBalance must be less than or equal to available FreezeEnergyV2 balance");

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

@@ -400,10 +400,9 @@ private void matchSingleOrder(MarketOrderCapsule takerOrderCapsule,
     // => takerBuyTokenQuantityCurrent_A = takerSellTokenQuantityRemain_TRX *
     //   makerSellTokenQuantity_A/makerBuyTokenQuantity_TRX
 
-    boolean disableMath = dynamicStore.disableJavaLangMath();
     long takerBuyTokenQuantityRemain = MarketUtils
         .multiplyAndDivide(takerSellRemainQuantity, makerSellQuantity, makerBuyQuantity,
-            disableMath);
+            this.disableJavaLangMath());
 
     if (takerBuyTokenQuantityRemain == 0) {
       // quantity too small, return sellToken to user
@@ -427,7 +426,7 @@ private void matchSingleOrder(MarketOrderCapsule takerOrderCapsule,
 
       makerBuyTokenQuantityReceive = MarketUtils
           .multiplyAndDivide(makerSellRemainQuantity, makerBuyQuantity, makerSellQuantity,
-              chainBaseManager.getDynamicPropertiesStore().disableJavaLangMath());
+              this.disableJavaLangMath());
       takerBuyTokenQuantityReceive = makerOrderCapsule.getSellTokenQuantityRemain();
 
       long takerSellTokenLeft =
@@ -462,7 +461,7 @@ private void matchSingleOrder(MarketOrderCapsule takerOrderCapsule,
       //   makerSellTokenQuantity_A/makerBuyTokenQuantity_TRX
       makerBuyTokenQuantityReceive = MarketUtils
           .multiplyAndDivide(makerSellRemainQuantity, makerBuyQuantity, makerSellQuantity,
-              chainBaseManager.getDynamicPropertiesStore().disableJavaLangMath());
+              this.disableJavaLangMath());
 
       MarketUtils.updateOrderState(makerOrderCapsule, State.INACTIVE, marketAccountStore);
       if (makerBuyTokenQuantityReceive == 0) {

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

@@ -603,10 +603,10 @@ private long getAccountEnergyLimitWithFloatRatio(AccountCapsule account, long fe
     }
     // can change the calc way
     long leftEnergyFromFreeze = rootRepository.getAccountLeftEnergyFromFreeze(account);
-    boolean isStrict2 = VMConfig.disableJavaLangMath();
-    callValue = max(callValue, 0, isStrict2);
+    callValue = max(callValue, 0, VMConfig.disableJavaLangMath());
     long energyFromBalance = floorDiv(max(
-        account.getBalance() - callValue, 0, isStrict2), sunPerEnergy, isStrict2);
+        account.getBalance() - callValue, 0, VMConfig.disableJavaLangMath()), sunPerEnergy,
+        VMConfig.disableJavaLangMath());
 
     long energyFromFeeLimit;
     long totalBalanceForEnergyFreeze = account.getAllFrozenBalanceForEnergy();

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

@@ -636,17 +636,16 @@ public long getEnergyForData(byte[] data) {
       int expLen = parseLen(data, 1);
       int modLen = parseLen(data, 2);
 
-      boolean allowStrictMath2 = VMConfig.disableJavaLangMath();
 
       byte[] expHighBytes = parseBytes(data, addSafely(ARGS_OFFSET, baseLen), min(expLen, 32,
-          allowStrictMath2));
+          VMConfig.disableJavaLangMath()));
 
-      long multComplexity = getMultComplexity(max(baseLen, modLen, allowStrictMath2));
+      long multComplexity = getMultComplexity(max(baseLen, modLen, VMConfig.disableJavaLangMath()));
       long adjExpLen = getAdjustedExponentLength(expHighBytes, expLen);
 
       // use big numbers to stay safe in case of overflow
       BigInteger energy = BigInteger.valueOf(multComplexity)
-          .multiply(BigInteger.valueOf(max(adjExpLen, 1, allowStrictMath2)))
+          .multiply(BigInteger.valueOf(max(adjExpLen, 1, VMConfig.disableJavaLangMath())))
           .divide(GQUAD_DIVISOR);
 
       return isLessThan(energy, BigInteger.valueOf(Long.MAX_VALUE)) ? energy.longValueExact()

actuator/src/main/java/org/tron/core/vm/nativecontract/DelegateResourceProcessor.java

@@ -22,6 +22,7 @@
 import org.tron.core.exception.ContractValidateException;
 import org.tron.core.store.DelegatedResourceAccountIndexStore;
 import org.tron.core.store.DynamicPropertiesStore;
+import org.tron.core.vm.config.VMConfig;
 import org.tron.core.vm.nativecontract.param.DelegateResourceParam;
 import org.tron.core.vm.repository.Repository;
 import org.tron.protos.Protocol;
@@ -53,7 +54,7 @@ public void validate(DelegateResourceParam param, Repository repo) throws Contra
       throw new ContractValidateException("delegateBalance must be greater than or equal to 1 TRX");
     }
 
-    boolean allowStrictMath2 = dynamicStore.disableJavaLangMath();
+    boolean disableJavaLangMath = VMConfig.disableJavaLangMath();
     switch (param.getResourceType()) {
       case BANDWIDTH: {
         BandwidthProcessor processor = new BandwidthProcessor(ChainBaseManager.getInstance());
@@ -62,7 +63,7 @@ public void validate(DelegateResourceParam param, Repository repo) throws Contra
         long netUsage = (long) (ownerCapsule.getNetUsage() * TRX_PRECISION * ((double)
             (repo.getTotalNetWeight()) / dynamicStore.getTotalNetLimit()));
 
-        long v2NetUsage = getV2NetUsage(ownerCapsule, netUsage, allowStrictMath2);
+        long v2NetUsage = getV2NetUsage(ownerCapsule, netUsage, disableJavaLangMath);
 
         if (ownerCapsule.getFrozenV2BalanceForBandwidth() - v2NetUsage < delegateBalance) {
           throw new ContractValidateException(
@@ -78,7 +79,7 @@ public void validate(DelegateResourceParam param, Repository repo) throws Contra
         long energyUsage = (long) (ownerCapsule.getEnergyUsage() * TRX_PRECISION * ((double)
             (repo.getTotalEnergyWeight()) / dynamicStore.getTotalEnergyCurrentLimit()));
 
-        long v2EnergyUsage = getV2EnergyUsage(ownerCapsule, energyUsage, allowStrictMath2);
+        long v2EnergyUsage = getV2EnergyUsage(ownerCapsule, energyUsage, disableJavaLangMath);
 
         if (ownerCapsule.getFrozenV2BalanceForEnergy() - v2EnergyUsage < delegateBalance) {
           throw new ContractValidateException(

actuator/src/main/java/org/tron/core/vm/program/Memory.java

@@ -105,17 +105,17 @@ public void extend(int address, int size) {
     if (size <= 0) {
       return;
     }
-    boolean allowStrictMath2 = VMConfig.disableJavaLangMath();
-    final int newSize = addExact(address, size, allowStrictMath2);
+    final int newSize = addExact(address, size, VMConfig.disableJavaLangMath());
     int toAllocate = newSize - internalSize();
     if (toAllocate > 0) {
-      addChunks((int) ceil((double) toAllocate / CHUNK_SIZE, allowStrictMath2));
+      addChunks((int) ceil((double) toAllocate / CHUNK_SIZE, VMConfig.disableJavaLangMath()));
     }
 
     toAllocate = newSize - softSize;
     if (toAllocate > 0) {
-      toAllocate = (int) ceil((double) toAllocate / WORD_SIZE, allowStrictMath2) * WORD_SIZE;
-      softSize = addExact(softSize, toAllocate, allowStrictMath2);
+      toAllocate = (int) ceil((double) toAllocate / WORD_SIZE,
+          VMConfig.disableJavaLangMath()) * WORD_SIZE;
+      softSize = addExact(softSize, toAllocate, VMConfig.disableJavaLangMath());
 
       if (programListener != null) {
         programListener.onMemoryExtend(toAllocate);

actuator/src/main/java/org/tron/core/vm/program/Program.java

@@ -2170,13 +2170,12 @@ public boolean voteWitness(int witnessArrayOffset, int witnessArrayLength,
     try {
       VoteWitnessParam param = new VoteWitnessParam();
       param.setVoterAddress(owner);
-      boolean allowStrictMath2 = VMConfig.disableJavaLangMath();
       byte[] witnessArrayData = memoryChunk(
-          addExact(witnessArrayOffset, DataWord.WORD_SIZE, allowStrictMath2),
-          multiplyExact(witnessArrayLength, DataWord.WORD_SIZE, allowStrictMath2));
+          addExact(witnessArrayOffset, DataWord.WORD_SIZE,  VMConfig.disableJavaLangMath()),
+          multiplyExact(witnessArrayLength, DataWord.WORD_SIZE,  VMConfig.disableJavaLangMath()));
       byte[] amountArrayData = memoryChunk(
-          addExact(amountArrayOffset, DataWord.WORD_SIZE, allowStrictMath2),
-          multiplyExact(amountArrayLength, DataWord.WORD_SIZE, allowStrictMath2));
+          addExact(amountArrayOffset, DataWord.WORD_SIZE,  VMConfig.disableJavaLangMath()),
+          multiplyExact(amountArrayLength, DataWord.WORD_SIZE,  VMConfig.disableJavaLangMath()));
 
       for (int i = 0; i < witnessArrayLength; i++) {
         DataWord witness = new DataWord(Arrays.copyOfRange(witnessArrayData,

actuator/src/main/java/org/tron/core/vm/utils/FreezeV2Util.java

@@ -144,7 +144,6 @@ public static long queryDelegatableResource(byte[] address, long type, Repositor
       return 0L;
     }
 
-    boolean allowStrictMath2 = VMConfig.disableJavaLangMath();
     AccountCapsule accountCapsule = repository.getAccount(address);
     if (accountCapsule == null) {
       return 0L;
@@ -166,8 +165,8 @@ public static long queryDelegatableResource(byte[] address, long type, Repositor
         return frozenV2Resource;
       }
 
-      long v2NetUsage = getV2NetUsage(accountCapsule, usage, allowStrictMath2);
-      return max(0L, frozenV2Resource - v2NetUsage, allowStrictMath2);
+      long v2NetUsage = getV2NetUsage(accountCapsule, usage, VMConfig.disableJavaLangMath());
+      return max(0L, frozenV2Resource - v2NetUsage, VMConfig.disableJavaLangMath());
     }
 
     if (type == 1) {
@@ -186,8 +185,8 @@ public static long queryDelegatableResource(byte[] address, long type, Repositor
         return frozenV2Resource;
       }
 
-      long v2EnergyUsage = getV2EnergyUsage(accountCapsule, usage, allowStrictMath2);
-      return max(0L, frozenV2Resource - v2EnergyUsage, allowStrictMath2);
+      long v2EnergyUsage = getV2EnergyUsage(accountCapsule, usage, VMConfig.disableJavaLangMath());
+      return max(0L, frozenV2Resource - v2EnergyUsage, VMConfig.disableJavaLangMath());
     }
 
     return 0L;
@@ -244,21 +243,21 @@ private static List<Protocol.Account.UnFreezeV2> getTotalWithdrawList(List<Proto
   }
 
   public static long getV2NetUsage(AccountCapsule ownerCapsule, long netUsage, boolean
-      allowStrictMath2) {
+      disableJavaLangMath) {
     long v2NetUsage= netUsage
         - ownerCapsule.getFrozenBalance()
         - ownerCapsule.getAcquiredDelegatedFrozenBalanceForBandwidth()
         - ownerCapsule.getAcquiredDelegatedFrozenV2BalanceForBandwidth();
-    return max(0, v2NetUsage, allowStrictMath2);
+    return max(0, v2NetUsage, disableJavaLangMath);
   }
 
   public static long getV2EnergyUsage(AccountCapsule ownerCapsule, long energyUsage, boolean
-      allowStrictMath2) {
+      disableJavaLangMath) {
     long v2EnergyUsage= energyUsage
           - ownerCapsule.getEnergyFrozenBalance()
           - ownerCapsule.getAcquiredDelegatedFrozenBalanceForEnergy()
           - ownerCapsule.getAcquiredDelegatedFrozenV2BalanceForEnergy();
-    return max(0, v2EnergyUsage, allowStrictMath2);
+    return max(0, v2EnergyUsage, disableJavaLangMath);
   }
 
 }

chainbase/src/main/java/org/tron/core/capsule/AccountCapsule.java

@@ -733,7 +733,7 @@ public boolean addAssetAmount(byte[] key, long amount, boolean useStrict) {
   public boolean addAssetAmountV2(byte[] key, long amount,
       DynamicPropertiesStore dynamicPropertiesStore, AssetIssueStore assetIssueStore) {
     importAsset(key);
-    boolean useStrict2 = dynamicPropertiesStore.disableJavaLangMath();
+    boolean disableJavaLangMath = dynamicPropertiesStore.disableJavaLangMath();
     //key is token name
     if (dynamicPropertiesStore.getAllowSameTokenName() == 0) {
       Map<String, Long> assetMap = this.account.getAssetMap();
@@ -745,8 +745,8 @@ public boolean addAssetAmountV2(byte[] key, long amount,
         currentAmount = 0L;
       }
       this.account = this.account.toBuilder()
-          .putAsset(nameKey, addExact(currentAmount, amount, useStrict2))
-          .putAssetV2(tokenID, addExact(currentAmount, amount, useStrict2))
+          .putAsset(nameKey, addExact(currentAmount, amount, disableJavaLangMath))
+          .putAssetV2(tokenID, addExact(currentAmount, amount, disableJavaLangMath))
           .build();
     }
     //key is token id
@@ -758,19 +758,19 @@ public boolean addAssetAmountV2(byte[] key, long amount,
         currentAmount = 0L;
       }
       this.account = this.account.toBuilder()
-          .putAssetV2(tokenIDStr, addExact(currentAmount, amount, useStrict2))
+          .putAssetV2(tokenIDStr, addExact(currentAmount, amount, disableJavaLangMath))
           .build();
     }
     return true;
   }
 
-  public boolean reduceAssetAmount(byte[] key, long amount, boolean useStrict2) {
+  public boolean reduceAssetAmount(byte[] key, long amount, boolean disableJavaLangMath) {
     Map<String, Long> assetMap = this.account.getAssetMap();
     String nameKey = ByteArray.toStr(key);
     Long currentAmount = assetMap.get(nameKey);
     if (amount > 0 && null != currentAmount && amount <= currentAmount) {
       this.account = this.account.toBuilder()
-              .putAsset(nameKey, subtractExact(currentAmount, amount, useStrict2)).build();
+              .putAsset(nameKey, subtractExact(currentAmount, amount, disableJavaLangMath)).build();
       return true;
     }
 
@@ -781,7 +781,7 @@ public boolean reduceAssetAmountV2(byte[] key, long amount,
                                      DynamicPropertiesStore dynamicPropertiesStore, AssetIssueStore assetIssueStore) {
     importAsset(key);
     //key is token name
-    boolean useStrict2 = dynamicPropertiesStore.disableJavaLangMath();
+    boolean disableJavaLangMath = dynamicPropertiesStore.disableJavaLangMath();
     if (dynamicPropertiesStore.getAllowSameTokenName() == 0) {
       Map<String, Long> assetMap = this.account.getAssetMap();
       AssetIssueCapsule assetIssueCapsule = assetIssueStore.get(key);
@@ -790,8 +790,8 @@ public boolean reduceAssetAmountV2(byte[] key, long amount,
       Long currentAmount = assetMap.get(nameKey);
       if (amount > 0 && null != currentAmount && amount <= currentAmount) {
         this.account = this.account.toBuilder()
-                .putAsset(nameKey, subtractExact(currentAmount, amount, useStrict2))
-                .putAssetV2(tokenID, subtractExact(currentAmount, amount, useStrict2))
+                .putAsset(nameKey, subtractExact(currentAmount, amount, disableJavaLangMath))
+                .putAssetV2(tokenID, subtractExact(currentAmount, amount, disableJavaLangMath))
                 .build();
         return true;
       }
@@ -803,7 +803,7 @@ public boolean reduceAssetAmountV2(byte[] key, long amount,
       Long currentAmount = assetMapV2.get(tokenID);
       if (amount > 0 && null != currentAmount && amount <= currentAmount) {
         this.account = this.account.toBuilder()
-                .putAssetV2(tokenID, subtractExact(currentAmount, amount, useStrict2))
+                .putAssetV2(tokenID, subtractExact(currentAmount, amount, disableJavaLangMath))
                 .build();
         return true;
       }

chainbase/src/main/java/org/tron/core/capsule/ReceiptCapsule.java

@@ -218,13 +218,14 @@ public void payEnergyBill(DynamicPropertiesStore dynamicPropertiesStore,
           receipt.getEnergyUsageTotal(), receipt.getResult(), energyProcessor, now);
       return;
     }
-    boolean useStrict2 = dynamicPropertiesStore.disableJavaLangMath();
+    boolean disableJavaLangMath = dynamicPropertiesStore.disableJavaLangMath();
 
     if ((!Objects.isNull(origin)) && caller.getAddress().equals(origin.getAddress())) {
       payEnergyBill(dynamicPropertiesStore, accountStore, forkController, caller,
           receipt.getEnergyUsageTotal(), receipt.getResult(), energyProcessor, now);
     } else {
-      long originUsage = multiplyExact(receipt.getEnergyUsageTotal(), percent, useStrict2) / 100;
+      long originUsage = multiplyExact(receipt.getEnergyUsageTotal(), percent, disableJavaLangMath)
+          / 100;
       originUsage = getOriginUsage(dynamicPropertiesStore, origin, originEnergyLimit,
           energyProcessor,
           originUsage);
@@ -240,18 +241,20 @@ public void payEnergyBill(DynamicPropertiesStore dynamicPropertiesStore,
   private long getOriginUsage(DynamicPropertiesStore dynamicPropertiesStore, AccountCapsule origin,
       long originEnergyLimit,
       EnergyProcessor energyProcessor, long originUsage) {
-    boolean useStrict2 = dynamicPropertiesStore.disableJavaLangMath();
+    boolean disableJavaLangMath = dynamicPropertiesStore.disableJavaLangMath();
     if (dynamicPropertiesStore.getAllowTvmFreeze() == 1
         || dynamicPropertiesStore.supportUnfreezeDelay()) {
-      return min(originUsage, min(originEnergyLeft, originEnergyLimit, useStrict2), useStrict2);
+      return min(originUsage, min(originEnergyLeft, originEnergyLimit, disableJavaLangMath),
+          disableJavaLangMath);
     }
 
     if (checkForEnergyLimit(dynamicPropertiesStore)) {
       return min(originUsage,
           min(energyProcessor.getAccountLeftEnergyFromFreeze(origin), originEnergyLimit,
-              useStrict2), useStrict2);
+              disableJavaLangMath), disableJavaLangMath);
     }
-    return min(originUsage, energyProcessor.getAccountLeftEnergyFromFreeze(origin), useStrict2);
+    return min(originUsage, energyProcessor.getAccountLeftEnergyFromFreeze(origin),
+        disableJavaLangMath);
   }
 
   private void payEnergyBill(

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

@@ -79,10 +79,9 @@ public void updateAdaptiveTotalEnergyLimit() {
           / AdaptiveResourceLimitConstants.EXPAND_RATE_DENOMINATOR;
       // logger.info(totalEnergyAverageUsage + "<" + targetTotalEnergyLimit + "\n" + result);
     }
-    boolean useStrict2 = dynamicPropertiesStore.disableJavaLangMath();
-    result = min(max(result, totalEnergyLimit, useStrict2),
+    result = min(max(result, totalEnergyLimit, this.disableJavaLangMath()),
         totalEnergyLimit * dynamicPropertiesStore.getAdaptiveResourceLimitMultiplier(),
-        useStrict2);
+        this.disableJavaLangMath());
 
     dynamicPropertiesStore.saveTotalEnergyCurrentLimit(result);
     logger.debug("Adjust totalEnergyCurrentLimit, old: {}, new: {}.",
@@ -178,7 +177,7 @@ public long getAccountLeftEnergyFromFreeze(AccountCapsule accountCapsule) {
 
     long newEnergyUsage = recovery(accountCapsule, ENERGY, energyUsage, latestConsumeTime, now);
 
-    return max(energyLimit - newEnergyUsage, 0, dynamicPropertiesStore.disableJavaLangMath()); // us
+    return max(energyLimit - newEnergyUsage, 0, this.disableJavaLangMath()); // us
   }
 
   private long getHeadSlot() {