Release v4.4.0

README.md

@@ -67,7 +67,7 @@ This guide walks the user through the TRON Quickstart (v2.0.0) image setup.
 # Deploy
 * [Build](./build.md) Please build java-tron after cloning the project
 * [Run](./run.md) Run java-tron
-
+* [Build & Run by shell script](./shell.md)
 # Deployment
 [Deployment Guide](https://tronprotocol.github.io/documentation-en/developers/deployment/)
  walks the user through how to deploy a FullNode and an SR node.

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

@@ -10,6 +10,7 @@
 import org.tron.common.utils.Commons;
 import org.tron.common.utils.DecodeUtil;
 import org.tron.core.capsule.AccountCapsule;
+import org.tron.core.capsule.ContractCapsule;
 import org.tron.core.capsule.TransactionResultCapsule;
 import org.tron.core.exception.BalanceInsufficientException;
 import org.tron.core.exception.ContractExeException;
@@ -137,6 +138,23 @@ public boolean validate() throws ContractValidateException {
 
       }
 
+      // after AllowTvmCompatibleEvm proposal, send trx to smartContract which version is one
+      // by actuator is not allowed.
+      if (dynamicStore.getAllowTvmCompatibleEvm() == 1
+          && toAccount != null
+          && toAccount.getType() == AccountType.Contract) {
+
+        ContractCapsule contractCapsule = chainBaseManager.getContractStore().get(toAddress);
+        if (contractCapsule == null) { //  this can not happen
+          throw new ContractValidateException(
+              "Account type is Contract, but it is not exist in contract store.");
+        } else if (contractCapsule.getContractVersion() == 1) {
+          throw new ContractValidateException(
+              "Cannot transfer TRX to a smartContract which version is one. " +
+                  "Instead please use TriggerSmartContract ");
+        }
+      }
+
       if (balance < Math.addExact(amount, fee)) {
         throw new ContractValidateException(
             "Validate TransferContract error, balance is not sufficient.");

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

@@ -177,24 +177,14 @@ public void execute(Object object) throws ContractExeException {
         vm.play(program);
         result = program.getResult();
 
-        if (isConstantCall) {
-          long callValue = TransactionCapsule.getCallValue(trx.getRawData().getContract(0));
-          long callTokenValue = TransactionUtil
-              .getCallTokenValue(trx.getRawData().getContract(0));
-          if (callValue > 0 || callTokenValue > 0) {
-            result.setRuntimeError("constant cannot set call value or call token value.");
-            result.rejectInternalTransactions();
-          }
-          if (result.getException() != null) {
-            result.setRuntimeError(result.getException().getMessage());
-            result.rejectInternalTransactions();
-          }
-          context.setProgramResult(result);
-          return;
-        }
-
         if (TrxType.TRX_CONTRACT_CREATION_TYPE == trxType && !result.isRevert()) {
           byte[] code = program.getResult().getHReturn();
+          if (code.length != 0 && vmConfig.allowTvmLondon() && code[0] == (byte) 0xEF) {
+            if (null == result.getException()) {
+              result.setException(Program.Exception
+                  .invalidCodeException());
+            }
+          }
           long saveCodeEnergy = (long) getLength(code) * EnergyCost.getInstance().getCREATE_DATA();
           long afterSpend = program.getEnergyLimitLeft().longValue() - saveCodeEnergy;
           if (afterSpend < 0) {
@@ -211,6 +201,15 @@ public void execute(Object object) throws ContractExeException {
           }
         }
 
+        if (isConstantCall) {
+          if (result.getException() != null) {
+            result.setRuntimeError(result.getException().getMessage());
+            result.rejectInternalTransactions();
+          }
+          context.setProgramResult(result);
+          return;
+        }
+
         if (result.getException() != null || result.isRevert()) {
           result.getDeleteAccounts().clear();
           result.getLogInfoList().clear();
@@ -297,7 +296,12 @@ private void create()
     if (contract == null) {
       throw new ContractValidateException("Cannot get CreateSmartContract from transaction");
     }
-    SmartContract newSmartContract = contract.getNewContract();
+    SmartContract newSmartContract;
+    if (VMConfig.allowTvmCompatibleEvm()) {
+      newSmartContract = contract.getNewContract().toBuilder().setVersion(1).build();
+    } else {
+      newSmartContract = contract.getNewContract().toBuilder().clearVersion().build();
+    }
     if (!contract.getOwnerAddress().equals(newSmartContract.getOriginAddress())) {
       logger.info("OwnerAddress not equals OriginAddress");
       throw new ContractValidateException("OwnerAddress is not equals OriginAddress");
@@ -346,19 +350,23 @@ private void create()
       long energyLimit;
       // according to version
 
-      if (StorageUtils.getEnergyLimitHardFork()) {
-        if (callValue < 0) {
-          throw new ContractValidateException("callValue must be >= 0");
-        }
-        if (tokenValue < 0) {
-          throw new ContractValidateException("tokenValue must be >= 0");
-        }
-        if (newSmartContract.getOriginEnergyLimit() <= 0) {
-          throw new ContractValidateException("The originEnergyLimit must be > 0");
-        }
-        energyLimit = getAccountEnergyLimitWithFixRatio(creator, feeLimit, callValue);
+      if (isConstantCall) {
+        energyLimit = CommonParameter.getInstance().maxEnergyLimitForConstant;
       } else {
-        energyLimit = getAccountEnergyLimitWithFloatRatio(creator, feeLimit, callValue);
+        if (StorageUtils.getEnergyLimitHardFork()) {
+          if (callValue < 0) {
+            throw new ContractValidateException("callValue must be >= 0");
+          }
+          if (tokenValue < 0) {
+            throw new ContractValidateException("tokenValue must be >= 0");
+          }
+          if (newSmartContract.getOriginEnergyLimit() <= 0) {
+            throw new ContractValidateException("The originEnergyLimit must be > 0");
+          }
+          energyLimit = getAccountEnergyLimitWithFixRatio(creator, feeLimit, callValue);
+        } else {
+          energyLimit = getAccountEnergyLimitWithFloatRatio(creator, feeLimit, callValue);
+        }
       }
 
       checkTokenValueAndId(tokenValue, tokenId);
@@ -377,6 +385,9 @@ private void create()
               vmShouldEndInUs, energyLimit);
       this.vm = new VM();
       this.program = new Program(ops, programInvoke, rootInternalTransaction, vmConfig);
+      if (VMConfig.allowTvmCompatibleEvm()) {
+        this.program.setContractVersion(1);
+      }
       byte[] txId = TransactionUtil.getTransactionId(trx).getBytes();
       this.program.setRootTransactionId(txId);
       if (enableEventListener && isCheckTransaction()) {
@@ -459,7 +470,6 @@ private void call()
 
     byte[] code = repository.getCode(contractAddress);
     if (isNotEmpty(code)) {
-
       long feeLimit = trx.getRawData().getFeeLimit();
       if (feeLimit < 0 || feeLimit > repository.getDynamicPropertiesStore().getMaxFeeLimit()) {
         logger.info("invalid feeLimit {}", feeLimit);
@@ -469,7 +479,7 @@ private void call()
       AccountCapsule caller = repository.getAccount(callerAddress);
       long energyLimit;
       if (isConstantCall) {
-        energyLimit = VMConstant.ENERGY_LIMIT_IN_CONSTANT_TX;
+        energyLimit = CommonParameter.getInstance().maxEnergyLimitForConstant;
       } else {
         AccountCapsule creator = repository
             .getAccount(deployedContract.getInstance().getOriginAddress().toByteArray());
@@ -492,6 +502,9 @@ private void call()
       this.vm = new VM();
       rootInternalTransaction = new InternalTransaction(trx, trxType);
       this.program = new Program(code, programInvoke, rootInternalTransaction, vmConfig);
+      if (VMConfig.allowTvmCompatibleEvm()) {
+        this.program.setContractVersion(deployedContract.getContractVersion());
+      }
       byte[] txId = TransactionUtil.getTransactionId(trx).getBytes();
       this.program.setRootTransactionId(txId);
 

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

@@ -383,9 +383,17 @@ public static void validator(DynamicPropertiesStore dynamicPropertiesStore,
         if (!forkController.pass(ForkBlockVersionEnum.VERSION_4_1_2)) {
           throw new ContractValidateException("Bad chain parameter id [MAX_FEE_LIMIT]");
         }
-        if (value < 0 || value > 10_000_000_000L) {
+        if (value < 0) {
           throw new ContractValidateException(
-              "Bad MAX_FEE_LIMIT parameter value, valid range is [0,10_000_000_000L]");
+              "Bad MAX_FEE_LIMIT parameter value, value must not be negative");
+        } else if (value > 10_000_000_000L) {
+          if (dynamicPropertiesStore.getAllowTvmLondon() == 0) {
+            throw new ContractValidateException(
+                "Bad MAX_FEE_LIMIT parameter value, valid range is [0,10_000_000_000L]");
+          }
+          if (value > LONG_VALUE) {
+            throw new ContractValidateException(LONG_VALUE_ERROR);
+          }
         }
         break;
       }
@@ -469,7 +477,6 @@ public static void validator(DynamicPropertiesStore dynamicPropertiesStore,
         }
         break;
       }
-
       case FREE_NET_LIMIT: {
         if (!forkController.pass(ForkBlockVersionEnum.VERSION_4_3)) {
           throw new ContractValidateException("Bad chain parameter id [FREE_NET_LIMIT]");
@@ -502,6 +509,28 @@ public static void validator(DynamicPropertiesStore dynamicPropertiesStore,
         }
         break;
       }
+      case ALLOW_TVM_LONDON: {
+        if (!forkController.pass(ForkBlockVersionEnum.VERSION_4_4)) {
+          throw new ContractValidateException(
+              "Bad chain parameter id [ALLOW_TVM_LONDON]");
+        }
+        if (value != 1) {
+          throw new ContractValidateException(
+              "This value[ALLOW_TVM_LONDON] is only allowed to be 1");
+        }
+        break;
+      }
+      case ALLOW_TVM_COMPATIBLE_EVM: {
+        if (!forkController.pass(ForkBlockVersionEnum.VERSION_4_4)) {
+          throw new ContractValidateException(
+              "Bad chain parameter id [ALLOW_TVM_COMPATIBLE_EVM]");
+        }
+        if (value != 1) {
+          throw new ContractValidateException(
+              "This value[ALLOW_TVM_COMPATIBLE_EVM] is only allowed to be 1");
+        }
+        break;
+      }
       default:
         break;
     }
@@ -552,16 +581,18 @@ public enum ProposalType {         // current value, value range
     ALLOW_MARKET_TRANSACTION(44), // {0, 1}
     MARKET_SELL_FEE(45), // 0 [0,10_000_000_000]
     MARKET_CANCEL_FEE(46), // 0 [0,10_000_000_000]
-    MAX_FEE_LIMIT(47), // [0, 10_000_000_000]
+    MAX_FEE_LIMIT(47), // [0, 100_000_000_000] TRX
     ALLOW_TRANSACTION_FEE_POOL(48), // 0, 1
     ALLOW_BLACKHOLE_OPTIMIZATION(49),// 0,1
     ALLOW_NEW_RESOURCE_MODEL(51),// 0,1
     ALLOW_TVM_FREEZE(52), // 0, 1
     ALLOW_ACCOUNT_ASSET_OPTIMIZATION(53), // 1
     // ALLOW_NEW_REWARD_ALGORITHM(58), // 0, 1
     ALLOW_TVM_VOTE(59), // 0, 1
+    ALLOW_TVM_COMPATIBLE_EVM(60), // 0, 1
     FREE_NET_LIMIT(61), // 5000, [0, 100_000]
-    TOTAL_NET_LIMIT(62); // 43_200_000_000L, [0, 1000_000_000_000L]
+    TOTAL_NET_LIMIT(62), // 43_200_000_000L, [0, 1000_000_000_000L]
+    ALLOW_TVM_LONDON(63); // 0, 1
 
     private long code;
 

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

@@ -244,6 +244,10 @@ public enum OpCode {
    *  (0x47) Get current account balance
    */
   SELFBALANCE(0x47, 0, 1, Tier.LowTier),
+  /**
+   *  (0x48) Get block's basefee
+   */
+  BASEFEE(0x48, 0, 1, Tier.BaseTier),
 
 
   /*  Memory, Storage and Flow Operations */

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

@@ -24,8 +24,10 @@
 import static org.tron.common.utils.BIUtil.isZero;
 import static org.tron.common.utils.ByteUtil.*;
 import static org.tron.core.db.TransactionTrace.convertToTronAddress;
+import static java.util.Arrays.copyOfRange;
 
 import java.math.BigInteger;
+import java.security.MessageDigest;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
@@ -45,6 +47,8 @@
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.ArrayUtils;
 import org.apache.commons.lang3.tuple.Pair;
+import org.tron.common.crypto.Blake2bfMessageDigest;
+import org.tron.common.crypto.Hash;
 import org.tron.common.crypto.SignUtils;
 import org.tron.common.crypto.SignatureInterface;
 import org.tron.common.crypto.zksnark.BN128;
@@ -107,6 +111,9 @@ public class PrecompiledContracts {
   private static final ReceivedVoteCount receivedVoteCount = new ReceivedVoteCount();
   private static final TotalVoteCount totalVoteCount = new TotalVoteCount();
 
+  private static final EthRipemd160 ethRipemd160 = new EthRipemd160();
+  private static final Blake2F blake2F = new Blake2F();
+
   private static final DataWord ecRecoverAddr = new DataWord(
       "0000000000000000000000000000000000000000000000000000000000000001");
   private static final DataWord sha256Addr = new DataWord(
@@ -147,6 +154,11 @@ public class PrecompiledContracts {
       "0000000000000000000000000000000000000000000000000000000001000009");
   private static final DataWord totalVoteCountAddr = new DataWord(
       "000000000000000000000000000000000000000000000000000000000100000a");
+  private static final DataWord ethRipemd160Addr = new DataWord(
+      "0000000000000000000000000000000000000000000000000000000000020003");
+  private static final DataWord blake2FAddr = new DataWord(
+      "0000000000000000000000000000000000000000000000000000000000020009");
+
 
   public static PrecompiledContract getContractForAddress(DataWord address) {
 
@@ -214,6 +226,12 @@ public static PrecompiledContract getContractForAddress(DataWord address) {
     if (VMConfig.allowTvmVote() && address.equals(totalVoteCountAddr)) {
       return totalVoteCount;
     }
+    if (VMConfig.allowTvmCompatibleEvm() && address.equals(ethRipemd160Addr)) {
+      return ethRipemd160;
+    }
+    if (VMConfig.allowTvmCompatibleEvm() && address.equals(blake2FAddr)) {
+      return blake2F;
+    }
 
     return null;
   }
@@ -1721,4 +1739,66 @@ public Pair<Boolean, byte[]> execute(byte[] data) {
     }
   }
 
+  public static class EthRipemd160 extends PrecompiledContract {
+
+
+    @Override
+    public long getEnergyForData(byte[] data) {
+
+      if (data == null) {
+        return 600;
+      }
+      return 600L + (data.length + 31) / 32 * 120;
+    }
+
+    @Override
+    public Pair<Boolean, byte[]> execute(byte[] data) {
+
+      byte[] result;
+      if (data == null) {
+        result = Hash.ripemd160(EMPTY_BYTE_ARRAY);
+      } else {
+        result = Hash.ripemd160(data);
+      }
+      return Pair.of(true, new DataWord(result).getData());
+    }
+  }
+
+  public static class Blake2F extends PrecompiledContract {
+
+
+    @Override
+    public long getEnergyForData(byte[] data) {
+
+      if (data.length != 213 || (data[212] & 0xFE) != 0) {
+        return 0;
+      }
+      final byte[] roundsBytes = copyOfRange(data, 0, 4);
+      final BigInteger rounds = new BigInteger(1, roundsBytes);
+      return rounds.longValue();
+    }
+
+    @Override
+    public Pair<Boolean, byte[]> execute(byte[] data) {
+
+      if (data.length != 213) {
+        logger.info("Incorrect input length.  Expected {} and got {}", 213, data.length);
+        return Pair.of(false, DataWord.ZERO().getData());
+      }
+      if ((data[212] & 0xFE) != 0) {
+        logger.info("Incorrect finalization flag, expected 0 or 1 and got {}", data[212]);
+        return Pair.of(false, DataWord.ZERO().getData());
+      }
+      final MessageDigest digest = new Blake2bfMessageDigest();
+      byte[] result;
+      try {
+        digest.update(data);
+        result = digest.digest();
+      } catch (Exception e) {
+        return Pair.of(true, EMPTY_BYTE_ARRAY);
+      }
+      return Pair.of(true, result);
+    }
+  }
+
 }