docs(archive): review state archive performance work

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

@@ -13,6 +13,7 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
+import java.util.function.LongSupplier;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
@@ -54,8 +55,10 @@
 import org.tron.core.vm.program.ProgramPrecompile;
 import org.tron.core.vm.program.invoke.ProgramInvoke;
 import org.tron.core.vm.program.invoke.ProgramInvokeFactory;
+import org.tron.core.vm.repository.CurrentRepositoryProvider;
 import org.tron.core.vm.repository.Repository;
 import org.tron.core.vm.repository.RepositoryImpl;
+import org.tron.core.vm.repository.RepositoryProvider;
 import org.tron.core.vm.utils.MUtil;
 import org.tron.protos.Protocol;
 import org.tron.protos.Protocol.Block;
@@ -97,8 +100,15 @@ public class VMActuator implements Actuator2 {
 
   private LogInfoTriggerParser logInfoTriggerParser;
 
+  private final RepositoryProvider repositoryProvider;
+
   public VMActuator(boolean isConstantCall) {
+    this(isConstantCall, CurrentRepositoryProvider.INSTANCE);
+  }
+
+  public VMActuator(boolean isConstantCall, RepositoryProvider repositoryProvider) {
     this.isConstantCall = isConstantCall;
+    this.repositoryProvider = Objects.requireNonNull(repositoryProvider, "repositoryProvider");
     this.maxEnergyLimit = CommonParameter.getInstance().maxEnergyLimitForConstant;
   }
 
@@ -111,6 +121,11 @@ private static long getEnergyFee(long callerEnergyUsage, long callerEnergyFrozen
         .divide(BigInteger.valueOf(callerEnergyTotal)).longValueExact();
   }
 
+  private long dynamicLong(String key, LongSupplier currentValue) {
+    return rootRepository.isHistorical()
+        ? ConfigLoader.property(rootRepository, key) : currentValue.getAsLong();
+  }
+
   @Override
   public void validate(Object object) throws ContractValidateException {
 
@@ -119,16 +134,24 @@ public void validate(Object object) throws ContractValidateException {
       throw new RuntimeException("TransactionContext is null");
     }
 
-    // Load Config
-    ConfigLoader.load(context.getStoreFactory(), isConstantCall);
+    rootRepository = Objects.requireNonNull(repositoryProvider.createRoot(context),
+        "repositoryProvider returned null");
+    if (rootRepository.isHistorical()) {
+      if (!isConstantCall) {
+        throw new ContractValidateException("Historical execution must be a constant call");
+      }
+      ConfigLoader.load(rootRepository);
+    } else {
+      ConfigLoader.load(context.getStoreFactory(), isConstantCall);
+    }
     // Warm up registry class
     OperationRegistry.init();
     trx = context.getTrxCap().getInstance();
     // If tx`s fee limit is set, use it to calc max energy limit for constant call
     if (isConstantCall && trx.getRawData().getFeeLimit() > 0) {
       maxEnergyLimit = min(maxEnergyLimit, trx.getRawData().getFeeLimit()
-          / context.getStoreFactory().getChainBaseManager()
-          .getDynamicPropertiesStore().getEnergyFee(), VMConfig.disableJavaLangMath());
+          / dynamicLong("ENERGY_FEE", () -> context.getStoreFactory().getChainBaseManager()
+          .getDynamicPropertiesStore().getEnergyFee()), VMConfig.disableJavaLangMath());
     }
     blockCap = context.getBlockCap();
     if ((VMConfig.allowTvmFreeze() || VMConfig.allowTvmFreezeV2())
@@ -137,8 +160,10 @@ public void validate(Object object) throws ContractValidateException {
     }
     //Route Type
     ContractType contractType = this.trx.getRawData().getContract(0).getType();
-    //Prepare Repository
-    rootRepository = RepositoryImpl.createRoot(context.getStoreFactory());
+    if (rootRepository.isHistorical() && contractType != ContractType.TriggerSmartContract) {
+      throw new ContractValidateException(
+          "Historical execution only supports TriggerSmartContract");
+    }
 
     enableEventListener = context.isEventPluginLoaded();
 
@@ -462,7 +487,8 @@ private void create()
   private void call()
       throws ContractValidateException {
 
-    if (!rootRepository.getDynamicPropertiesStore().supportVM()) {
+    if (dynamicLong("ALLOW_CREATION_OF_CONTRACTS",
+        () -> rootRepository.getDynamicPropertiesStore().getAllowCreationOfContracts()) != 1L) {
       logger.info("vm work is off, need to be opened by the committee");
       throw new ContractValidateException("VM work is off, need to be opened by the committee");
     }
@@ -507,10 +533,12 @@ private void call()
     byte[] code = rootRepository.getCode(contractAddress);
     if (isNotEmpty(code)) {
       long feeLimit = trx.getRawData().getFeeLimit();
-      if (feeLimit < 0 || feeLimit > rootRepository.getDynamicPropertiesStore().getMaxFeeLimit()) {
+      long maxFeeLimit = dynamicLong("MAX_FEE_LIMIT",
+          () -> rootRepository.getDynamicPropertiesStore().getMaxFeeLimit());
+      if (feeLimit < 0 || feeLimit > maxFeeLimit) {
         logger.info("invalid feeLimit {}", feeLimit);
         throw new ContractValidateException("feeLimit must be >= 0 and <= "
-            + rootRepository.getDynamicPropertiesStore().getMaxFeeLimit());
+            + maxFeeLimit);
       }
       AccountCapsule caller = rootRepository.getAccount(callerAddress);
       long energyLimit;
@@ -523,7 +551,8 @@ private void call()
       }
 
       long thisTxCPULimitInUs = calculateCpuLimitInUs(isConstantCall,
-          rootRepository.getDynamicPropertiesStore().getMaxCpuTimeOfOneTx(),
+          dynamicLong("MAX_CPU_TIME_OF_ONE_TX",
+              () -> rootRepository.getDynamicPropertiesStore().getMaxCpuTimeOfOneTx()),
           getCpuLimitInUsRatio(), CommonParameter.getInstance().getConstantCallTimeoutMs());
       long vmStartInUs = System.nanoTime() / VMConstant.ONE_THOUSAND;
       long vmShouldEndInUs = vmStartInUs + thisTxCPULimitInUs;

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

@@ -0,0 +1,9 @@
+package org.tron.core.vm;
+
+/** Fail-closed rejection for a state capability unavailable to historical execution. */
+public class HistoricalCapabilityException extends RuntimeException {
+
+  public HistoricalCapabilityException(String message) {
+    super(message);
+  }
+}

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

@@ -0,0 +1,28 @@
+package org.tron.core.vm;
+
+/** Runtime allowlist for capabilities reachable only after bytecode dispatch. */
+public final class HistoricalExecutionGuard {
+
+  private HistoricalExecutionGuard() {
+  }
+
+  public static void requirePrecompileAllowed(
+      PrecompiledContracts.PrecompiledContract contract) {
+    if (contract instanceof PrecompiledContracts.Identity
+        || contract instanceof PrecompiledContracts.Sha256
+        || contract instanceof PrecompiledContracts.Ripempd160
+        || contract instanceof PrecompiledContracts.ECRecover
+        || contract instanceof PrecompiledContracts.ModExp
+        || contract instanceof PrecompiledContracts.BN128Addition
+        || contract instanceof PrecompiledContracts.BN128Multiplication
+        || contract instanceof PrecompiledContracts.BN128Pairing
+        || contract instanceof PrecompiledContracts.EthRipemd160
+        || contract instanceof PrecompiledContracts.Blake2F
+        || contract instanceof PrecompiledContracts.P256Verify) {
+      return;
+    }
+    throw new HistoricalCapabilityException(
+        "Precompile is not allowed by historical execution: "
+            + contract.getClass().getSimpleName());
+  }
+}

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

@@ -1070,6 +1070,10 @@ public static void revertAction(Program program) {
   }
 
   public static void suicideAction(Program program) {
+    if (program.getContractState().isHistorical()) {
+      throw new HistoricalCapabilityException(
+          "SELFDESTRUCT is not supported by historical execution");
+    }
     if (program.isStaticCall()) {
       throw new Program.StaticCallModificationException();
     }
@@ -1085,6 +1089,10 @@ public static void suicideAction(Program program) {
   }
 
   public static void suicideAction2(Program program) {
+    if (program.getContractState().isHistorical()) {
+      throw new HistoricalCapabilityException(
+          "SELFDESTRUCT is not supported by historical execution");
+    }
     if (program.isStaticCall()) {
       throw new Program.StaticCallModificationException();
     }

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

@@ -24,13 +24,17 @@ public static void play(Program program, JumpTable jumpTable) {
       long factor = DYNAMIC_ENERGY_FACTOR_DECIMAL;
       long energyUsage = 0L;
       // hoist once per execution: avoids a per-opcode VMConfig.current() thread-local lookup
+      final boolean historical = program.getContractState().isHistorical();
       final boolean allowDynamicEnergy = VMConfig.allowDynamicEnergy();
 
       if (allowDynamicEnergy) {
         factor = program.updateContextContractFactor();
       }
 
       while (!program.isStopped()) {
+        if (historical) {
+          program.getContractState().checkHistoricalQueryActive();
+        }
         if (VMConfig.vmTrace()) {
           program.saveOpTrace();
         }
@@ -88,6 +92,9 @@ public static void play(Program program, JumpTable jumpTable) {
 
           /* exec op action */
           op.execute(program);
+          if (historical) {
+            program.getContractState().checkHistoricalQueryActive();
+          }
 
           program.setPreviouslyExecutedOp((byte) op.getOpcode());
         } catch (RuntimeException e) {

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

@@ -1,11 +1,11 @@
 package org.tron.core.vm.config;
 
-import static org.tron.core.capsule.ReceiptCapsule.checkForEnergyLimit;
-
 import lombok.extern.slf4j.Slf4j;
 import org.tron.common.parameter.CommonParameter;
 import org.tron.core.store.DynamicPropertiesStore;
 import org.tron.core.store.StoreFactory;
+import org.tron.core.vm.HistoricalCapabilityException;
+import org.tron.core.vm.repository.Repository;
 
 @Slf4j(topic = "VMConfigLoader")
 public class ConfigLoader {
@@ -21,8 +21,9 @@ public static void load(StoreFactory storeFactory, boolean isolate) {
       DynamicPropertiesStore ds = storeFactory.getChainBaseManager().getDynamicPropertiesStore();
       VMConfig.setVmTrace(CommonParameter.getInstance().isVmTrace());
       if (ds != null) {
-        VMConfig.initVmHardFork(checkForEnergyLimit(ds));
         VMConfig.Snapshot snapshot = new VMConfig.Snapshot();
+        snapshot.energyLimitHardFork = ds.getLatestBlockHeaderNumber()
+            >= CommonParameter.getInstance().getBlockNumForEnergyLimit();
         snapshot.allowMultiSign = ds.getAllowMultiSign() == 1;
         snapshot.allowTvmTransferTrc10 = ds.getAllowTvmTransferTrc10() == 1;
         snapshot.allowTvmConstantinople = ds.getAllowTvmConstantinople() == 1;
@@ -53,9 +54,62 @@ public static void load(StoreFactory storeFactory, boolean isolate) {
         if (isolate) {
           VMConfig.setLocalSnapshot(snapshot);
         } else {
+          VMConfig.initVmHardFork(snapshot.energyLimitHardFork);
           VMConfig.setGlobalSnapshot(snapshot);
         }
       }
     }
   }
+
+  /** Loads an isolated VM view exclusively from a Repository's request-owned state source. */
+  public static void load(Repository repository) {
+    if (disable) {
+      throw new HistoricalCapabilityException(
+          "Historical VM config loading cannot be disabled");
+    }
+    VMConfig.setVmTrace(CommonParameter.getInstance().isVmTrace());
+    VMConfig.Snapshot snapshot = new VMConfig.Snapshot();
+    snapshot.energyLimitHardFork = property(repository, "latest_block_header_number")
+        >= CommonParameter.getInstance().getBlockNumForEnergyLimit();
+    snapshot.allowMultiSign = enabled(repository, "ALLOW_MULTI_SIGN");
+    snapshot.allowTvmTransferTrc10 = enabled(repository, "ALLOW_TVM_TRANSFER_TRC10");
+    snapshot.allowTvmConstantinople = enabled(repository, "ALLOW_TVM_CONSTANTINOPLE");
+    snapshot.allowTvmSolidity059 = enabled(repository, "ALLOW_TVM_SOLIDITY_059");
+    snapshot.allowShieldedTRC20Transaction =
+        enabled(repository, "ALLOW_SHIELDED_TRC20_TRANSACTION");
+    snapshot.allowTvmIstanbul = enabled(repository, "ALLOW_TVM_ISTANBUL");
+    snapshot.allowTvmFreeze = enabled(repository, "ALLOW_TVM_FREEZE");
+    snapshot.allowTvmVote = enabled(repository, "ALLOW_TVM_VOTE");
+    snapshot.allowTvmLondon = enabled(repository, "ALLOW_TVM_LONDON");
+    snapshot.allowTvmCompatibleEvm = enabled(repository, "ALLOW_TVM_COMPATIBLE_EVM");
+    snapshot.allowHigherLimitForMaxCpuTimeOfOneTx =
+        enabled(repository, "ALLOW_HIGHER_LIMIT_FOR_MAX_CPU_TIME_OF_ONE_TX");
+    snapshot.allowTvmFreezeV2 = property(repository, "UNFREEZE_DELAY_DAYS") > 0;
+    snapshot.allowOptimizedReturnValueOfChainId =
+        enabled(repository, "ALLOW_OPTIMIZED_RETURN_VALUE_OF_CHAIN_ID");
+    snapshot.allowDynamicEnergy = enabled(repository, "ALLOW_DYNAMIC_ENERGY");
+    snapshot.dynamicEnergyThreshold = property(repository, "DYNAMIC_ENERGY_THRESHOLD");
+    snapshot.dynamicEnergyIncreaseFactor = property(repository, "DYNAMIC_ENERGY_INCREASE_FACTOR");
+    snapshot.dynamicEnergyMaxFactor = property(repository, "DYNAMIC_ENERGY_MAX_FACTOR");
+    snapshot.allowTvmShanghai = enabled(repository, "ALLOW_TVM_SHANGHAI");
+    snapshot.allowEnergyAdjustment = enabled(repository, "ALLOW_ENERGY_ADJUSTMENT");
+    snapshot.allowStrictMath = enabled(repository, "ALLOW_STRICT_MATH");
+    snapshot.allowTvmCancun = enabled(repository, "ALLOW_TVM_CANCUN");
+    snapshot.disableJavaLangMath = enabled(repository, "CONSENSUS_LOGIC_OPTIMIZATION");
+    snapshot.allowTvmBlob = enabled(repository, "ALLOW_TVM_BLOB");
+    snapshot.allowTvmSelfdestructRestriction =
+        enabled(repository, "ALLOW_TVM_SELFDESTRUCT_RESTRICTION");
+    snapshot.allowTvmOsaka = enabled(repository, "ALLOW_TVM_OSAKA");
+    snapshot.allowHardenResourceCalculation =
+        enabled(repository, "ALLOW_HARDEN_RESOURCE_CALCULATION");
+    VMConfig.setLocalSnapshot(snapshot);
+  }
+
+  public static long property(Repository repository, String key) {
+    return repository.getDynamicPropertyLong(key);
+  }
+
+  private static boolean enabled(Repository repository, String key) {
+    return property(repository, key) == 1L;
+  }
 }

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

@@ -41,6 +41,16 @@ public void setProgramListener(ProgramListener listener) {
     this.programListener = listener;
   }
 
+  @Override
+  public void checkHistoricalQueryActive() {
+    repository.checkHistoricalQueryActive();
+  }
+
+  @Override
+  public boolean isHistorical() {
+    return repository.isHistorical();
+  }
+
   @Override
   public AssetIssueCapsule getAssetIssue(byte[] tokenId) {
     return repository.getAssetIssue(tokenId);

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

@@ -58,6 +58,8 @@
 import org.tron.core.exception.TronException;
 import org.tron.core.utils.TransactionUtil;
 import org.tron.core.vm.EnergyCost;
+import org.tron.core.vm.HistoricalCapabilityException;
+import org.tron.core.vm.HistoricalExecutionGuard;
 import org.tron.core.vm.MessageCall;
 import org.tron.core.vm.Op;
 import org.tron.core.vm.OperationRegistry;
@@ -811,6 +813,10 @@ public void createContract(DataWord value, DataWord memStart, DataWord memSize)
 
   private void createContractImpl(DataWord value, byte[] programCode, byte[] newAddress,
       boolean isCreate2) {
+    if (getContractState().isHistorical()) {
+      throw new HistoricalCapabilityException(
+          "CREATE and CREATE2 are not supported by historical execution");
+    }
     byte[] senderAddress = getContextAddress();
 
     if (logger.isDebugEnabled()) {
@@ -1660,6 +1666,10 @@ public void callToPrecompiledAddress(MessageCall msg,
       PrecompiledContracts.PrecompiledContract contract) {
     returnDataBuffer = null; // reset return buffer right before the call
 
+    if (getContractState().isHistorical()) {
+      HistoricalExecutionGuard.requirePrecompileAllowed(contract);
+    }
+
     if (getCallDeep() == MAX_DEPTH) {
       stackPushZero();
       this.refundEnergy(msg.getEnergy().longValue(), " call deep limit reach");
@@ -2363,11 +2373,11 @@ public long updateContextContractFactor() {
 
     if (contractStateCapsule == null) {
       contractStateCapsule = new ContractStateCapsule(
-          contractState.getDynamicPropertiesStore().getCurrentCycleNumber());
+          contractState.getDynamicPropertyLong("CURRENT_CYCLE_NUMBER"));
       contractState.updateContractState(getContextAddress(), contractStateCapsule);
     } else {
       if (contractStateCapsule.catchUpToCycle(
-          contractState.getDynamicPropertiesStore().getCurrentCycleNumber(),
+          contractState.getDynamicPropertyLong("CURRENT_CYCLE_NUMBER"),
           VMConfig.getDynamicEnergyThreshold(),
           VMConfig.getDynamicEnergyIncreaseFactor(),
           VMConfig.getDynamicEnergyMaxFactor(),