feat(archive): add historical state archive support

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

@@ -7,17 +7,17 @@ public enum ChainParameterEnum {
 
   INVALID_PARAMETER_KEY(0, ignored -> 0L),
 
-  TOTAL_NET_LIMIT(1, repository -> repository.getDynamicPropertiesStore().getTotalNetLimit()),
+  TOTAL_NET_LIMIT(1, repository -> repository.getVmDynamicProperties().getTotalNetLimit()),
 
   TOTAL_NET_WEIGHT(2, Repository::getTotalNetWeight),
 
   TOTAL_ENERGY_CURRENT_LIMIT(3,
-      repository -> repository.getDynamicPropertiesStore().getTotalEnergyCurrentLimit()),
+      repository -> repository.getVmDynamicProperties().getTotalEnergyCurrentLimit()),
 
   TOTAL_ENERGY_WEIGHT(4, Repository::getTotalEnergyWeight),
 
   UNFREEZE_DELAY_DAYS(5,
-      repository -> repository.getDynamicPropertiesStore().getUnfreezeDelayDays()),
+      repository -> repository.getVmDynamicProperties().getUnfreezeDelayDays()),
 
   ;
 

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

@@ -17,7 +17,11 @@ public JumpTable() {
     // fill all op slots to undefined
     Arrays.fill(table, UNDEFINED);
   }
-
+
+  public JumpTable(JumpTable source) {
+    System.arraycopy(source.table, 0, table, 0, table.length);
+  }
+
   public Operation get(int op) {
     return table[op];
   }

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

@@ -444,7 +444,7 @@ public static void gasPriceAction(Program program) {
     DataWord energyPrice = DataWord.ZERO();
     if (VMConfig.allowTvmCompatibleEvm() && program.getContractVersion() == 1) {
       energyPrice = new DataWord(program.getContractState()
-          .getDynamicPropertiesStore().getEnergyFee());
+          .getVmDynamicProperties().getEnergyFee());
     }
     program.stackPush(energyPrice);
     program.step();
@@ -549,7 +549,7 @@ public static void selfBalanceAction(Program program) {
 
   public static void baseFeeAction(Program program) {
     DataWord energyFee =
-        new DataWord(program.getContractState().getDynamicPropertiesStore().getEnergyFee());
+        new DataWord(program.getContractState().getVmDynamicProperties().getEnergyFee());
 
     program.stackPush(energyFee);
     program.step();
@@ -1046,8 +1046,8 @@ public static void exeCall(Program program, DataWord adjustedCallEnergy,
     PrecompiledContracts.PrecompiledContract contract =
         PrecompiledContracts.getContractForAddress(codeAddress);
     if (contract != null) {
-      if (program.isConstantCall()) {
-        contract =  PrecompiledContracts.getOptimizedContractForConstant(contract);
+      if (program.usesIsolatedExecutionHelpers()) {
+        contract = PrecompiledContracts.newIsolatedContract(contract);
       }
       program.callToPrecompiledAddress(msg, contract);
     } else {

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

@@ -75,8 +75,9 @@ public static JumpTable newTronV15OperationSet() {
   public static void init() {}
 
   public static JumpTable getTable() {
-    // always get the table which has the newest version
-    JumpTable table = tableMap.get(Version.TRON_V1_5);
+    // Always start from the newest immutable base table; per-call VMConfig adjustments must not
+    // mutate the shared base or a latest fork view can leak into historical replay/trace calls.
+    JumpTable table = new JumpTable(tableMap.get(Version.TRON_V1_5));
 
     // next make the corresponding changes, exclude activating opcode
     if (VMConfig.allowHigherLimitForMaxCpuTimeOfOneTx()) {

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

@@ -29,12 +29,16 @@
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
+import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.Setter;
@@ -70,6 +74,10 @@
 import org.tron.common.utils.Sha256Hash;
 import org.tron.common.zksnark.JLibrustzcash;
 import org.tron.common.zksnark.LibrustzcashParam;
+import org.tron.core.archive.query.ArchiveQueryLimits;
+import org.tron.core.archive.query.HistoricalQueryLimitException;
+import org.tron.core.archive.query.QueryContext;
+import org.tron.core.archive.query.QueryContextHolder;
 import org.tron.core.capsule.AccountCapsule;
 import org.tron.core.capsule.TransactionCapsule;
 import org.tron.core.capsule.WitnessCapsule;
@@ -212,7 +220,7 @@ public class PrecompiledContracts {
   private static final DataWord p256VerifyAddr = new DataWord(
       "0000000000000000000000000000000000000000000000000000000000000100");
 
-  public static PrecompiledContract getOptimizedContractForConstant(PrecompiledContract contract) {
+  public static PrecompiledContract newIsolatedContract(PrecompiledContract contract) {
     try {
       Constructor<?> constructor = contract.getClass().getDeclaredConstructor();
       return (PrecompiledContracts.PrecompiledContract) constructor.newInstance();
@@ -479,14 +487,18 @@ public void setResult(ProgramResult result) {
     }
 
     protected long getCPUTimeLeftInNanoSecond() {
-      long left = getVmShouldEndInUs() * VMConstant.ONE_THOUSAND - System.nanoTime();
+      long left = getCPUTimeRemainingInNanoSecond(System.nanoTime());
       if (left <= 0) {
         throw Program.Exception.notEnoughTime("call");
       } else {
         return left;
       }
     }
 
+    protected long getCPUTimeRemainingInNanoSecond(long sampledNanos) {
+      return getVmShouldEndInUs() * VMConstant.ONE_THOUSAND - sampledNanos;
+    }
+
     protected byte[] dataOne() {
       byte[] ret = new byte[WORD_SIZE];
       ret[31] = 1;
@@ -1446,13 +1458,21 @@ public Pair<Boolean, byte[]> execute(byte[] data) {
   public static class VerifyTransferProof extends VerifyProof {
 
     private static final Integer[] SIZE = {2080, 2368, 2464, 2752};
+    private static final int HISTORICAL_QUEUE_CAPACITY = 64;
     private static final ExecutorService workersInConstantCall;
+    private static final ThreadPoolExecutor workersInHistoricalConstantCall;
     private static final ExecutorService workersInNonConstantCall;
     private static final String constantCallName = "verify-transfer-constant-call";
+    private static final String historicalConstantCallName =
+        "verify-transfer-historical-constant-call";
     private static final String nonConstantCallName = "verify-transfer-non-constant-call";
 
     static {
       workersInConstantCall = ExecutorServiceManager.newFixedThreadPool(constantCallName, 5);
+      workersInHistoricalConstantCall = (ThreadPoolExecutor)
+          ExecutorServiceManager.newThreadPoolExecutor(
+              5, 5, 0L, TimeUnit.MILLISECONDS,
+              new ArrayBlockingQueue<>(HISTORICAL_QUEUE_CAPACITY), historicalConstantCallName);
       workersInNonConstantCall = ExecutorServiceManager.newFixedThreadPool(nonConstantCallName, 5);
     }
 
@@ -1463,6 +1483,8 @@ public long getEnergyForData(byte[] data) {
 
     @Override
     public Pair<Boolean, byte[]> execute(byte[] data) {
+      boolean historicalCall = isHistoricalArchiveCall();
+      List<Future<Boolean>> futures = new ArrayList<>(5);
       if (data == null) {
         return Pair.of(true, DataWord.ZERO().getData());
       }
@@ -1558,9 +1580,10 @@ public Pair<Boolean, byte[]> execute(byte[] data) {
 
         int threadCount = spendCount + receiveCount + 1;
         CountDownLatch countDownLatch = new CountDownLatch(threadCount);
-        List<Future<Boolean>> futures = new ArrayList<>(threadCount);
         ExecutorService workers;
-        if (isConstantCall()) {
+        if (historicalCall) {
+          workers = workersInHistoricalConstantCall;
+        } else if (isConstantCall()) {
           workers = workersInConstantCall;
         } else {
           workers = workersInNonConstantCall;
@@ -1586,31 +1609,176 @@ public Pair<Boolean, byte[]> execute(byte[] data) {
                 signHash, spendCvs, spendCount * 32, receiveCvs, receiveCount * 32));
         futures.add(futureCheckBindingSig);
 
-        boolean withNoTimeout = countDownLatch.await(getCPUTimeLeftInNanoSecond(),
-            TimeUnit.NANOSECONDS);
-        boolean checkResult = true;
-        for (Future<Boolean> future : futures) {
-          boolean eachTaskResult = future.get();
-          checkResult = checkResult && eachTaskResult;
-        }
+        boolean checkResult = historicalCall
+            ? awaitHistoricalProofTasks(countDownLatch, futures)
+            : awaitLegacyProofTasks(countDownLatch, futures);
         if (checkResult) {
           return insertLeaves(frontier, leafCount, receiveCm);
         } else {
           return Pair.of(true, DataWord.ZERO().getData());
         }
       } catch (InterruptedException e) {
         Thread.currentThread().interrupt();
+        rethrowHistoricalInterrupt(historicalCall, e);
         logger.info("VerifyTransferProof exception: " + e.getMessage());
       } catch (Throwable any) {
+        rethrowHistoricalHardFailure(historicalCall, any);
         String errorMsg = any.getMessage();
         if (errorMsg == null && any.getCause() != null) {
           errorMsg = any.getCause().getMessage();
         }
         logger.info("VerifyTransferProof exception: " + errorMsg);
+      } finally {
+        if (historicalCall) {
+          cancelUnfinished(futures);
+        }
       }
       return Pair.of(true, DataWord.ZERO().getData());
     }
 
+    protected boolean awaitHistoricalProofTasks(
+        CountDownLatch countDownLatch, List<Future<Boolean>> futures)
+        throws InterruptedException, ExecutionException {
+      HistoricalWaitBudget latchBudget = getHistoricalWaitBudget();
+      if (!countDownLatch.await(latchBudget.remainingNanos, TimeUnit.NANOSECONDS)) {
+        throw historicalProofTimeout(null, latchBudget.archiveDeadlineLimited);
+      }
+      boolean result = true;
+      for (Future<Boolean> future : futures) {
+        HistoricalWaitBudget futureBudget = getHistoricalWaitBudget();
+        try {
+          result = future.get(futureBudget.remainingNanos, TimeUnit.NANOSECONDS) && result;
+        } catch (TimeoutException e) {
+          throw historicalProofTimeout(e, futureBudget.archiveDeadlineLimited);
+        }
+      }
+      return result;
+    }
+
+    private HistoricalWaitBudget getHistoricalWaitBudget() {
+      QueryContext queryContext = QueryContextHolder.current();
+      if (queryContext == null) {
+        return new HistoricalWaitBudget(getCPUTimeLeftInNanoSecond(), false);
+      }
+      QueryContext.DeadlineSnapshot archiveDeadline = queryContext.sampleDeadline();
+      long archiveRemainingNanos = archiveDeadline.getRemainingNanos();
+      long vmRemainingNanos = getCPUTimeRemainingInNanoSecond(
+          archiveDeadline.getSampledNanos());
+      boolean archiveDeadlineLimited = archiveRemainingNanos <= vmRemainingNanos;
+      long remainingNanos = archiveDeadlineLimited ? archiveRemainingNanos : vmRemainingNanos;
+      if (remainingNanos <= 0L) {
+        if (archiveDeadlineLimited) {
+          queryContext.checkDeadline();
+        }
+        throw Program.Exception.notEnoughTime("call VerifyTransferProof precompile method");
+      }
+      return new HistoricalWaitBudget(remainingNanos, archiveDeadlineLimited);
+    }
+
+    static OutOfTimeException historicalProofTimeout(
+        Throwable cause, boolean archiveDeadlineLimited) {
+      if (archiveDeadlineLimited) {
+        QueryContext queryContext = QueryContextHolder.current();
+        if (queryContext != null) {
+          // Re-check only when this deadline supplied the wait duration. A later-expiring archive
+          // deadline must not retroactively replace an earlier VM timeout.
+          queryContext.checkDeadline();
+        }
+      }
+      OutOfTimeException timeout =
+          Program.Exception.notEnoughTime("call VerifyTransferProof precompile method");
+      if (cause != null) {
+        try {
+          timeout.addSuppressed(cause);
+        } catch (Throwable ignored) {
+          // Preserve the VM timeout if suppression cannot allocate.
+        }
+      }
+      return timeout;
+    }
+
+    private static final class HistoricalWaitBudget {
+
+      private final long remainingNanos;
+      private final boolean archiveDeadlineLimited;
+
+      private HistoricalWaitBudget(long remainingNanos, boolean archiveDeadlineLimited) {
+        this.remainingNanos = remainingNanos;
+        this.archiveDeadlineLimited = archiveDeadlineLimited;
+      }
+    }
+
+    private boolean awaitLegacyProofTasks(
+        CountDownLatch countDownLatch, List<Future<Boolean>> futures)
+        throws InterruptedException, ExecutionException {
+      countDownLatch.await(getCPUTimeLeftInNanoSecond(), TimeUnit.NANOSECONDS);
+      boolean result = true;
+      for (Future<Boolean> future : futures) {
+        result = future.get() && result;
+      }
+      return result;
+    }
+
+    protected static void cancelUnfinished(List<Future<Boolean>> futures) {
+      for (Future<Boolean> future : futures) {
+        try {
+          if (!future.isDone()) {
+            future.cancel(true);
+          }
+          if (future instanceof Runnable) {
+            workersInHistoricalConstantCall.remove((Runnable) future);
+          }
+        } catch (RuntimeException ignored) {
+          // Cancellation is best-effort; preserve the historical call's primary result/failure.
+        }
+      }
+    }
+
+    private boolean isHistoricalArchiveCall() {
+      Repository repository = getDeposit();
+      return isConstantCall() && repository != null && repository.isHistoricalArchive();
+    }
+
+    static void rethrowHistoricalHardFailure(boolean historicalCall, Throwable failure) {
+      if (!historicalCall) {
+        return;
+      }
+      Throwable terminal = failure instanceof ExecutionException && failure.getCause() != null
+          ? failure.getCause() : failure;
+      if (terminal instanceof HistoricalQueryLimitException) {
+        throw (HistoricalQueryLimitException) terminal;
+      }
+      if (terminal instanceof Error) {
+        throw (Error) terminal;
+      }
+      if (terminal instanceof OutOfTimeException) {
+        throw (OutOfTimeException) terminal;
+      }
+      if (terminal instanceof RejectedExecutionException) {
+        throw new HistoricalQueryLimitException(
+            HistoricalQueryLimitException.Reason.RESOURCE_EXHAUSTED,
+            HistoricalQueryLimitException.Limit.QUERY_ADMISSION,
+            ArchiveQueryLimits.UNLIMITED,
+            ArchiveQueryLimits.UNLIMITED,
+            "historical proof worker capacity exhausted",
+            terminal);
+      }
+    }
+
+    static void rethrowHistoricalInterrupt(
+        boolean historicalCall, InterruptedException failure) {
+      if (!historicalCall) {
+        return;
+      }
+      throw new HistoricalQueryLimitException(
+          HistoricalQueryLimitException.Reason.RESOURCE_EXHAUSTED,
+          HistoricalQueryLimitException.Limit.INTERRUPTED,
+          ArchiveQueryLimits.UNLIMITED,
+          ArchiveQueryLimits.UNLIMITED,
+          "historical proof wait interrupted",
+          failure);
+    }
+
     private static class SaplingCheckSpendTask implements Callable<Boolean> {
 
       private byte[] cv;
@@ -1962,8 +2130,8 @@ public Pair<Boolean, byte[]> execute(byte[] data) {
       if (accountCapsule == null) {
         tronPower = 0;
       } else {
-        if (getDeposit().getDynamicPropertiesStore().supportUnfreezeDelay()
-            && getDeposit().getDynamicPropertiesStore().supportAllowNewResourceModel()) {
+        if (getDeposit().getVmDynamicProperties().supportUnfreezeDelay()
+            && getDeposit().getVmDynamicProperties().supportAllowNewResourceModel()) {
           tronPower = accountCapsule.getAllTronPower();
         } else {
           tronPower = accountCapsule.getTronPower();