reactor(actuator): rename allowStrictMath2 to disableJavaLangMath

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

@@ -69,46 +69,43 @@ public AbstractActuator setForkUtils(ForkController forkController) {
   }
 
   public long addExact(long x, long y) {
-    return Maths.addExact(x, y, chainBaseManager.getDynamicPropertiesStore().allowStrictMath2());
+    return Maths.addExact(x, y, this.disableJavaLangMath());
   }
 
   public long addExact(int x, int y) {
-    return Maths.addExact(x, y, chainBaseManager.getDynamicPropertiesStore().allowStrictMath2());
+    return Maths.addExact(x, y, this.disableJavaLangMath());
   }
 
   public long floorDiv(long x, long y) {
-    return Maths.floorDiv(x, y, chainBaseManager.getDynamicPropertiesStore().allowStrictMath2());
+    return Maths.floorDiv(x, y, this.disableJavaLangMath());
   }
 
   public long floorDiv(long x, int y) {
     return this.floorDiv(x, (long) y);
   }
 
   public long multiplyExact(long x, long y) {
-    return Maths.multiplyExact(x, y,
-        chainBaseManager.getDynamicPropertiesStore().allowStrictMath2());
+    return Maths.multiplyExact(x, y, this.disableJavaLangMath());
   }
 
   public long multiplyExact(long x, int y) {
     return this.multiplyExact(x, (long) y);
   }
 
   public int multiplyExact(int x, int y) {
-    return Maths.multiplyExact(x, y,
-        chainBaseManager.getDynamicPropertiesStore().allowStrictMath2());
+    return Maths.multiplyExact(x, y, this.disableJavaLangMath());
   }
 
   public long subtractExact(long x, long y) {
-    return Maths.subtractExact(x, y,
-        chainBaseManager.getDynamicPropertiesStore().allowStrictMath2());
+    return Maths.subtractExact(x, y, this.disableJavaLangMath());
   }
 
   public int min(int a, int b) {
-    return Maths.min(a, b, chainBaseManager.getDynamicPropertiesStore().allowStrictMath2());
+    return Maths.min(a, b, this.disableJavaLangMath());
   }
 
   public long min(long a, long b) {
-    return Maths.min(a, b, chainBaseManager.getDynamicPropertiesStore().allowStrictMath2());
+    return Maths.min(a, b, this.disableJavaLangMath());
   }
 
   public void adjustBalance(AccountStore accountStore, byte[] accountAddress, long amount)
@@ -122,7 +119,10 @@ public void adjustBalance(AccountStore accountStore, byte[] accountAddress, long
    */
   public void adjustBalance(AccountStore accountStore, AccountCapsule account, long amount)
       throws BalanceInsufficientException {
-    Commons.adjustBalance(accountStore, account, amount,
-        chainBaseManager.getDynamicPropertiesStore().allowStrictMath2());
+    Commons.adjustBalance(accountStore, account, amount, this.disableJavaLangMath());
+  }
+
+  private boolean disableJavaLangMath() {
+    return chainBaseManager.getDynamicPropertiesStore().disableJavaLangMath();
   }
 }

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

@@ -15,7 +15,6 @@
 import java.util.Arrays;
 import java.util.Objects;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.ArrayUtils;
 import org.tron.common.utils.DecodeUtil;
 import org.tron.common.utils.StringUtil;
 import org.tron.core.capsule.AccountCapsule;
@@ -163,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.allowStrictMath2());
+            dynamicStore.disableJavaLangMath());
         if (ownerCapsule.getFrozenV2BalanceForBandwidth() - v2NetUsage < delegateBalance) {
           throw new ContractValidateException(
               "delegateBalance must be less than or equal to available FreezeBandwidthV2 balance");
@@ -177,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.allowStrictMath2());
+            dynamicStore.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,10 @@ private void matchSingleOrder(MarketOrderCapsule takerOrderCapsule,
     // => takerBuyTokenQuantityCurrent_A = takerSellTokenQuantityRemain_TRX *
     //   makerSellTokenQuantity_A/makerBuyTokenQuantity_TRX
 
-    boolean useStrictMath2 = dynamicStore.allowStrictMath2();
+    boolean disableMath = dynamicStore.disableJavaLangMath();
     long takerBuyTokenQuantityRemain = MarketUtils
         .multiplyAndDivide(takerSellRemainQuantity, makerSellQuantity, makerBuyQuantity,
-            useStrictMath2);
+            disableMath);
 
     if (takerBuyTokenQuantityRemain == 0) {
       // quantity too small, return sellToken to user
@@ -427,7 +427,7 @@ private void matchSingleOrder(MarketOrderCapsule takerOrderCapsule,
 
       makerBuyTokenQuantityReceive = MarketUtils
           .multiplyAndDivide(makerSellRemainQuantity, makerBuyQuantity, makerSellQuantity,
-              chainBaseManager.getDynamicPropertiesStore().allowStrictMath2());
+              chainBaseManager.getDynamicPropertiesStore().disableJavaLangMath());
       takerBuyTokenQuantityReceive = makerOrderCapsule.getSellTokenQuantityRemain();
 
       long takerSellTokenLeft =
@@ -462,7 +462,7 @@ private void matchSingleOrder(MarketOrderCapsule takerOrderCapsule,
       //   makerSellTokenQuantity_A/makerBuyTokenQuantity_TRX
       makerBuyTokenQuantityReceive = MarketUtils
           .multiplyAndDivide(makerSellRemainQuantity, makerBuyQuantity, makerSellQuantity,
-              chainBaseManager.getDynamicPropertiesStore().allowStrictMath2());
+              chainBaseManager.getDynamicPropertiesStore().disableJavaLangMath());
 
       MarketUtils.updateOrderState(makerOrderCapsule, State.INACTIVE, marketAccountStore);
       if (makerBuyTokenQuantityReceive == 0) {

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

@@ -128,7 +128,7 @@ public void validate(Object object) throws ContractValidateException {
     if (isConstantCall && trx.getRawData().getFeeLimit() > 0) {
       maxEnergyLimit = min(maxEnergyLimit, trx.getRawData().getFeeLimit()
           / context.getStoreFactory().getChainBaseManager()
-          .getDynamicPropertiesStore().getEnergyFee(), VMConfig.allowStrictMath2());
+          .getDynamicPropertiesStore().getEnergyFee(), VMConfig.disableJavaLangMath());
     }
     blockCap = context.getBlockCap();
     if ((VMConfig.allowTvmFreeze() || VMConfig.allowTvmFreezeV2())
@@ -566,9 +566,9 @@ public long getAccountEnergyLimitWithFixRatio(AccountCapsule account, long feeLi
     }
 
     long energyFromBalance = max(account.getBalance() - callValue, 0,
-        VMConfig.allowStrictMath2()) / sunPerEnergy;
+        VMConfig.disableJavaLangMath()) / sunPerEnergy;
     long availableEnergy = addExact(leftFrozenEnergy, energyFromBalance,
-        VMConfig.allowStrictMath2());
+        VMConfig.disableJavaLangMath());
 
     long energyFromFeeLimit = feeLimit / sunPerEnergy;
     if (VMConfig.allowTvmFreezeV2()) {
@@ -585,12 +585,12 @@ public long getAccountEnergyLimitWithFixRatio(AccountCapsule account, long feeLi
       account.setEnergyUsage(
           energyProcessor.increase(account, ENERGY,
               account.getEnergyUsage(), min(leftFrozenEnergy, energyFromFeeLimit,
-                  VMConfig.allowStrictMath2()), now, now));
+                  VMConfig.disableJavaLangMath()), now, now));
       receipt.setCallerEnergyMergedUsage(account.getEnergyUsage());
       receipt.setCallerEnergyMergedWindowSize(account.getWindowSize(ENERGY));
       rootRepository.updateAccount(account.createDbKey(), account);
     }
-    return min(availableEnergy, energyFromFeeLimit, VMConfig.allowStrictMath2());
+    return min(availableEnergy, energyFromFeeLimit, VMConfig.disableJavaLangMath());
 
   }
 
@@ -603,7 +603,7 @@ private long getAccountEnergyLimitWithFloatRatio(AccountCapsule account, long fe
     }
     // can change the calc way
     long leftEnergyFromFreeze = rootRepository.getAccountLeftEnergyFromFreeze(account);
-    boolean isStrict2 = VMConfig.allowStrictMath2();
+    boolean isStrict2 = VMConfig.disableJavaLangMath();
     callValue = max(callValue, 0, isStrict2);
     long energyFromBalance = floorDiv(max(
         account.getBalance() - callValue, 0, isStrict2), sunPerEnergy, isStrict2);
@@ -627,12 +627,12 @@ private long getAccountEnergyLimitWithFloatRatio(AccountCapsule account, long fe
       } else {
         energyFromFeeLimit = addExact(
             leftEnergyFromFreeze, (feeLimit - leftBalanceForEnergyFreeze) / sunPerEnergy,
-            VMConfig.allowStrictMath2());
+            VMConfig.disableJavaLangMath());
       }
     }
 
     return min(addExact(leftEnergyFromFreeze, energyFromBalance,
-            VMConfig.allowStrictMath2()), energyFromFeeLimit, VMConfig.allowStrictMath2());
+            VMConfig.disableJavaLangMath()), energyFromFeeLimit, VMConfig.disableJavaLangMath());
   }
 
   public long getTotalEnergyLimit(AccountCapsule creator, AccountCapsule caller,
@@ -708,7 +708,7 @@ public long getTotalEnergyLimitWithFixRatio(AccountCapsule creator, AccountCapsu
     ContractCapsule contractCapsule = rootRepository
         .getContract(contract.getContractAddress().toByteArray());
     long consumeUserResourcePercent = contractCapsule.getConsumeUserResourcePercent(
-        VMConfig.allowStrictMath2());
+        VMConfig.disableJavaLangMath());
 
     long originEnergyLimit = contractCapsule.getOriginEnergyLimit();
     if (originEnergyLimit < 0) {
@@ -724,7 +724,7 @@ public long getTotalEnergyLimitWithFixRatio(AccountCapsule creator, AccountCapsu
     }
     if (consumeUserResourcePercent <= 0) {
       creatorEnergyLimit = min(originEnergyLeft, originEnergyLimit,
-          VMConfig.allowStrictMath2());
+          VMConfig.disableJavaLangMath());
     } else {
       if (consumeUserResourcePercent < VMConstant.ONE_HUNDRED) {
         // creatorEnergyLimit =
@@ -735,8 +735,8 @@ public long getTotalEnergyLimitWithFixRatio(AccountCapsule creator, AccountCapsu
             BigInteger.valueOf(callerEnergyLimit)
                 .multiply(BigInteger.valueOf(VMConstant.ONE_HUNDRED - consumeUserResourcePercent))
                 .divide(BigInteger.valueOf(consumeUserResourcePercent)).longValueExact(),
-            min(originEnergyLeft, originEnergyLimit, VMConfig.allowStrictMath2()),
-            VMConfig.allowStrictMath2());
+            min(originEnergyLeft, originEnergyLimit, VMConfig.disableJavaLangMath()),
+            VMConfig.disableJavaLangMath());
       }
     }
     if (VMConfig.allowTvmFreezeV2()) {
@@ -758,7 +758,7 @@ public long getTotalEnergyLimitWithFixRatio(AccountCapsule creator, AccountCapsu
       rootRepository.updateAccount(creator.createDbKey(), creator);
     }
     return addExact(callerEnergyLimit, creatorEnergyLimit,
-        VMConfig.allowStrictMath2());
+        VMConfig.disableJavaLangMath());
   }
 
   private long getTotalEnergyLimitWithFloatRatio(AccountCapsule creator, AccountCapsule caller,
@@ -775,16 +775,16 @@ private long getTotalEnergyLimitWithFloatRatio(AccountCapsule creator, AccountCa
     ContractCapsule contractCapsule = rootRepository
         .getContract(contract.getContractAddress().toByteArray());
     long consumeUserResourcePercent = contractCapsule.getConsumeUserResourcePercent(
-        VMConfig.allowStrictMath2());
+        VMConfig.disableJavaLangMath());
 
     if (creatorEnergyLimit * consumeUserResourcePercent
         > (VMConstant.ONE_HUNDRED - consumeUserResourcePercent) * callerEnergyLimit) {
       return floorDiv(
           callerEnergyLimit * VMConstant.ONE_HUNDRED, consumeUserResourcePercent,
-          VMConfig.allowStrictMath2());
+          VMConfig.disableJavaLangMath());
     } else {
       return addExact(callerEnergyLimit, creatorEnergyLimit,
-          VMConfig.allowStrictMath2());
+          VMConfig.disableJavaLangMath());
     }
   }
 

actuator/src/main/java/org/tron/core/utils/TransactionUtil.java

@@ -40,7 +40,6 @@
 import org.tron.common.parameter.CommonParameter;
 import org.tron.common.utils.Sha256Hash;
 import org.tron.core.ChainBaseManager;
-import org.tron.core.Constant;
 import org.tron.core.capsule.AccountCapsule;
 import org.tron.core.capsule.TransactionCapsule;
 import org.tron.core.exception.PermissionException;
@@ -53,7 +52,6 @@
 import org.tron.protos.Protocol.Transaction.Result.contractResult;
 import org.tron.protos.contract.SmartContractOuterClass.CreateSmartContract;
 import org.tron.protos.contract.SmartContractOuterClass.TriggerSmartContract;
-import org.tron.protos.Protocol.Transaction.Contract.ContractType;
 import org.tron.protos.contract.BalanceContract.DelegateResourceContract;
 
 @Slf4j(topic = "capsule")
@@ -271,7 +269,7 @@ public static long estimateConsumeBandWidthSize(DynamicPropertiesStore dps, long
     DelegateResourceContract.Builder builder2 = DelegateResourceContract.newBuilder()
         .setBalance(TRX_PRECISION);
     long builder2Size = builder2.build().getSerializedSize();
-    long addSize = max(builderSize - builder2Size, 0L, dps.allowStrictMath2());
+    long addSize = max(builderSize - builder2Size, 0L, dps.disableJavaLangMath());
 
     return DELEGATE_COST_BASE_SIZE + addSize;
   }

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

@@ -626,7 +626,7 @@ public long getEnergyForData(byte[] data) {
       int expLen = parseLen(data, 1);
       int modLen = parseLen(data, 2);
 
-      boolean allowStrictMath2 = VMConfig.allowStrictMath2();
+      boolean allowStrictMath2 = VMConfig.disableJavaLangMath();
 
       byte[] expHighBytes = parseBytes(data, addSafely(ARGS_OFFSET, baseLen), min(expLen, 32,
           allowStrictMath2));

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

@@ -170,7 +170,7 @@ public static boolean validateForSmartContract(Repository deposit, byte[] ownerA
             "Validate InternalTransfer error, balance is not sufficient.");
       }
 
-      addExact(toAccount.getBalance(), amount, VMConfig.allowStrictMath2());
+      addExact(toAccount.getBalance(), amount, VMConfig.disableJavaLangMath());
     } catch (ArithmeticException e) {
       logger.debug(e.getMessage(), e);
       throw new ContractValidateException(e.getMessage());
@@ -232,7 +232,7 @@ public static boolean validateForSmartContract(Repository deposit, byte[] ownerA
       if (assetBalance != null) {
         try {
           addExact(assetBalance, amount,
-              VMConfig.allowStrictMath2()); //check if overflow
+              VMConfig.disableJavaLangMath()); //check if overflow
         } catch (Exception e) {
           logger.debug(e.getMessage(), e);
           throw new ContractValidateException(e.getMessage());

actuator/src/main/java/org/tron/core/vm/config/ConfigLoader.java

@@ -42,7 +42,7 @@ public static void load(StoreFactory storeFactory) {
         VMConfig.initAllowEnergyAdjustment(ds.getAllowEnergyAdjustment());
         VMConfig.initAllowStrictMath(ds.getAllowStrictMath());
         VMConfig.initAllowTvmCancun(ds.getAllowTvmCancun());
-        VMConfig.initAllowStrictMath2(ds.getConsensusLogicOptimization());
+        VMConfig.initDisableJavaLangMath(ds.getConsensusLogicOptimization());
       }
     }
   }

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

@@ -10,7 +10,6 @@
 import com.google.protobuf.ByteString;
 import java.util.Arrays;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.ArrayUtils;
 import org.tron.common.utils.DecodeUtil;
 import org.tron.common.utils.StringUtil;
 import org.tron.core.ChainBaseManager;
@@ -54,7 +53,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.allowStrictMath2();
+    boolean allowStrictMath2 = dynamicStore.disableJavaLangMath();
     switch (param.getResourceType()) {
       case BANDWIDTH: {
         BandwidthProcessor processor = new BandwidthProcessor(ChainBaseManager.getInstance());

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

@@ -117,7 +117,7 @@ public void execute(UnDelegateResourceParam param, Repository repo) {
                 * dynamicStore.getTotalNetLimit() / repo.getTotalNetWeight());
             transferUsage = (long) (receiverCapsule.getNetUsage()
                 * ((double) (unDelegateBalance) / receiverCapsule.getAllFrozenBalanceForBandwidth()));
-            transferUsage = min(unDelegateMaxUsage, transferUsage, VMConfig.allowStrictMath2());
+            transferUsage = min(unDelegateMaxUsage, transferUsage, VMConfig.disableJavaLangMath());
 
             receiverCapsule.addAcquiredDelegatedFrozenV2BalanceForBandwidth(-unDelegateBalance);
           }
@@ -141,7 +141,7 @@ public void execute(UnDelegateResourceParam param, Repository repo) {
                 * dynamicStore.getTotalEnergyCurrentLimit() / repo.getTotalEnergyWeight());
             transferUsage = (long) (receiverCapsule.getEnergyUsage()
                 * ((double) (unDelegateBalance) / receiverCapsule.getAllFrozenBalanceForEnergy()));
-            transferUsage = min(unDelegateMaxUsage, transferUsage, VMConfig.allowStrictMath2());
+            transferUsage = min(unDelegateMaxUsage, transferUsage, VMConfig.disableJavaLangMath());
 
             receiverCapsule.addAcquiredDelegatedFrozenV2BalanceForEnergy(-unDelegateBalance);
           }

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

@@ -137,11 +137,11 @@ public long execute(UnfreezeBalanceParam param, Repository repo) {
         switch (param.getResourceType()) {
           case BANDWIDTH:
             receiverCapsule.safeAddAcquiredDelegatedFrozenBalanceForBandwidth(-unfreezeBalance,
-                VMConfig.allowStrictMath2());
+                VMConfig.disableJavaLangMath());
             break;
           case ENERGY:
             receiverCapsule.safeAddAcquiredDelegatedFrozenBalanceForEnergy(-unfreezeBalance,
-                VMConfig.allowStrictMath2());
+                VMConfig.disableJavaLangMath());
             break;
           default:
             //this should never happen

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

@@ -105,7 +105,7 @@ public void extend(int address, int size) {
     if (size <= 0) {
       return;
     }
-    boolean allowStrictMath2 = VMConfig.allowStrictMath2();
+    boolean allowStrictMath2 = VMConfig.disableJavaLangMath();
     final int newSize = addExact(address, size, allowStrictMath2);
     int toAllocate = newSize - internalSize();
     if (toAllocate > 0) {
@@ -194,7 +194,7 @@ public void copy(int destPos, int srcPos, int size) {
   private int captureMax(int chunkIndex, int chunkOffset, int size, byte[] src, int srcPos) {
 
     byte[] chunk = chunks.get(chunkIndex);
-    int toCapture = min(size, chunk.length - chunkOffset, VMConfig.allowStrictMath2());
+    int toCapture = min(size, chunk.length - chunkOffset, VMConfig.disableJavaLangMath());
 
     System.arraycopy(src, srcPos, chunk, chunkOffset, toCapture);
     return toCapture;
@@ -203,7 +203,7 @@ private int captureMax(int chunkIndex, int chunkOffset, int size, byte[] src, in
   private int grabMax(int chunkIndex, int chunkOffset, int size, byte[] dest, int destPos) {
 
     byte[] chunk = chunks.get(chunkIndex);
-    int toGrab = min(size, chunk.length - chunkOffset, VMConfig.allowStrictMath2());
+    int toGrab = min(size, chunk.length - chunkOffset, VMConfig.disableJavaLangMath());
 
     System.arraycopy(chunk, chunkOffset, dest, destPos, toGrab);