Merge pull request #6185 from raymondliu0711/feature/vm_cancun_opcodes

feat(tvm): implement TIP-650&TIP-651

Author: CodeNinjaEvan

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

@@ -809,6 +809,21 @@ public static void validator(DynamicPropertiesStore dynamicPropertiesStore,
         }
         break;
       }
+      case ALLOW_TVM_CANCUN: {
+        if (!forkController.pass(ForkBlockVersionEnum.VERSION_4_8_0)) {
+          throw new ContractValidateException(
+              "Bad chain parameter id [ALLOW_TVM_CANCUN]");
+        }
+        if (dynamicPropertiesStore.getAllowTvmCancun() == 1) {
+          throw new ContractValidateException(
+              "[ALLOW_TVM_CANCUN] has been valid, no need to propose again");
+        }
+        if (value != 1) {
+          throw new ContractValidateException(
+              "This value[ALLOW_TVM_CANCUN] is only allowed to be 1");
+        }
+        break;
+      }
       default:
         break;
     }
@@ -888,6 +903,7 @@ public enum ProposalType {         // current value, value range
     ALLOW_OLD_REWARD_OPT(79), // 0, 1
     ALLOW_ENERGY_ADJUSTMENT(81), // 0, 1
     MAX_CREATE_ACCOUNT_TX_SIZE(82), // [500, 10000]
+    ALLOW_TVM_CANCUN(83), // 0, 1
     ALLOW_STRICT_MATH(87), // 0, 1
     CONSENSUS_LOGIC_OPTIMIZATION(88); // 0, 1
 

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

@@ -57,6 +57,8 @@ public class EnergyCost {
   private static final long SUICIDE = 0;
   private static final long STOP = 0;
   private static final long CREATE_DATA = 200;
+  private static final long TLOAD = 100;
+  private static final long TSTORE = 100;
 
   public static long getZeroTierCost(Program ignored) {
     return ZERO_TIER;
@@ -232,6 +234,26 @@ public static long getSstoreCost(Program program) {
 
   }
 
+  public static long getTLoadCost(Program ignored) {
+    return TLOAD;
+  }
+
+  public static long getTStoreCost(Program ignored) {
+    return TSTORE;
+  }
+
+  public static long getMCopyCost(Program program) {
+    Stack stack = program.getStack();
+    long oldMemSize = program.getMemSize();
+    
+    int dstOffset = stack.peek().intValue();
+    int srcOffset = stack.get(stack.size() - 2).intValue();
+    DataWord maxOffset = new DataWord(Math.max(dstOffset, srcOffset));
+    return VERY_LOW_TIER + calcMemEnergy(oldMemSize,
+        memNeeded(maxOffset, stack.get(stack.size() - 3)),
+        stack.get(stack.size() - 3).longValueSafe(), Op.MCOPY);
+  }
+
   public static long getLogCost(Program program) {
     Stack stack = program.getStack();
     long oldMemSize = program.getMemSize();

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

@@ -145,6 +145,12 @@ public class Op {
   // (0x5a) Get the amount of available gas
   public static final int GAS = 0x5a;
   public static final int JUMPDEST = 0x5b;
+  // (0x5c) Load word from transient storage
+  public static final int TLOAD = 0x5c;
+  // (0x5d) Save word to transient storage
+  public static final int TSTORE = 0x5d;
+  // (0x5e) Copy word from memory
+  public static final int MCOPY = 0x5e;
 
   /*  Push Operations */
   // Place item on stack

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

@@ -643,6 +643,37 @@ public static void jumpDestAction(Program program) {
     program.step();
   }
 
+  public static void tLoadAction(Program program) {
+    DataWord key = program.stackPop();
+    DataWord address = program.getContractAddress();
+
+    byte[] data =
+        program.getContractState().getTransientStorageValue(address.getData(), key.getData());
+    DataWord value = data != null ? new DataWord(data) : DataWord.ZERO();
+
+    program.stackPush(value);
+    program.step();
+  }
+
+  public static void tStoreAction(Program program) {
+    DataWord key = program.stackPop();
+    DataWord value = program.stackPop();
+    DataWord address = program.getContractAddress();
+
+    program.getContractState()
+        .updateTransientStorageValue(address.getData(), key.getData(), value.getData());
+    program.step();
+  }
+
+  public static void mCopyAction(Program program) {
+    int dstOffset = program.stackPop().intValueSafe();
+    int srcOffset = program.stackPop().intValueSafe();
+    int length = program.stackPop().intValueSafe();
+
+    program.memoryCopy(dstOffset, srcOffset, length);
+    program.step();
+  }
+
   public static void push0Action(Program program) {
     program.stackPush(DataWord.ZERO());
     program.step();

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

@@ -12,6 +12,7 @@ public enum Version {
     TRON_V1_1,
     TRON_V1_2,
     TRON_V1_3,
+    TRON_V1_4,
     // add more
     // TRON_V2,
     // ETH
@@ -24,6 +25,7 @@ public enum Version {
     tableMap.put(Version.TRON_V1_1, newTronV11OperationSet());
     tableMap.put(Version.TRON_V1_2, newTronV12OperationSet());
     tableMap.put(Version.TRON_V1_3, newTronV13OperationSet());
+    tableMap.put(Version.TRON_V1_4, newTronV14OperationSet());
   }
 
   public static JumpTable newTronV10OperationSet() {
@@ -55,12 +57,18 @@ public static JumpTable newTronV13OperationSet() {
     return table;
   }
 
+  public static JumpTable newTronV14OperationSet() {
+    JumpTable table = newTronV13OperationSet();
+    appendCancunOperations(table);
+    return table;
+  }
+
   // Just for warming up class to avoid out_of_time
   public static void init() {}
 
   public static JumpTable getTable() {
     // always get the table which has the newest version
-    JumpTable table = tableMap.get(Version.TRON_V1_3);
+    JumpTable table = tableMap.get(Version.TRON_V1_4);
 
     // next make the corresponding changes, exclude activating opcode
     if (VMConfig.allowHigherLimitForMaxCpuTimeOfOneTx()) {
@@ -652,4 +660,26 @@ public static void adjustForFairEnergy(JumpTable table) {
         EnergyCost::getSuicideCost2,
         OperationActions::suicideAction));
   }
+
+  public static void appendCancunOperations(JumpTable table) {
+    BooleanSupplier proposal = VMConfig::allowTvmCancun;
+
+    table.set(new Operation(
+        Op.TLOAD, 1, 1,
+        EnergyCost::getTLoadCost,
+        OperationActions::tLoadAction,
+        proposal));
+
+    table.set(new Operation(
+        Op.TSTORE, 2, 0,
+        EnergyCost::getTStoreCost,
+        OperationActions::tStoreAction,
+        proposal));
+
+    table.set(new Operation(
+        Op.MCOPY, 3, 0,
+        EnergyCost::getMCopyCost,
+        OperationActions::mCopyAction,
+        proposal));
+  }
 }

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

@@ -41,6 +41,7 @@ public static void load(StoreFactory storeFactory) {
         VMConfig.initAllowTvmShangHai(ds.getAllowTvmShangHai());
         VMConfig.initAllowEnergyAdjustment(ds.getAllowEnergyAdjustment());
         VMConfig.initAllowStrictMath(ds.getAllowStrictMath());
+        VMConfig.initAllowTvmCancun(ds.getAllowTvmCancun());
       }
     }
   }

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

@@ -53,6 +53,8 @@ public class VMConfig {
 
   private static boolean ALLOW_STRICT_MATH = false;
 
+  private static boolean ALLOW_TVM_CANCUN = false;
+
   private VMConfig() {
   }
 
@@ -148,6 +150,10 @@ public static void initAllowStrictMath(long allow) {
     ALLOW_STRICT_MATH = allow == 1;
   }
 
+  public static void initAllowTvmCancun(long allow) {
+    ALLOW_TVM_CANCUN = allow == 1;
+  }
+
   public static boolean getEnergyLimitHardFork() {
     return CommonParameter.ENERGY_LIMIT_HARD_FORK;
   }
@@ -231,4 +237,8 @@ public static boolean allowEnergyAdjustment() {
   public static boolean allowStrictMath() {
     return ALLOW_STRICT_MATH;
   }
+
+  public static boolean allowTvmCancun() {
+    return ALLOW_TVM_CANCUN;
+  }
 }

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

@@ -229,6 +229,11 @@ public void putDelegatedResourceAccountIndex(Key key, Value value) {
     repository.putDelegatedResourceAccountIndex(key, value);
   }
 
+  @Override
+  public void putTransientStorageValue(Key address, Key key, Value value) {
+    repository.putTransientStorageValue(address, key, value);
+  }
+
   @Override
   public long addTokenBalance(byte[] address, byte[] tokenId, long value) {
     return repository.addTokenBalance(address, tokenId, value);
@@ -314,6 +319,11 @@ public DelegatedResourceAccountIndexCapsule getDelegatedResourceAccountIndex(byt
     return repository.getDelegatedResourceAccountIndex(key);
   }
 
+  @Override
+  public byte[] getTransientStorageValue(byte[] address, byte[] key) {
+    return repository.getTransientStorageValue(address, key);
+  }
+
   @Override
   public void updateDynamicProperty(byte[] word, BytesCapsule bytesCapsule) {
     repository.updateDynamicProperty(word, bytesCapsule);
@@ -354,6 +364,11 @@ public void updateDelegatedResourceAccountIndex(byte[] word, DelegatedResourceAc
     repository.updateDelegatedResourceAccountIndex(word, delegatedResourceAccountIndexCapsule);
   }
 
+  @Override
+  public void updateTransientStorageValue(byte[] address, byte[] key, byte[] value) {
+    repository.updateTransientStorageValue(address, key, value);
+  }
+
   @Override
   public void putDynamicProperty(Key key, Value value) {
     repository.putDynamicProperty(key, value);

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

@@ -181,6 +181,14 @@ public List<byte[]> getChunks() {
     return new LinkedList<>(chunks);
   }
 
+  public void copy(int destPos, int srcPos, int size) {
+    if (size <= 0) {
+      return;
+    }
+    byte[] data = read(srcPos, size);
+    write(destPos, data, size, false);
+  }
+
   private int captureMax(int chunkIndex, int chunkOffset, int size, byte[] src, int srcPos) {
 
     byte[] chunk = chunks.get(chunkIndex);

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

@@ -429,6 +429,10 @@ public byte[] memoryChunk(int offset, int size) {
     return memory.read(offset, size);
   }
 
+  public void memoryCopy(int dst, int src, int size) {
+    memory.copy(dst, src, size);
+  }
+
   /**
    * . Allocates extra memory in the program for a specified size, calculated from a given offset
    *