Tron EVM 1.0

Author: guoygang

src/main/java/org/tron/common/runtime/Runtime.java

@@ -17,7 +17,7 @@
 import org.tron.core.capsule.*;
 import org.tron.core.db.Manager;
 import org.tron.protos.Contract;
-import org.tron.protos.Contract.ContractCreationContract;
+import org.tron.protos.Contract.ContractDeployContract;
 import org.tron.protos.Protocol;
 import org.tron.protos.Protocol.Block;
 import org.tron.protos.Protocol.Transaction;
@@ -66,10 +66,10 @@ public Runtime(Transaction tx, Block block, Manager dbManager,
 
         Transaction.Contract.ContractType contractType = tx.getRawData().getContract(0).getType();
         switch (contractType.getNumber()) {
-            case Transaction.Contract.ContractType.ContractCallContract_VALUE:
+            case Transaction.Contract.ContractType.TriggerContract_VALUE:
                 trxType = TRX_CONTRACT_CALL_TYPE;
                 break;
-            case Transaction.Contract.ContractType.ContractCreationContract_VALUE:
+            case Transaction.Contract.ContractType.DeployContract_VALUE:
                 trxType = TRX_CONTRACT_CREATION_TYPE;
                 break;
             default:
@@ -92,10 +92,10 @@ public Runtime(Transaction tx, Manager dbManager, ProgramInvokeFactory programIn
         this.executerType = ET_PRE_TYPE;
         Transaction.Contract.ContractType contractType = tx.getRawData().getContract(0).getType();
         switch (contractType.getNumber()) {
-            case Transaction.Contract.ContractType.ContractCallContract_VALUE:
+            case Transaction.Contract.ContractType.TriggerContract_VALUE:
                 trxType = TRX_CONTRACT_CALL_TYPE;
                 break;
-            case Transaction.Contract.ContractType.ContractCreationContract_VALUE:
+            case Transaction.Contract.ContractType.DeployContract_VALUE:
                 trxType = TRX_CONTRACT_CREATION_TYPE;
                 break;
             default:
@@ -159,7 +159,7 @@ public void execute() {
     }
 
     private void call() {
-        Contract.ContractCallContract contract = ContractCapsule.getCallContractFromTransaction(trx);
+        Contract.ContractTriggerContract contract = ContractCapsule.getTriggerContractFromTransaction(trx);
         if (contract == null) return;
 
         byte[] contractAddress = contract.getContractAddress().toByteArray();
@@ -178,11 +178,11 @@ private void call() {
     /*
      **/
     private void create() {
-        ContractCreationContract contract = ContractCapsule.getCreationContractFromTransaction(trx);
+        ContractDeployContract contract = ContractCapsule.getDeployContractFromTransaction(trx);
 
         // Create a Contract Account by ownerAddress or If the address exist, random generate one
         byte[] code = contract.getBytecode().toByteArray();
-        ContractCreationContract.ABI abi = contract.getAbi();
+        ContractDeployContract.ABI abi = contract.getAbi();
         byte[] ownerAddress = contract.getOwnerAddress().toByteArray();
         ByteString newContractAddress = contract.getContractAddress();
 

src/main/java/org/tron/common/runtime/vm/program/invoke/ProgramInvokeFactoryImpl.java

@@ -27,7 +27,8 @@
 import org.tron.core.capsule.AccountCapsule;
 import org.tron.core.capsule.ContractCapsule;
 import org.tron.core.db.Manager;
-import org.tron.protos.Contract;
+import org.tron.protos.Contract.ContractDeployContract;
+import org.tron.protos.Contract.ContractTriggerContract;
 import org.tron.protos.Protocol.Block;
 import org.tron.protos.Protocol.Transaction;
 
@@ -57,7 +58,7 @@ public ProgramInvoke createProgramInvoke(InternalTransaction.TrxType trxType, In
         long number = -1L;
 
         if (trxType == TRX_CONTRACT_CREATION_TYPE) {
-            Contract.ContractCreationContract contract = ContractCapsule.getCreationContractFromTransaction(tx);
+            ContractDeployContract contract = ContractCapsule.getDeployContractFromTransaction(tx);
             contractAddress = contract.getContractAddress().toByteArray();
             ownerAddress = contract.getOwnerAddress().toByteArray();
             AccountCapsule accountCapsule = manager.getAccountStore().get(ownerAddress);
@@ -82,7 +83,7 @@ public ProgramInvoke createProgramInvoke(InternalTransaction.TrxType trxType, In
                     lastHash, coinbase, timestamp, number, manager);
 
         } else if (trxType == TRX_CONTRACT_CALL_TYPE) {
-            Contract.ContractCallContract contract = ContractCapsule.getCallContractFromTransaction(tx);
+            ContractTriggerContract contract = ContractCapsule.getTriggerContractFromTransaction(tx);
             /***         ADDRESS op       ***/
             // YP: Get address of currently executing account.
             // byte[] address = tx.isContractCreation() ? tx.getContractAddress() : tx.getReceiveAddress();

src/main/java/org/tron/core/Wallet.java

@@ -18,9 +18,14 @@
 
 package org.tron.core;
 
+import com.google.protobuf.Any;
 import com.google.protobuf.ByteString;
+
+import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
+
+import com.google.protobuf.InvalidProtocolBufferException;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.ArrayUtils;
@@ -38,15 +43,13 @@
 import org.tron.common.crypto.ECKey;
 import org.tron.common.crypto.Hash;
 import org.tron.common.overlay.message.Message;
+import org.tron.common.runtime.vm.program.ProgramResult;
 import org.tron.common.utils.Base58;
 import org.tron.common.utils.ByteArray;
 import org.tron.common.utils.Utils;
-import org.tron.core.capsule.AccountCapsule;
-import org.tron.core.capsule.AssetIssueCapsule;
-import org.tron.core.capsule.BlockCapsule;
-import org.tron.core.capsule.TransactionCapsule;
-import org.tron.core.capsule.WitnessCapsule;
+import org.tron.core.capsule.*;
 import org.tron.core.db.AccountStore;
+import org.tron.core.db.ContractStore;
 import org.tron.core.db.Manager;
 import org.tron.core.db.PendingManager;
 import org.tron.core.exception.ContractExeException;
@@ -60,6 +63,8 @@
 import org.tron.core.exception.ValidateSignatureException;
 import org.tron.core.net.message.TransactionMessage;
 import org.tron.core.net.node.NodeImpl;
+import org.tron.protos.Contract.ContractDeployContract;
+import org.tron.protos.Contract.ContractTriggerContract;
 import org.tron.protos.Contract.AssetIssueContract;
 import org.tron.protos.Contract.TransferContract;
 import org.tron.protos.Protocol.Account;
@@ -392,4 +397,115 @@ public Transaction getTransactionById(ByteString transactionId) {
     }
     return transaction;
   }
+
+  public Transaction deployContract(ContractDeployContract contractDeployContract) {
+    return new TransactionCapsule(contractDeployContract, Transaction.Contract.ContractType.DeployContract)
+            .getInstance();
+  }
+
+  public Transaction triggerContract(ContractTriggerContract contractTriggerContract) {
+    ContractStore contractStore = dbManager.getContractStore();
+    byte[] contractAddress = contractTriggerContract.getContractAddress().toByteArray();
+    ContractDeployContract.ABI abi = contractStore.getABI(contractAddress);
+    if (abi == null) {
+      return null;
+    }
+
+    try {
+      byte[] selector = getSelector(contractTriggerContract.getData().toByteArray());
+      if (selector == null) {
+        return null;
+      }
+
+      Transaction trx = null;
+      if (!isConstant(abi, selector)) {
+        trx = new TransactionCapsule(contractTriggerContract, Transaction.Contract.ContractType.TriggerContract)
+                .getInstance();
+      } else {
+        TransactionCapsule trxCap = new TransactionCapsule(contractTriggerContract, Transaction.Contract.ContractType.TriggerContract);
+        /*ProgramResult programResult = DepositController.getInstance().processConstantTransaction(trxCap);
+        Transaction.Result.Builder builder = Transaction.Result.newBuilder();
+        builder.setConstantResult(ByteString.copyFrom(programResult.getHReturn()));
+        trx = trxCap.getInstance();
+        trx = trx.toBuilder().addRet(builder.build()).build();*/
+      }
+
+      return trx;
+    } catch (Exception e) {
+      logger.error(e.getMessage());
+      return null;
+    }
+  }
+
+  public ContractDeployContract getContract(GrpcAPI.BytesMessage bytesMessage) {
+    byte[] address = bytesMessage.getValue().toByteArray();
+    AccountCapsule accountCapsule = dbManager.getAccountStore().get(address);
+    if (accountCapsule == null || ArrayUtils.isEmpty(accountCapsule.getCodeHash())) {
+      logger.error("Get contract failed, the account is not exist or the account does not have code hash!");
+      return null;
+    }
+
+    ContractCapsule contractCapsule = dbManager.getContractStore().get(bytesMessage.getValue().toByteArray());
+    Transaction trx = contractCapsule.getInstance();
+    Any contract = trx.getRawData().getContract(0).getParameter();
+    if (contract.is(ContractDeployContract.class)) {
+      try {
+        return contract.unpack(ContractDeployContract.class);
+      } catch (InvalidProtocolBufferException e) {
+        return null;
+      }
+    }
+    return null;
+  }
+
+  private byte[] getSelector(byte[] data) {
+    if (data == null ||
+            data.length < 4) {
+      return null;
+    }
+
+    byte[] ret = new byte[4];
+    System.arraycopy(data, 0, ret, 0, 4);
+    return ret;
+  }
+
+  private boolean isConstant(ContractDeployContract.ABI abi, byte[] selector) throws Exception{
+    if (selector == null || selector.length != 4) {
+      throw new Exception("Selector's length or selector itself is invalid");
+    }
+
+    for (int i = 0; i < abi.getEntrysCount(); i++) {
+      ContractDeployContract.ABI.Entry entry = abi.getEntrys(i);
+      if (entry.getType() != ContractDeployContract.ABI.Entry.EntryType.Function) {
+        continue;
+      }
+
+      int inputCount = entry.getInputsCount();
+      StringBuffer sb = new StringBuffer();
+      sb.append(entry.getName().toStringUtf8());
+      sb.append("(");
+      for (int k = 0; k < inputCount; k++) {
+        ContractDeployContract.ABI.Entry.Param param = entry.getInputs(k);
+        sb.append(param.getType().toStringUtf8());
+        if (k + 1 < inputCount) {
+          sb.append(",");
+        }
+      }
+      sb.append(")");
+
+      byte[] funcSelector = new byte[4];
+      System.arraycopy(Hash.sha3(sb.toString().getBytes()), 0, funcSelector, 0, 4);
+      if (Arrays.equals(funcSelector, selector)) {
+        if (entry.getConstant() == true) {
+          return true;
+        } else {
+          return false;
+        }
+      }
+    }
+
+    throw new Exception("There is no the selector!");
+  }
+
+
 }

src/main/java/org/tron/core/capsule/CodeCapsule.java

@@ -21,8 +21,9 @@
 import lombok.extern.slf4j.Slf4j;
 import org.tron.common.crypto.ECKey.ECDSASignature;
 import org.tron.common.utils.Sha256Hash;
-import org.tron.protos.Contract.ContractCallContract;
-import org.tron.protos.Contract.ContractCreationContract;
+import org.tron.protos.Contract;
+import org.tron.protos.Contract.ContractDeployContract;
+import org.tron.protos.Contract.ContractTriggerContract;
 import org.tron.protos.Protocol.Transaction;
 
 /**
@@ -42,26 +43,6 @@ public CodeCapsule(ByteString bs) {
     this.code = bs.toByteArray();
   }
 
-  public static ContractCreationContract getCreationContractFromTransaction(Transaction trx) {
-    try {
-      Any any = trx.getRawData().getContract(0).getParameter();
-      ContractCreationContract contractCreationContract = any.unpack(ContractCreationContract.class);
-      return contractCreationContract;
-    } catch (InvalidProtocolBufferException e) {
-      return null;
-    }
-  }
-
-  public static ContractCallContract getCallContractFromTransaction(Transaction trx) {
-    try {
-      Any any = trx.getRawData().getContract(0).getParameter();
-      ContractCallContract contractCallContract = any.unpack(ContractCallContract.class);
-      return contractCallContract;
-    } catch (InvalidProtocolBufferException e) {
-      return null;
-    }
-  }
-
   public Sha256Hash getHash() {
     return Sha256Hash.of(this.code);
   }

src/main/java/org/tron/core/capsule/ContractCapsule.java

@@ -22,15 +22,10 @@
 import org.tron.common.crypto.ECKey;
 import org.tron.common.crypto.ECKey.ECDSASignature;
 import org.tron.common.utils.Sha256Hash;
-import org.tron.core.Wallet;
-import org.tron.protos.Contract.ContractCallContract;
-import org.tron.protos.Contract.ContractCreationContract;
+import org.tron.protos.Contract.ContractDeployContract;
+import org.tron.protos.Contract.ContractTriggerContract;
 import org.tron.protos.Protocol.Transaction;
 
-/**
- *
- * Created by Guo Yonggang on 04.14.2018
- */
 @Slf4j
 public class ContractCapsule implements ProtoCapsule<Transaction> {
 
@@ -51,21 +46,21 @@ public ContractCapsule(byte[] data) {
     }
   }
 
-  public static ContractCreationContract getCreationContractFromTransaction(Transaction trx) {
+  public static ContractDeployContract getDeployContractFromTransaction(Transaction trx) {
     try {
       Any any = trx.getRawData().getContract(0).getParameter();
-      ContractCreationContract contractCreationContract = any.unpack(ContractCreationContract.class);
-      return contractCreationContract;
+      ContractDeployContract contractDeployContract = any.unpack(ContractDeployContract.class);
+      return contractDeployContract;
     } catch (InvalidProtocolBufferException e) {
       return null;
     }
   }
 
-  public static ContractCallContract getCallContractFromTransaction(Transaction trx) {
+  public static ContractTriggerContract getTriggerContractFromTransaction(Transaction trx) {
     try {
       Any any = trx.getRawData().getContract(0).getParameter();
-      ContractCallContract contractCallContract = any.unpack(ContractCallContract.class);
-      return contractCallContract;
+      ContractTriggerContract contractTriggerContract = any.unpack(ContractTriggerContract.class);
+      return contractTriggerContract;
     } catch (InvalidProtocolBufferException e) {
       return null;
     }
@@ -83,8 +78,8 @@ public Sha256Hash getRawHash() {
   public Sha256Hash getCodeHash() {
     try {
       Any any = transaction.getRawData().getContract(0).getParameter();
-      ContractCreationContract contractCreationContract = any.unpack(ContractCreationContract.class);
-      byte[] bytecode = contractCreationContract.getBytecode().toByteArray();
+      ContractDeployContract contractDeployContract = any.unpack(ContractDeployContract.class);
+      byte[] bytecode = contractDeployContract.getBytecode().toByteArray();
       return Sha256Hash.of(bytecode);
     } catch (InvalidProtocolBufferException e) {
       return null;

src/main/java/org/tron/core/capsule/TransactionCapsule.java

@@ -16,7 +16,6 @@
 package org.tron.core.capsule;
 
 import static org.tron.protos.Contract.AssetIssueContract;
-import static org.tron.protos.Contract.DeployContract;
 import static org.tron.protos.Contract.VoteAssetContract;
 import static org.tron.protos.Contract.VoteWitnessContract;
 import static org.tron.protos.Contract.WitnessCreateContract;
@@ -38,6 +37,7 @@
 import org.tron.core.Wallet;
 import org.tron.core.db.AccountStore;
 import org.tron.core.exception.ValidateSignatureException;
+import org.tron.protos.Contract;
 import org.tron.protos.Contract.AccountCreateContract;
 import org.tron.protos.Contract.AccountUpdateContract;
 import org.tron.protos.Contract.FreezeBalanceContract;
@@ -254,9 +254,6 @@ public static byte[] getOwner(Transaction.Contract contract) {
         case AssetIssueContract:
           owner = contractParameter.unpack(AssetIssueContract.class).getOwnerAddress();
           break;
-        case DeployContract:
-          owner = contractParameter.unpack(DeployContract.class).getOwnerAddress();
-          break;
         case WitnessUpdateContract:
           owner = contractParameter.unpack(WitnessUpdateContract.class).getOwnerAddress();
           break;
@@ -275,6 +272,12 @@ public static byte[] getOwner(Transaction.Contract contract) {
         case WithdrawBalanceContract:
           owner = contractParameter.unpack(WithdrawBalanceContract.class).getOwnerAddress();
           break;
+        case DeployContract:
+          owner = contractParameter.unpack(Contract.ContractDeployContract.class).getOwnerAddress();
+          break;
+        case TriggerContract:
+          owner = contractParameter.unpack(Contract.ContractTriggerContract.class).getOwnerAddress();
+          break;
         // todo add other contract
         default:
           return null;