fix(freezeV2): optimize stake2.0 code

CONTRIBUTING.md

@@ -103,12 +103,12 @@ If you want to contribute codes to java-tron, please follow the following steps:
 
   Submit a pull request (PR) from your repository to `tronprotocol/java-tron`.
   Please be sure to click on the link in the red box shown below. Select the base branch for tronprotocol and the compare branch for your personal fork repository.
-  ![](https://codimd.s3.shivering-isles.com/demo/uploads/e24435ab42e4287d9369a2136.png)
+  ![image](https://raw.githubusercontent.com/tronprotocol/documentation-en/master/images/javatron_pr.png)
 
 
 
 ## Code Review Guidelines
-The only way to get code into java-tron is to send a pull request. Those pull requests need to be reviewed by someone. there a guide that explains our expectations around PRs for both authors and reviewers.
+The only way to get code into java-tron is to send a pull request. Those pull requests need to be reviewed by someone. The following guide explains our expectations around PRs for both authors and reviewers.
 
 ### Terminology
 - The author of a pull request is the entity who wrote the diff and submitted it to GitHub.

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

@@ -1,5 +1,7 @@
 package org.tron.core.actuator;
 
+import static org.tron.core.actuator.ActuatorConstant.NOT_EXIST_STR;
+
 import com.google.protobuf.ByteString;
 import com.google.protobuf.InvalidProtocolBufferException;
 import java.util.Arrays;
@@ -16,13 +18,10 @@
 import org.tron.core.store.AbiStore;
 import org.tron.core.store.AccountStore;
 import org.tron.core.store.ContractStore;
-import org.tron.core.vm.config.VMConfig;
 import org.tron.protos.Protocol.Transaction.Contract.ContractType;
 import org.tron.protos.Protocol.Transaction.Result.code;
-import org.tron.protos.contract.SmartContractOuterClass.SmartContract.ABI;
 import org.tron.protos.contract.SmartContractOuterClass.ClearABIContract;
-
-import static org.tron.core.actuator.ActuatorConstant.NOT_EXIST_STR;
+import org.tron.protos.contract.SmartContractOuterClass.SmartContract.ABI;
 
 @Slf4j(topic = "actuator")
 public class ClearABIContractActuator extends AbstractActuator {
@@ -57,17 +56,16 @@ public boolean execute(Object result) throws ContractExeException {
 
   @Override
   public boolean validate() throws ContractValidateException {
-    if (!VMConfig.allowTvmConstantinople()) {
-      throw new ContractValidateException(
-          "contract type error,unexpected type [ClearABIContract]");
-    }
-
     if (this.any == null) {
       throw new ContractValidateException(ActuatorConstant.CONTRACT_NOT_EXIST);
     }
     if (chainBaseManager == null) {
       throw new ContractValidateException("No account store or contract store!");
     }
+    if (chainBaseManager.getDynamicPropertiesStore().getAllowTvmConstantinople() == 0) {
+      throw new ContractValidateException(
+          "contract type error,unexpected type [ClearABIContract]");
+    }
     AccountStore accountStore = chainBaseManager.getAccountStore();
     ContractStore contractStore = chainBaseManager.getContractStore();
     if (!this.any.is(ClearABIContract.class)) {

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

@@ -3,6 +3,10 @@
 import static org.tron.core.actuator.ActuatorConstant.NOT_EXIST_STR;
 import static org.tron.core.config.Parameter.ChainConstant.FROZEN_PERIOD;
 import static org.tron.core.config.Parameter.ChainConstant.TRX_PRECISION;
+import static org.tron.protos.contract.Common.ResourceCode;
+import static org.tron.protos.contract.Common.ResourceCode.BANDWIDTH;
+import static org.tron.protos.contract.Common.ResourceCode.ENERGY;
+import static org.tron.protos.contract.Common.ResourceCode.TRON_POWER;
 
 import com.google.protobuf.ByteString;
 import com.google.protobuf.InvalidProtocolBufferException;
@@ -72,44 +76,48 @@ public boolean execute(Object result) throws ContractExeException {
     byte[] ownerAddress = freezeBalanceContract.getOwnerAddress().toByteArray();
     byte[] receiverAddress = freezeBalanceContract.getReceiverAddress().toByteArray();
 
+    long increment;
     switch (freezeBalanceContract.getResource()) {
       case BANDWIDTH:
         if (!ArrayUtils.isEmpty(receiverAddress)
             && dynamicStore.supportDR()) {
-          delegateResource(ownerAddress, receiverAddress, true,
-              frozenBalance, expireTime);
+          increment = delegateResource(ownerAddress, receiverAddress, true,
+                  frozenBalance, expireTime);
           accountCapsule.addDelegatedFrozenBalanceForBandwidth(frozenBalance);
         } else {
+          long oldNetWeight = accountCapsule.getFrozenBalance() / TRX_PRECISION;
           long newFrozenBalanceForBandwidth =
               frozenBalance + accountCapsule.getFrozenBalance();
           accountCapsule.setFrozenForBandwidth(newFrozenBalanceForBandwidth, expireTime);
+          long newNetWeight = accountCapsule.getFrozenBalance() / TRX_PRECISION;
+          increment = newNetWeight - oldNetWeight;
         }
-        dynamicStore
-            .addTotalNetWeight(frozenBalance / TRX_PRECISION);
+        addTotalWeight(BANDWIDTH, dynamicStore, frozenBalance, increment);
         break;
       case ENERGY:
         if (!ArrayUtils.isEmpty(receiverAddress)
             && dynamicStore.supportDR()) {
-          delegateResource(ownerAddress, receiverAddress, false,
-              frozenBalance, expireTime);
+          increment = delegateResource(ownerAddress, receiverAddress, false,
+                  frozenBalance, expireTime);
           accountCapsule.addDelegatedFrozenBalanceForEnergy(frozenBalance);
         } else {
+          long oldEnergyWeight = accountCapsule.getEnergyFrozenBalance() / TRX_PRECISION;
           long newFrozenBalanceForEnergy =
-              frozenBalance + accountCapsule.getAccountResource()
-                  .getFrozenBalanceForEnergy()
-                  .getFrozenBalance();
+              frozenBalance + accountCapsule.getEnergyFrozenBalance();
           accountCapsule.setFrozenForEnergy(newFrozenBalanceForEnergy, expireTime);
+          long newEnergyWeight = accountCapsule.getEnergyFrozenBalance() / TRX_PRECISION;
+          increment = newEnergyWeight - oldEnergyWeight;
         }
-        dynamicStore
-            .addTotalEnergyWeight(frozenBalance / TRX_PRECISION);
+        addTotalWeight(ENERGY, dynamicStore, frozenBalance, increment);
         break;
       case TRON_POWER:
+        long oldTPWeight = accountCapsule.getTronPowerFrozenBalance() / TRX_PRECISION;
         long newFrozenBalanceForTronPower =
             frozenBalance + accountCapsule.getTronPowerFrozenBalance();
         accountCapsule.setFrozenForTronPower(newFrozenBalanceForTronPower, expireTime);
-
-        dynamicStore
-            .addTotalTronPowerWeight(frozenBalance / TRX_PRECISION);
+        long newTPWeight = accountCapsule.getTronPowerFrozenBalance() / TRX_PRECISION;
+        increment = newTPWeight - oldTPWeight;
+        addTotalWeight(TRON_POWER, dynamicStore, frozenBalance, increment);
         break;
       default:
         logger.debug("Resource Code Error.");
@@ -123,6 +131,23 @@ public boolean execute(Object result) throws ContractExeException {
     return true;
   }
 
+  private void addTotalWeight(ResourceCode resourceCode, DynamicPropertiesStore dynamicStore,
+                              long frozenBalance, long increment) {
+    long weight = dynamicStore.allowNewReward() ? increment : frozenBalance / TRX_PRECISION;
+    switch (resourceCode) {
+      case BANDWIDTH:
+        dynamicStore.addTotalNetWeight(weight);
+        break;
+      case ENERGY:
+        dynamicStore.addTotalEnergyWeight(weight);
+        break;
+      case TRON_POWER:
+        dynamicStore.addTotalTronPowerWeight(weight);
+        break;
+      default:
+        logger.debug("Resource Code Error.");
+    }
+  }
 
   @Override
   public boolean validate() throws ContractValidateException {
@@ -175,11 +200,6 @@ public boolean validate() throws ContractValidateException {
       throw new ContractValidateException("frozenBalance must be less than accountBalance");
     }
 
-//    long maxFrozenNumber = dbManager.getDynamicPropertiesStore().getMaxFrozenNumber();
-//    if (accountCapsule.getFrozenCount() >= maxFrozenNumber) {
-//      throw new ContractValidateException("max frozen number is: " + maxFrozenNumber);
-//    }
-
     long frozenDuration = freezeBalanceContract.getFrozenDuration();
     long minFrozenTime = dynamicStore.getMinFrozenTime();
     long maxFrozenTime = dynamicStore.getMaxFrozenTime();
@@ -224,8 +244,7 @@ public boolean validate() throws ContractValidateException {
     //If the receiver is included in the contract, the receiver will receive the resource.
     if (!ArrayUtils.isEmpty(receiverAddress) && dynamicStore.supportDR()) {
       if (Arrays.equals(receiverAddress, ownerAddress)) {
-        throw new ContractValidateException(
-            "receiverAddress must not be the same as ownerAddress");
+        throw new ContractValidateException("receiverAddress must not be the same as ownerAddress");
       }
 
       if (!DecodeUtil.addressValid(receiverAddress)) {
@@ -267,9 +286,10 @@ public long calcFee() {
     return 0;
   }
 
-  private void delegateResource(byte[] ownerAddress, byte[] receiverAddress, boolean isBandwidth,
+  private long delegateResource(byte[] ownerAddress, byte[] receiverAddress, boolean isBandwidth,
       long balance, long expireTime) {
     AccountStore accountStore = chainBaseManager.getAccountStore();
+    DynamicPropertiesStore dynamicPropertiesStore = chainBaseManager.getDynamicPropertiesStore();
     DelegatedResourceStore delegatedResourceStore = chainBaseManager.getDelegatedResourceStore();
     DelegatedResourceAccountIndexStore delegatedResourceAccountIndexStore = chainBaseManager
         .getDelegatedResourceAccountIndexStore();
@@ -297,46 +317,56 @@ private void delegateResource(byte[] ownerAddress, byte[] receiverAddress, boole
     delegatedResourceStore.put(key, delegatedResourceCapsule);
 
     //modify DelegatedResourceAccountIndexStore
-    {
-      DelegatedResourceAccountIndexCapsule delegatedResourceAccountIndexCapsule = delegatedResourceAccountIndexStore
-          .get(ownerAddress);
-      if (delegatedResourceAccountIndexCapsule == null) {
-        delegatedResourceAccountIndexCapsule = new DelegatedResourceAccountIndexCapsule(
+    if (!dynamicPropertiesStore.supportAllowDelegateOptimization()) {
+
+      DelegatedResourceAccountIndexCapsule ownerIndexCapsule =
+          delegatedResourceAccountIndexStore.get(ownerAddress);
+      if (ownerIndexCapsule == null) {
+        ownerIndexCapsule = new DelegatedResourceAccountIndexCapsule(
             ByteString.copyFrom(ownerAddress));
       }
-      List<ByteString> toAccountsList = delegatedResourceAccountIndexCapsule.getToAccountsList();
+      List<ByteString> toAccountsList = ownerIndexCapsule.getToAccountsList();
       if (!toAccountsList.contains(ByteString.copyFrom(receiverAddress))) {
-        delegatedResourceAccountIndexCapsule.addToAccount(ByteString.copyFrom(receiverAddress));
+        ownerIndexCapsule.addToAccount(ByteString.copyFrom(receiverAddress));
       }
-      delegatedResourceAccountIndexStore
-          .put(ownerAddress, delegatedResourceAccountIndexCapsule);
-    }
+      delegatedResourceAccountIndexStore.put(ownerAddress, ownerIndexCapsule);
 
-    {
-      DelegatedResourceAccountIndexCapsule delegatedResourceAccountIndexCapsule = delegatedResourceAccountIndexStore
-          .get(receiverAddress);
-      if (delegatedResourceAccountIndexCapsule == null) {
-        delegatedResourceAccountIndexCapsule = new DelegatedResourceAccountIndexCapsule(
+      DelegatedResourceAccountIndexCapsule receiverIndexCapsule
+          = delegatedResourceAccountIndexStore.get(receiverAddress);
+      if (receiverIndexCapsule == null) {
+        receiverIndexCapsule = new DelegatedResourceAccountIndexCapsule(
             ByteString.copyFrom(receiverAddress));
       }
-      List<ByteString> fromAccountsList = delegatedResourceAccountIndexCapsule
+      List<ByteString> fromAccountsList = receiverIndexCapsule
           .getFromAccountsList();
       if (!fromAccountsList.contains(ByteString.copyFrom(ownerAddress))) {
-        delegatedResourceAccountIndexCapsule.addFromAccount(ByteString.copyFrom(ownerAddress));
+        receiverIndexCapsule.addFromAccount(ByteString.copyFrom(ownerAddress));
       }
-      delegatedResourceAccountIndexStore
-          .put(receiverAddress, delegatedResourceAccountIndexCapsule);
+      delegatedResourceAccountIndexStore.put(receiverAddress, receiverIndexCapsule);
+
+    } else {
+      // modify DelegatedResourceAccountIndexStore new
+      delegatedResourceAccountIndexStore.convert(ownerAddress);
+      delegatedResourceAccountIndexStore.convert(receiverAddress);
+      delegatedResourceAccountIndexStore.delegate(ownerAddress, receiverAddress,
+          dynamicPropertiesStore.getLatestBlockHeaderTimestamp());
     }
 
     //modify AccountStore
     AccountCapsule receiverCapsule = accountStore.get(receiverAddress);
+    long oldWeight;
+    long newWeight;
     if (isBandwidth) {
+      oldWeight = receiverCapsule.getAcquiredDelegatedFrozenBalanceForBandwidth() / TRX_PRECISION;
       receiverCapsule.addAcquiredDelegatedFrozenBalanceForBandwidth(balance);
+      newWeight = receiverCapsule.getAcquiredDelegatedFrozenBalanceForBandwidth() / TRX_PRECISION;
     } else {
+      oldWeight = receiverCapsule.getAcquiredDelegatedFrozenBalanceForEnergy() / TRX_PRECISION;
       receiverCapsule.addAcquiredDelegatedFrozenBalanceForEnergy(balance);
+      newWeight = receiverCapsule.getAcquiredDelegatedFrozenBalanceForEnergy() / TRX_PRECISION;
     }
-
     accountStore.put(receiverCapsule.createDbKey(), receiverCapsule);
+    return newWeight - oldWeight;
   }
 
 }