feat(vm): add node-level vm.constantCallTimeoutMs for constant calls

yanghang8612 · yanghang8612 · commit c8ccd9f826eb · 2026-04-28T18:50:40.000+08:00
New config knob extends the TVM execution window for triggerconstantcontract / eth_call only; pairs with a concurrency cap that engages when the configured timeout exceeds the network's current maxCpuTimeOfOneTx. Issue #6681.
diff --git a/actuator/src/main/java/org/tron/core/actuator/VMActuator.java b/actuator/src/main/java/org/tron/core/actuator/VMActuator.java
@@ -45,6 +45,7 @@
 import org.tron.core.vm.VM;
 import org.tron.core.vm.VMConstant;
 import org.tron.core.vm.VMUtils;
+import org.tron.core.vm.VmTimeoutPolicy;
 import org.tron.core.vm.config.ConfigLoader;
 import org.tron.core.vm.config.VMConfig;
 import org.tron.core.vm.program.Program;
@@ -398,11 +399,11 @@ private void create()
       byte[] ops = newSmartContract.getBytecode().toByteArray();
       rootInternalTx = new InternalTransaction(trx, trxType);
 
-      long maxCpuTimeOfOneTx = rootRepository.getDynamicPropertiesStore()
-          .getMaxCpuTimeOfOneTx() * VMConstant.ONE_THOUSAND;
-      long thisTxCPULimitInUs = (long) (maxCpuTimeOfOneTx * getCpuLimitInUsRatio());
+      long maxCpuTimeOfOneTxMs = rootRepository.getDynamicPropertiesStore().getMaxCpuTimeOfOneTx();
       long vmStartInUs = System.nanoTime() / VMConstant.ONE_THOUSAND;
-      long vmShouldEndInUs = vmStartInUs + thisTxCPULimitInUs;
+      long vmShouldEndInUs = VmTimeoutPolicy.computeVmShouldEndInUs(
+          isConstantCall, vmStartInUs, maxCpuTimeOfOneTxMs, getCpuLimitInUsRatio(),
+          CommonParameter.getInstance().getConstantCallTimeoutMs());
       ProgramInvoke programInvoke = ProgramInvokeFactory
           .createProgramInvoke(TrxType.TRX_CONTRACT_CREATION_TYPE, executorType, trx,
               tokenValue, tokenId, blockCap.getInstance(), rootRepository, vmStartInUs,
@@ -512,12 +513,11 @@ private void call()
         energyLimit = getTotalEnergyLimit(creator, caller, contract, feeLimit, callValue);
       }
 
-      long maxCpuTimeOfOneTx = rootRepository.getDynamicPropertiesStore()
-          .getMaxCpuTimeOfOneTx() * VMConstant.ONE_THOUSAND;
-      long thisTxCPULimitInUs =
-          (long) (maxCpuTimeOfOneTx * getCpuLimitInUsRatio());
+      long maxCpuTimeOfOneTxMs = rootRepository.getDynamicPropertiesStore().getMaxCpuTimeOfOneTx();
       long vmStartInUs = System.nanoTime() / VMConstant.ONE_THOUSAND;
-      long vmShouldEndInUs = vmStartInUs + thisTxCPULimitInUs;
+      long vmShouldEndInUs = VmTimeoutPolicy.computeVmShouldEndInUs(
+          isConstantCall, vmStartInUs, maxCpuTimeOfOneTxMs, getCpuLimitInUsRatio(),
+          CommonParameter.getInstance().getConstantCallTimeoutMs());
       ProgramInvoke programInvoke = ProgramInvokeFactory
           .createProgramInvoke(TrxType.TRX_CONTRACT_CALL_TYPE, executorType, trx,
               tokenValue, tokenId, blockCap.getInstance(), rootRepository, vmStartInUs,
diff --git a/common/src/main/java/org/tron/common/parameter/CommonParameter.java b/common/src/main/java/org/tron/common/parameter/CommonParameter.java
@@ -58,6 +58,23 @@ public class CommonParameter {
   @Getter
   @Setter
   public double maxTimeRatio = calcMaxTimeRatio();
+  /**
+   * Max TVM execution time (ms) for constant calls. 0 = use the same
+   * deadline as block processing (current behaviour). Otherwise must be
+   * within [CONSTANT_CALL_TIMEOUT_MIN_MS, CONSTANT_CALL_TIMEOUT_MAX_MS];
+   * range is enforced at config-load in Args.
+   */
+  @Getter
+  @Setter
+  public long constantCallTimeoutMs = 0L;
+  /**
+   * Max concurrent constant-call executions. Cap is engaged only when
+   * constantCallTimeoutMs exceeds the baseline default; nodes leaving the
+   * timeout at its default see no behaviour change.
+   */
+  @Getter
+  @Setter
+  public int constantCallMaxConcurrency = 10;
   @Getter
   @Setter
   public boolean saveInternalTx;
diff --git a/common/src/main/java/org/tron/core/config/args/VmConfig.java b/common/src/main/java/org/tron/core/config/args/VmConfig.java
@@ -5,6 +5,7 @@
 import lombok.Getter;
 import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
+import org.tron.core.vm.VmTimeoutPolicy;
 
 /**
  * VM configuration bean. Field names match config.conf keys under the "vm" section.
@@ -27,6 +28,8 @@ public class VmConfig {
   private boolean saveInternalTx = false;
   private boolean saveFeaturedInternalTx = false;
   private boolean saveCancelAllUnfreezeV2Details = false;
+  private long constantCallTimeoutMs = 0L;
+  private int constantCallMaxConcurrency = 10;
 
   /**
    * Create VmConfig from the "vm" section of the application config.
@@ -60,5 +63,22 @@ private void postProcess() {
       logger.warn("Configuring [vm.saveCancelAllUnfreezeV2Details] won't work as "
           + "vm.saveInternalTx or vm.saveFeaturedInternalTx is off.");
     }
+
+    // constantCallTimeoutMs: 0 (sentinel = use existing path) or
+    // [MIN_MS, MAX_MS]. Issue #6681.
+    if (constantCallTimeoutMs != VmTimeoutPolicy.CONSTANT_CALL_TIMEOUT_UNSET
+        && (constantCallTimeoutMs < VmTimeoutPolicy.CONSTANT_CALL_TIMEOUT_MIN_MS
+            || constantCallTimeoutMs > VmTimeoutPolicy.CONSTANT_CALL_TIMEOUT_MAX_MS)) {
+      throw new IllegalArgumentException(
+          "vm.constantCallTimeoutMs must be 0 or within ["
+              + VmTimeoutPolicy.CONSTANT_CALL_TIMEOUT_MIN_MS + ", "
+              + VmTimeoutPolicy.CONSTANT_CALL_TIMEOUT_MAX_MS + "], got "
+              + constantCallTimeoutMs);
+    }
+    if (constantCallMaxConcurrency <= 0) {
+      throw new IllegalArgumentException(
+          "vm.constantCallMaxConcurrency must be > 0, got "
+              + constantCallMaxConcurrency);
+    }
   }
 }
diff --git a/common/src/main/java/org/tron/core/vm/VmTimeoutPolicy.java b/common/src/main/java/org/tron/core/vm/VmTimeoutPolicy.java
@@ -0,0 +1,77 @@
+package org.tron.core.vm;
+
+import org.tron.common.math.StrictMathWrapper;
+
+/**
+ * Constants and helpers governing the TVM execution-time deadline for constant
+ * calls (triggerconstantcontract / eth_call). Lives in the {@code common}
+ * module so that both {@code VmConfig} (config-time validation) and
+ * {@code VMActuator} (runtime deadline computation) can reference the same
+ * policy values without creating a circular dependency.
+ *
+ * <p>See issue #6681.
+ */
+public final class VmTimeoutPolicy {
+
+  private VmTimeoutPolicy() {
+  }
+
+  /** Sentinel: 0 means "use existing maxCpuTimeOfOneTx * ratio path". */
+  public static final long CONSTANT_CALL_TIMEOUT_UNSET = 0L;
+
+  /**
+   * Sanity floor for {@code vm.constantCallTimeoutMs}, enforced at config-load
+   * in {@code VmConfig.postProcess()}. Below this value the operator has
+   * almost certainly mistyped — the actual cap-engagement comparison is
+   * runtime against the network's {@code maxCpuTimeOfOneTx}.
+   */
+  public static final long CONSTANT_CALL_TIMEOUT_MIN_MS = 80L;
+
+  /** Hard upper bound, enforced at config-load. */
+  public static final long CONSTANT_CALL_TIMEOUT_MAX_MS = 500L;
+
+  /** Concurrency cap default; engages only when timeout is raised. */
+  public static final int CONSTANT_CALL_MAX_CONCURRENCY_DEFAULT = 10;
+
+  /**
+   * Compute the absolute deadline (in microseconds since system start) for
+   * a TVM execution. Block processing always uses
+   * {@code maxCpuTimeOfOneTxMs * 1000 * cpuLimitRatio}. Constant calls may
+   * opt into a longer window via {@code vm.constantCallTimeoutMs}; when that
+   * value is unset, constant calls fall back to the same path as block
+   * processing.
+   *
+   * <p>Centralised here so the block-processing and constant-call branches
+   * cannot drift; see issue #6681.
+   */
+  public static long computeVmShouldEndInUs(boolean isConstantCall,
+                                            long vmStartInUs,
+                                            long maxCpuTimeOfOneTxMs,
+                                            double cpuLimitRatio,
+                                            long configuredConstantCallTimeoutMs) {
+    long budgetUs;
+    if (isConstantCall
+        && configuredConstantCallTimeoutMs != CONSTANT_CALL_TIMEOUT_UNSET) {
+      // Operators can only EXTEND the constant-call window, never shrink it
+      // below the network's current maxCpuTimeOfOneTx. Issue #6681.
+      long effectiveMs =
+          StrictMathWrapper.max(configuredConstantCallTimeoutMs, maxCpuTimeOfOneTxMs);
+      budgetUs = StrictMathWrapper.multiplyExact(effectiveMs, 1_000L);
+    } else {
+      long unscaledUs = StrictMathWrapper.multiplyExact(maxCpuTimeOfOneTxMs, 1_000L);
+      budgetUs = (long) (unscaledUs * cpuLimitRatio);
+    }
+    return StrictMathWrapper.addExact(vmStartInUs, budgetUs);
+  }
+
+  /**
+   * Whether the constant-call concurrency cap should engage. The cap engages
+   * strictly when the operator's configured timeout exceeds the network's
+   * current {@code maxCpuTimeOfOneTx}; nodes leaving the timeout at the
+   * sentinel see no throttling. Issue #6681.
+   */
+  public static boolean isCapEngaged(long configuredConstantCallTimeoutMs,
+                                     long networkMaxCpuTimeOfOneTxMs) {
+    return configuredConstantCallTimeoutMs > networkMaxCpuTimeOfOneTxMs;
+  }
+}
diff --git a/common/src/main/resources/reference.conf b/common/src/main/resources/reference.conf
@@ -709,6 +709,17 @@ vm = {
 
   # Max retry time for executing transaction in estimating energy
   estimateEnergyMaxRetry = 3
+
+  # Max TVM execution time (ms) for constant calls (triggerconstantcontract /
+  # eth_call). 0 = use the same deadline as block processing. When set, must be
+  # in [80, 500]. See issue #6681. Migration note: if previously running --debug
+  # to extend constant calls, switch to this option (--debug also extends
+  # block-processing, which is unsafe; see issue #6266).
+  constantCallTimeoutMs = 0
+
+  # Max concurrent constant-call executions. Engages only when
+  # constantCallTimeoutMs is raised above 80.
+  constantCallMaxConcurrency = 10
 }
 
 # Governance proposal toggle parameters. All default to 0 (disabled).
diff --git a/framework/src/main/java/org/tron/core/Wallet.java b/framework/src/main/java/org/tron/core/Wallet.java
@@ -61,6 +61,7 @@
 import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.concurrent.Semaphore;
 import java.util.stream.Collectors;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
@@ -210,6 +211,7 @@
 import org.tron.core.store.VotesStore;
 import org.tron.core.store.WitnessStore;
 import org.tron.core.utils.TransactionUtil;
+import org.tron.core.vm.VmTimeoutPolicy;
 import org.tron.core.vm.program.Program;
 import org.tron.core.zen.ShieldedTRC20ParametersBuilder;
 import org.tron.core.zen.ShieldedTRC20ParametersBuilder.ShieldedTRC20ParametersType;
@@ -279,6 +281,23 @@ public class Wallet {
       .fromString("TokenBurn(address,uint256,bytes32[3])"));
   private static final String BROADCAST_TRANS_FAILED = "Broadcast transaction {} failed, {}.";
 
+  private static volatile Semaphore constantCallSemaphore;
+
+  private static Semaphore getConstantCallSemaphore() {
+    Semaphore s = constantCallSemaphore;
+    if (s == null) {
+      synchronized (Wallet.class) {
+        s = constantCallSemaphore;
+        if (s == null) {
+          s = new Semaphore(
+              CommonParameter.getInstance().getConstantCallMaxConcurrency(), true);
+          constantCallSemaphore = s;
+        }
+      }
+    }
+    return s;
+  }
+
   @Getter
   private final SignInterface cryptoEngine;
   @Autowired
@@ -3158,53 +3177,69 @@ public Transaction callConstantContract(TransactionCapsule trxCap,
       throw new ContractValidateException("this node does not support constant");
     }
 
-    Block headBlock;
-    List<BlockCapsule> blockCapsuleList = chainBaseManager.getBlockStore()
-        .getBlockByLatestNum(1);
-    if (CollectionUtils.isEmpty(blockCapsuleList)) {
-      throw new HeaderNotFound("latest block not found");
-    } else {
-      headBlock = blockCapsuleList.get(0).getInstance();
-    }
-
-    BlockCapsule headBlockCapsule = new BlockCapsule(headBlock);
-    TransactionContext context = new TransactionContext(headBlockCapsule, trxCap,
-        StoreFactory.getInstance(), true, false);
-    VMActuator vmActuator = new VMActuator(true);
-
-    vmActuator.validate(context);
-    vmActuator.execute(context);
-
-    ProgramResult result = context.getProgramResult();
-    if (!isEstimating && result.getException() != null
-        || result.getException() instanceof Program.OutOfTimeException) {
-      RuntimeException e = result.getException();
-      logger.warn("Constant call failed for reason: {}", e.getMessage());
-      throw e;
-    }
-
-    TransactionResultCapsule ret = new TransactionResultCapsule();
-    builder.setEnergyUsed(result.getEnergyUsed());
-    builder.setEnergyPenalty(result.getEnergyPenaltyTotal());
-    builder.addConstantResult(ByteString.copyFrom(result.getHReturn()));
-    result.getLogInfoList().forEach(logInfo ->
-        builder.addLogs(LogInfo.buildLog(logInfo)));
-    result.getInternalTransactions().forEach(it ->
-        builder.addInternalTransactions(buildInternalTransaction(it)));
-    ret.setStatus(0, code.SUCESS);
-    if (StringUtils.isNoneEmpty(result.getRuntimeError())) {
-      ret.setStatus(0, code.FAILED);
-      retBuilder
-          .setMessage(ByteString.copyFromUtf8(result.getRuntimeError()))
-          .build();
+    long networkMaxCpuTimeOfOneTxMs = chainBaseManager.getDynamicPropertiesStore()
+        .getMaxCpuTimeOfOneTx();
+    boolean throttled = VmTimeoutPolicy.isCapEngaged(
+        CommonParameter.getInstance().getConstantCallTimeoutMs(), networkMaxCpuTimeOfOneTxMs);
+    Semaphore sem = throttled ? getConstantCallSemaphore() : null;
+    if (sem != null && !sem.tryAcquire()) {
+      throw new ContractValidateException(
+          "too many concurrent constant calls; configured cap is "
+              + CommonParameter.getInstance().getConstantCallMaxConcurrency());
     }
-    if (result.isRevert()) {
-      ret.setStatus(0, code.FAILED);
-      retBuilder.setMessage(ByteString.copyFromUtf8("REVERT opcode executed"))
-          .build();
+    try {
+      Block headBlock;
+      List<BlockCapsule> blockCapsuleList = chainBaseManager.getBlockStore()
+          .getBlockByLatestNum(1);
+      if (CollectionUtils.isEmpty(blockCapsuleList)) {
+        throw new HeaderNotFound("latest block not found");
+      } else {
+        headBlock = blockCapsuleList.get(0).getInstance();
+      }
+
+      BlockCapsule headBlockCapsule = new BlockCapsule(headBlock);
+      TransactionContext context = new TransactionContext(headBlockCapsule, trxCap,
+          StoreFactory.getInstance(), true, false);
+      VMActuator vmActuator = new VMActuator(true);
+
+      vmActuator.validate(context);
+      vmActuator.execute(context);
+
+      ProgramResult result = context.getProgramResult();
+      if (!isEstimating && result.getException() != null
+          || result.getException() instanceof Program.OutOfTimeException) {
+        RuntimeException e = result.getException();
+        logger.warn("Constant call failed for reason: {}", e.getMessage());
+        throw e;
+      }
+
+      TransactionResultCapsule ret = new TransactionResultCapsule();
+      builder.setEnergyUsed(result.getEnergyUsed());
+      builder.setEnergyPenalty(result.getEnergyPenaltyTotal());
+      builder.addConstantResult(ByteString.copyFrom(result.getHReturn()));
+      result.getLogInfoList().forEach(logInfo ->
+          builder.addLogs(LogInfo.buildLog(logInfo)));
+      result.getInternalTransactions().forEach(it ->
+          builder.addInternalTransactions(buildInternalTransaction(it)));
+      ret.setStatus(0, code.SUCESS);
+      if (StringUtils.isNoneEmpty(result.getRuntimeError())) {
+        ret.setStatus(0, code.FAILED);
+        retBuilder
+            .setMessage(ByteString.copyFromUtf8(result.getRuntimeError()))
+            .build();
+      }
+      if (result.isRevert()) {
+        ret.setStatus(0, code.FAILED);
+        retBuilder.setMessage(ByteString.copyFromUtf8("REVERT opcode executed"))
+            .build();
+      }
+      trxCap.setResult(ret);
+      return trxCap.getInstance();
+    } finally {
+      if (sem != null) {
+        sem.release();
+      }
     }
-    trxCap.setResult(ret);
-    return trxCap.getInstance();
   }
 
   public SmartContract getContract(GrpcAPI.BytesMessage bytesMessage) {
diff --git a/framework/src/main/java/org/tron/core/config/args/Args.java b/framework/src/main/java/org/tron/core/config/args/Args.java
@@ -73,6 +73,7 @@
 import org.tron.core.config.Parameter.NodeConstant;
 import org.tron.core.exception.TronError;
 import org.tron.core.store.AccountStore;
+import org.tron.core.vm.VmTimeoutPolicy;
 import org.tron.p2p.P2pConfig;
 import org.tron.p2p.dns.update.DnsType;
 import org.tron.p2p.dns.update.PublishConfig;
@@ -212,6 +213,22 @@ private static void applyVmConfig(VmConfig vm) {
     PARAMETER.saveInternalTx = vm.isSaveInternalTx();
     PARAMETER.saveFeaturedInternalTx = vm.isSaveFeaturedInternalTx();
     PARAMETER.saveCancelAllUnfreezeV2Details = vm.isSaveCancelAllUnfreezeV2Details();
+    PARAMETER.constantCallTimeoutMs = vm.getConstantCallTimeoutMs();
+    PARAMETER.constantCallMaxConcurrency = vm.getConstantCallMaxConcurrency();
+
+    if (PARAMETER.constantCallTimeoutMs != VmTimeoutPolicy.CONSTANT_CALL_TIMEOUT_UNSET) {
+      logger.warn(
+          "vm.constantCallTimeoutMs is configured to {} ms; the concurrency"
+              + " cap of {} will engage whenever this value exceeds the"
+              + " network's current maxCpuTimeOfOneTx (operators can only"
+              + " extend, not shrink, the constant-call window)."
+              + " Tune with vm.constantCallMaxConcurrency. See issue #6681."
+              + " If you previously ran with --debug solely for this purpose,"
+              + " switch to vm.constantCallTimeoutMs (--debug also extends"
+              + " block-processing, which is unsafe; see issue #6266).",
+          PARAMETER.constantCallTimeoutMs,
+          PARAMETER.constantCallMaxConcurrency);
+    }
   }
 
   // Old applyStorageConfig removed — merged into applyStorageConfig()
diff --git a/framework/src/main/resources/config.conf b/framework/src/main/resources/config.conf
