diff --git a/actuator/src/main/java/org/tron/core/utils/ProposalUtil.java b/actuator/src/main/java/org/tron/core/utils/ProposalUtil.java index cd42d7a9010..6b297883fbd 100644 --- a/actuator/src/main/java/org/tron/core/utils/ProposalUtil.java +++ b/actuator/src/main/java/org/tron/core/utils/ProposalUtil.java @@ -886,6 +886,22 @@ public static void validator(DynamicPropertiesStore dynamicPropertiesStore, } break; } + case ALLOW_HARDEN_RESOURCE_CALCULATION: { + if (!forkController.pass(ForkBlockVersionEnum.VERSION_4_8_2)) { + throw new ContractValidateException( + "Bad chain parameter id [ALLOW_HARDEN_RESOURCE_CALCULATION]"); + } + if (dynamicPropertiesStore.getAllowHardenResourceCalculation() == 1) { + throw new ContractValidateException( + "[ALLOW_HARDEN_RESOURCE_CALCULATION] has been valid, " + + "no need to propose again"); + } + if (value != 1) { + throw new ContractValidateException( + "This value[ALLOW_HARDEN_RESOURCE_CALCULATION] is only allowed to be 1"); + } + break; + } default: break; } @@ -971,7 +987,8 @@ public enum ProposalType { // current value, value range ALLOW_TVM_BLOB(89), // 0, 1 PROPOSAL_EXPIRE_TIME(92), // (0, 31536003000) ALLOW_TVM_SELFDESTRUCT_RESTRICTION(94), // 0, 1 - ALLOW_TVM_OSAKA(96); // 0, 1 + ALLOW_TVM_OSAKA(96), // 0, 1 + ALLOW_HARDEN_RESOURCE_CALCULATION(97); // 0, 1 private long code; diff --git a/actuator/src/main/java/org/tron/core/vm/config/ConfigLoader.java b/actuator/src/main/java/org/tron/core/vm/config/ConfigLoader.java index e099101912b..881eb861bea 100644 --- a/actuator/src/main/java/org/tron/core/vm/config/ConfigLoader.java +++ b/actuator/src/main/java/org/tron/core/vm/config/ConfigLoader.java @@ -46,6 +46,7 @@ public static void load(StoreFactory storeFactory) { VMConfig.initAllowTvmBlob(ds.getAllowTvmBlob()); VMConfig.initAllowTvmSelfdestructRestriction(ds.getAllowTvmSelfdestructRestriction()); VMConfig.initAllowTvmOsaka(ds.getAllowTvmOsaka()); + VMConfig.initAllowHardenResourceCalculation(ds.getAllowHardenResourceCalculation()); } } } diff --git a/actuator/src/main/java/org/tron/core/vm/repository/RepositoryImpl.java b/actuator/src/main/java/org/tron/core/vm/repository/RepositoryImpl.java index 9de7c0691ba..62e7ce6ec08 100644 --- a/actuator/src/main/java/org/tron/core/vm/repository/RepositoryImpl.java +++ b/actuator/src/main/java/org/tron/core/vm/repository/RepositoryImpl.java @@ -8,6 +8,7 @@ import com.google.common.collect.HashBasedTable; import com.google.protobuf.ByteString; +import java.math.BigInteger; import java.util.HashMap; import java.util.HashSet; import java.util.Optional; @@ -17,6 +18,7 @@ import org.bouncycastle.util.Strings; import org.bouncycastle.util.encoders.Hex; import org.tron.common.crypto.Hash; +import org.tron.common.math.StrictMathWrapper; import org.tron.common.parameter.CommonParameter; import org.tron.common.runtime.vm.DataWord; import org.tron.common.utils.ByteArray; @@ -223,7 +225,7 @@ public Pair getAccountEnergyUsageBalanceAndRestoreSeconds(AccountCap long totalEnergyLimit = getDynamicPropertiesStore().getTotalEnergyCurrentLimit(); long totalEnergyWeight = getTotalEnergyWeight(); - long balance = (long) ((double) newEnergyUsage * totalEnergyWeight / totalEnergyLimit * TRX_PRECISION); + long balance = usageToBalance(newEnergyUsage, totalEnergyWeight, totalEnergyLimit); return Pair.of(balance, restoreSlots * BLOCK_PRODUCED_INTERVAL / 1_000); } @@ -246,11 +248,22 @@ public Pair getAccountNetUsageBalanceAndRestoreSeconds(AccountCapsul long totalNetLimit = getDynamicPropertiesStore().getTotalNetLimit(); long totalNetWeight = getTotalNetWeight(); - long balance = (long) ((double) newNetUsage * totalNetWeight / totalNetLimit * TRX_PRECISION); + long balance = usageToBalance(newNetUsage, totalNetWeight, totalNetLimit); return Pair.of(balance, restoreSlots * BLOCK_PRODUCED_INTERVAL / 1_000); } + private long usageToBalance(long usage, long totalWeight, long totalLimit) { + if (hardenResourceCalculation()) { + return BigInteger.valueOf(usage) + .multiply(BigInteger.valueOf(totalWeight)) + .multiply(BigInteger.valueOf(TRX_PRECISION)) + .divide(BigInteger.valueOf(totalLimit)) + .longValueExact(); + } + return (long) ((double) usage * totalWeight / totalLimit * TRX_PRECISION); + } + @Override public AssetIssueCapsule getAssetIssue(byte[] tokenId) { byte[] tokenIdWithoutLeadingZero = ByteUtil.stripLeadingZeroes(tokenId); @@ -896,8 +909,19 @@ private long recover(long lastUsage, long lastTime, long now, long personalWindo } private long increase(long lastUsage, long usage, long lastTime, long now, long windowSize) { - long averageLastUsage = divideCeil(lastUsage * precision, windowSize); - long averageUsage = divideCeil(usage * precision, windowSize); + long averageLastUsage; + long averageUsage; + if (hardenResourceCalculation()) { + BigInteger biPrecision = BigInteger.valueOf(precision); + BigInteger biWindowSize = BigInteger.valueOf(windowSize); + averageLastUsage = divideCeilExact( + BigInteger.valueOf(lastUsage).multiply(biPrecision), biWindowSize); + averageUsage = divideCeilExact( + BigInteger.valueOf(usage).multiply(biPrecision), biWindowSize); + } else { + averageLastUsage = divideCeil(lastUsage * precision, windowSize); + averageUsage = divideCeil(usage * precision, windowSize); + } if (lastTime != now) { assert now > lastTime; @@ -917,21 +941,46 @@ private long divideCeil(long numerator, long denominator) { return (numerator / denominator) + ((numerator % denominator) > 0 ? 1 : 0); } + private long divideCeilExact(BigInteger numerator, BigInteger denominator) { + BigInteger[] divRem = numerator.divideAndRemainder(denominator); + long result = divRem[0].longValueExact(); + if (divRem[1].signum() > 0) { + result = StrictMathWrapper.addExact(result, 1); + } + return result; + } + private long getUsage(long usage, long windowSize) { + if (hardenResourceCalculation()) { + return BigInteger.valueOf(usage) + .multiply(BigInteger.valueOf(windowSize)) + .divide(BigInteger.valueOf(precision)) + .longValueExact(); + } return usage * windowSize / precision; } + private boolean hardenResourceCalculation() { + return VMConfig.allowHardenResourceCalculation(); + } + public long calculateGlobalEnergyLimit(AccountCapsule accountCapsule) { long frozeBalance = accountCapsule.getAllFrozenBalanceForEnergy(); - if (frozeBalance < 1_000_000L) { + if (frozeBalance < TRX_PRECISION) { return 0; } - long energyWeight = frozeBalance / 1_000_000L; + long energyWeight = frozeBalance / TRX_PRECISION; long totalEnergyLimit = getDynamicPropertiesStore().getTotalEnergyCurrentLimit(); long totalEnergyWeight = getDynamicPropertiesStore().getTotalEnergyWeight(); assert totalEnergyWeight > 0; + if (hardenResourceCalculation()) { + return BigInteger.valueOf(energyWeight) + .multiply(BigInteger.valueOf(totalEnergyLimit)) + .divide(BigInteger.valueOf(totalEnergyWeight)) + .longValueExact(); + } return (long) (energyWeight * ((double) totalEnergyLimit / totalEnergyWeight)); } diff --git a/build.gradle b/build.gradle index 12a0622db99..4ceebadb158 100644 --- a/build.gradle +++ b/build.gradle @@ -35,7 +35,7 @@ ext.archInfo = [ // https://github.com/grpc/grpc-java/issues/7690 // https://github.com/grpc/grpc-java/pull/12319, Add support for macOS aarch64 with universal binary // https://github.com/grpc/grpc-java/pull/11371 , 1.64.x is not supported CentOS 7. - ProtocGenVersion: isArm64 && isMac ? '1.76.0' : '1.60.0' + ProtocGenVersion: isArm64 || isMac ? '1.81.0' : '1.60.0' ], VMOptions: isArm64 ? "${rootDir}/gradle/jdk17/java-tron.vmoptions" : "${rootDir}/gradle/java-tron.vmoptions" ] @@ -90,7 +90,7 @@ subprojects { implementation group: 'org.apache.commons', name: 'commons-math', version: '2.2' implementation "org.apache.commons:commons-collections4:4.1" implementation group: 'joda-time', name: 'joda-time', version: '2.3' - implementation group: 'org.bouncycastle', name: 'bcprov-jdk18on', version: '1.79' + implementation group: 'org.bouncycastle', name: 'bcprov-jdk18on', version: '1.84' compileOnly 'org.projectlombok:lombok:1.18.34' annotationProcessor 'org.projectlombok:lombok:1.18.34' diff --git a/chainbase/src/main/java/org/tron/core/db/BandwidthProcessor.java b/chainbase/src/main/java/org/tron/core/db/BandwidthProcessor.java index 2488686bfb0..ece16b25819 100644 --- a/chainbase/src/main/java/org/tron/core/db/BandwidthProcessor.java +++ b/chainbase/src/main/java/org/tron/core/db/BandwidthProcessor.java @@ -437,7 +437,6 @@ public long calculateGlobalNetLimit(AccountCapsule accountCapsule) { if (frozeBalance < TRX_PRECISION) { return 0; } - long netWeight = frozeBalance / TRX_PRECISION; long totalNetLimit = chainBaseManager.getDynamicPropertiesStore().getTotalNetLimit(); long totalNetWeight = chainBaseManager.getDynamicPropertiesStore().getTotalNetWeight(); if (dynamicPropertiesStore.allowNewReward() && totalNetWeight <= 0) { @@ -446,16 +445,23 @@ public long calculateGlobalNetLimit(AccountCapsule accountCapsule) { if (totalNetWeight == 0) { return 0; } + if (hardenCalculation()) { + return calculateGlobalLimitV1(frozeBalance, totalNetLimit, totalNetWeight); + } + long netWeight = frozeBalance / TRX_PRECISION; return (long) (netWeight * ((double) totalNetLimit / totalNetWeight)); } public long calculateGlobalNetLimitV2(long frozeBalance) { - double netWeight = (double) frozeBalance / TRX_PRECISION; long totalNetLimit = dynamicPropertiesStore.getTotalNetLimit(); long totalNetWeight = dynamicPropertiesStore.getTotalNetWeight(); if (totalNetWeight == 0) { return 0; } + if (hardenCalculation()) { + return calculateGlobalLimitV2(frozeBalance, totalNetLimit, totalNetWeight); + } + double netWeight = (double) frozeBalance / TRX_PRECISION; return (long) (netWeight * ((double) totalNetLimit / totalNetWeight)); } diff --git a/chainbase/src/main/java/org/tron/core/db/EnergyProcessor.java b/chainbase/src/main/java/org/tron/core/db/EnergyProcessor.java index 30d778d0990..0c429178636 100644 --- a/chainbase/src/main/java/org/tron/core/db/EnergyProcessor.java +++ b/chainbase/src/main/java/org/tron/core/db/EnergyProcessor.java @@ -5,6 +5,7 @@ import static org.tron.core.config.Parameter.ChainConstant.BLOCK_PRODUCED_INTERVAL; import static org.tron.core.config.Parameter.ChainConstant.TRX_PRECISION; +import java.math.BigInteger; import lombok.extern.slf4j.Slf4j; import org.tron.common.parameter.CommonParameter; import org.tron.core.capsule.AccountCapsule; @@ -71,17 +72,20 @@ public void updateAdaptiveTotalEnergyLimit() { long result; if (totalEnergyAverageUsage > targetTotalEnergyLimit) { - result = totalEnergyCurrentLimit * AdaptiveResourceLimitConstants.CONTRACT_RATE_NUMERATOR - / AdaptiveResourceLimitConstants.CONTRACT_RATE_DENOMINATOR; - // logger.info(totalEnergyAverageUsage + ">" + targetTotalEnergyLimit + "\n" + result); + result = scaleByRate(totalEnergyCurrentLimit, + AdaptiveResourceLimitConstants.CONTRACT_RATE_NUMERATOR, + AdaptiveResourceLimitConstants.CONTRACT_RATE_DENOMINATOR); } else { - result = totalEnergyCurrentLimit * AdaptiveResourceLimitConstants.EXPAND_RATE_NUMERATOR - / AdaptiveResourceLimitConstants.EXPAND_RATE_DENOMINATOR; - // logger.info(totalEnergyAverageUsage + "<" + targetTotalEnergyLimit + "\n" + result); + result = scaleByRate(totalEnergyCurrentLimit, + AdaptiveResourceLimitConstants.EXPAND_RATE_NUMERATOR, + AdaptiveResourceLimitConstants.EXPAND_RATE_DENOMINATOR); } + long upperBound = hardenCalculation() + ? BigInteger.valueOf(totalEnergyLimit).multiply(BigInteger.valueOf( + dynamicPropertiesStore.getAdaptiveResourceLimitMultiplier())).longValueExact() + : totalEnergyLimit * dynamicPropertiesStore.getAdaptiveResourceLimitMultiplier(); result = min(max(result, totalEnergyLimit, this.disableJavaLangMath()), - totalEnergyLimit * dynamicPropertiesStore.getAdaptiveResourceLimitMultiplier(), - this.disableJavaLangMath()); + upperBound, this.disableJavaLangMath()); dynamicPropertiesStore.saveTotalEnergyCurrentLimit(result); logger.debug("Adjust totalEnergyCurrentLimit, old: {}, new: {}.", @@ -147,7 +151,6 @@ public long calculateGlobalEnergyLimit(AccountCapsule accountCapsule) { return 0; } - long energyWeight = frozeBalance / TRX_PRECISION; long totalEnergyLimit = dynamicPropertiesStore.getTotalEnergyCurrentLimit(); long totalEnergyWeight = dynamicPropertiesStore.getTotalEnergyWeight(); if (dynamicPropertiesStore.allowNewReward() && totalEnergyWeight <= 0) { @@ -155,16 +158,23 @@ public long calculateGlobalEnergyLimit(AccountCapsule accountCapsule) { } else { assert totalEnergyWeight > 0; } + if (hardenCalculation()) { + return calculateGlobalLimitV1(frozeBalance, totalEnergyLimit, totalEnergyWeight); + } + long energyWeight = frozeBalance / TRX_PRECISION; return (long) (energyWeight * ((double) totalEnergyLimit / totalEnergyWeight)); } public long calculateGlobalEnergyLimitV2(long frozeBalance) { - double energyWeight = (double) frozeBalance / TRX_PRECISION; long totalEnergyLimit = dynamicPropertiesStore.getTotalEnergyCurrentLimit(); long totalEnergyWeight = dynamicPropertiesStore.getTotalEnergyWeight(); if (totalEnergyWeight == 0) { return 0; } + if (hardenCalculation()) { + return calculateGlobalLimitV2(frozeBalance, totalEnergyLimit, totalEnergyWeight); + } + double energyWeight = (double) frozeBalance / TRX_PRECISION; return (long) (energyWeight * ((double) totalEnergyLimit / totalEnergyWeight)); } @@ -184,7 +194,15 @@ private long getHeadSlot() { return getHeadSlot(dynamicPropertiesStore); } - + private long scaleByRate(long value, long numerator, long denominator) { + if (hardenCalculation()) { + return BigInteger.valueOf(value) + .multiply(BigInteger.valueOf(numerator)) + .divide(BigInteger.valueOf(denominator)) + .longValueExact(); + } + return value * numerator / denominator; + } } diff --git a/chainbase/src/main/java/org/tron/core/db/ResourceProcessor.java b/chainbase/src/main/java/org/tron/core/db/ResourceProcessor.java index 7e170f9dab5..6706c430084 100644 --- a/chainbase/src/main/java/org/tron/core/db/ResourceProcessor.java +++ b/chainbase/src/main/java/org/tron/core/db/ResourceProcessor.java @@ -3,8 +3,11 @@ import static org.tron.common.math.Maths.min; import static org.tron.common.math.Maths.round; import static org.tron.core.config.Parameter.ChainConstant.BLOCK_PRODUCED_INTERVAL; +import static org.tron.core.config.Parameter.ChainConstant.TRX_PRECISION; import static org.tron.core.config.Parameter.ChainConstant.WINDOW_SIZE_PRECISION; +import java.math.BigInteger; +import org.tron.common.math.StrictMathWrapper; import org.tron.common.utils.Commons; import org.tron.core.capsule.AccountCapsule; import org.tron.core.capsule.TransactionCapsule; @@ -45,8 +48,19 @@ protected long increase(long lastUsage, long usage, long lastTime, long now) { } protected long increase(long lastUsage, long usage, long lastTime, long now, long windowSize) { - long averageLastUsage = divideCeil(lastUsage * precision, windowSize); - long averageUsage = divideCeil(usage * precision, windowSize); + long averageLastUsage; + long averageUsage; + if (hardenCalculation()) { + BigInteger biPrecision = BigInteger.valueOf(precision); + BigInteger biWindowSize = BigInteger.valueOf(windowSize); + averageLastUsage = divideCeilExact( + BigInteger.valueOf(lastUsage).multiply(biPrecision), biWindowSize); + averageUsage = divideCeilExact( + BigInteger.valueOf(usage).multiply(biPrecision), biWindowSize); + } else { + averageLastUsage = divideCeil(lastUsage * precision, windowSize); + averageUsage = divideCeil(usage * precision, windowSize); + } if (lastTime != now) { assert now > lastTime; @@ -75,8 +89,20 @@ public long increase(AccountCapsule accountCapsule, ResourceCode resourceCode, return increaseV2(accountCapsule, resourceCode, lastUsage, usage, lastTime, now); } long oldWindowSize = accountCapsule.getWindowSize(resourceCode); - long averageLastUsage = divideCeil(lastUsage * this.precision, oldWindowSize); - long averageUsage = divideCeil(usage * this.precision, this.windowSize); + long averageLastUsage; + long averageUsage; + if (hardenCalculation()) { + BigInteger biPrecision = BigInteger.valueOf(this.precision); + averageLastUsage = divideCeilExact( + BigInteger.valueOf(lastUsage).multiply(biPrecision), + BigInteger.valueOf(oldWindowSize)); + averageUsage = divideCeilExact( + BigInteger.valueOf(usage).multiply(biPrecision), + BigInteger.valueOf(this.windowSize)); + } else { + averageLastUsage = divideCeil(lastUsage * this.precision, oldWindowSize); + averageUsage = divideCeil(usage * this.precision, this.windowSize); + } if (lastTime != now) { if (lastTime + oldWindowSize > now) { @@ -108,8 +134,20 @@ public long increaseV2(AccountCapsule accountCapsule, ResourceCode resourceCode, long lastUsage, long usage, long lastTime, long now) { long oldWindowSizeV2 = accountCapsule.getWindowSizeV2(resourceCode); long oldWindowSize = accountCapsule.getWindowSize(resourceCode); - long averageLastUsage = divideCeil(lastUsage * this.precision, oldWindowSize); - long averageUsage = divideCeil(usage * this.precision, this.windowSize); + long averageLastUsage; + long averageUsage; + if (hardenCalculation()) { + BigInteger biPrecision = BigInteger.valueOf(this.precision); + averageLastUsage = divideCeilExact( + BigInteger.valueOf(lastUsage).multiply(biPrecision), + BigInteger.valueOf(oldWindowSize)); + averageUsage = divideCeilExact( + BigInteger.valueOf(usage).multiply(biPrecision), + BigInteger.valueOf(this.windowSize)); + } else { + averageLastUsage = divideCeil(lastUsage * this.precision, oldWindowSize); + averageUsage = divideCeil(usage * this.precision, this.windowSize); + } if (lastTime != now) { if (lastTime + oldWindowSize > now) { @@ -130,8 +168,19 @@ public long increaseV2(AccountCapsule accountCapsule, ResourceCode resourceCode, } long remainWindowSize = oldWindowSizeV2 - (now - lastTime) * WINDOW_SIZE_PRECISION; - long newWindowSize = divideCeil( - remainUsage * remainWindowSize + usage * this.windowSize * WINDOW_SIZE_PRECISION, newUsage); + long newWindowSize; + if (hardenCalculation()) { + BigInteger biNewWindowSize = BigInteger.valueOf(remainUsage) + .multiply(BigInteger.valueOf(remainWindowSize)) + .add(BigInteger.valueOf(usage) + .multiply(BigInteger.valueOf(this.windowSize)) + .multiply(BigInteger.valueOf(WINDOW_SIZE_PRECISION))); + newWindowSize = divideCeilExact(biNewWindowSize, BigInteger.valueOf(newUsage)); + } else { + newWindowSize = divideCeil( + remainUsage * remainWindowSize + usage * this.windowSize * WINDOW_SIZE_PRECISION, + newUsage); + } newWindowSize = min(newWindowSize, this.windowSize * WINDOW_SIZE_PRECISION, this.disableJavaLangMath()); accountCapsule.setNewWindowSizeV2(resourceCode, newWindowSize); @@ -191,10 +240,18 @@ public void unDelegateIncreaseV2(AccountCapsule owner, final AccountCapsule rece remainReceiverWindowSizeV2 = remainReceiverWindowSizeV2 < 0 ? 0 : remainReceiverWindowSizeV2; // calculate new windowSize - long newOwnerWindowSize = - divideCeil( - ownerUsage * remainOwnerWindowSizeV2 + transferUsage * remainReceiverWindowSizeV2, - newOwnerUsage); + long newOwnerWindowSize; + if (hardenCalculation()) { + BigInteger bi = BigInteger.valueOf(ownerUsage) + .multiply(BigInteger.valueOf(remainOwnerWindowSizeV2)) + .add(BigInteger.valueOf(transferUsage) + .multiply(BigInteger.valueOf(remainReceiverWindowSizeV2))); + newOwnerWindowSize = divideCeilExact(bi, BigInteger.valueOf(newOwnerUsage)); + } else { + newOwnerWindowSize = divideCeil( + ownerUsage * remainOwnerWindowSizeV2 + transferUsage * remainReceiverWindowSizeV2, + newOwnerUsage); + } newOwnerWindowSize = min(newOwnerWindowSize, this.windowSize * WINDOW_SIZE_PRECISION, this.disableJavaLangMath()); owner.setNewWindowSizeV2(resourceCode, newOwnerWindowSize); @@ -204,6 +261,11 @@ public void unDelegateIncreaseV2(AccountCapsule owner, final AccountCapsule rece private long getNewWindowSize(long lastUsage, long lastWindowSize, long usage, long windowSize, long newUsage) { + if (hardenCalculation()) { + BigInteger bi = BigInteger.valueOf(lastUsage).multiply(BigInteger.valueOf(lastWindowSize)) + .add(BigInteger.valueOf(usage).multiply(BigInteger.valueOf(windowSize))); + return bi.divide(BigInteger.valueOf(newUsage)).longValueExact(); + } return (lastUsage * lastWindowSize + usage * windowSize) / newUsage; } @@ -211,11 +273,29 @@ private long divideCeil(long numerator, long denominator) { return (numerator / denominator) + ((numerator % denominator) > 0 ? 1 : 0); } + private long divideCeilExact(BigInteger numerator, BigInteger denominator) { + BigInteger[] divRem = numerator.divideAndRemainder(denominator); + long result = divRem[0].longValueExact(); + if (divRem[1].signum() > 0) { + result = StrictMathWrapper.addExact(result, 1); + } + return result; + } + private long getUsage(long usage, long windowSize) { + if (hardenCalculation()) { + return BigInteger.valueOf(usage).multiply(BigInteger.valueOf(windowSize)) + .divide(BigInteger.valueOf(precision)).longValueExact(); + } return usage * windowSize / precision; } private long getUsage(long oldUsage, long oldWindowSize, long newUsage, long newWindowSize) { + if (hardenCalculation()) { + BigInteger bi = BigInteger.valueOf(oldUsage).multiply(BigInteger.valueOf(oldWindowSize)) + .add(BigInteger.valueOf(newUsage).multiply(BigInteger.valueOf(newWindowSize))); + return bi.divide(BigInteger.valueOf(precision)).longValueExact(); + } return (oldUsage * oldWindowSize + newUsage * newWindowSize) / precision; } @@ -262,4 +342,38 @@ protected boolean consumeFeeForNewAccount(AccountCapsule accountCapsule, long fe protected boolean disableJavaLangMath() { return dynamicPropertiesStore.disableJavaLangMath(); } + + protected boolean hardenCalculation() { + return dynamicPropertiesStore.allowHardenResourceCalculation(); + } + + protected long calculateGlobalLimitV1(long frozeBalance, + long totalLimit, long totalWeight) { + long weight = frozeBalance / TRX_PRECISION; + return BigInteger.valueOf(weight) + .multiply(BigInteger.valueOf(totalLimit)) + .divide(BigInteger.valueOf(totalWeight)) + .longValueExact(); + } + + /** + * Hardened replacement of legacy V2 formula + * {@code (long)(((double) frozeBalance / TRX_PRECISION) + * * ((double) totalLimit / totalWeight))}. + * + *

Preserves V2 semantics: equivalent to + * {@code (frozeBalance * totalLimit) / (TRX_PRECISION * totalWeight)} with + * a single integer truncation at the end. Critically, fractional weight + * (i.e. {@code frozeBalance < TRX_PRECISION}) is preserved through the + * multiplication and only truncated at the final divide, so small balances + * yield the same proportional result as the double-arithmetic path. + */ + protected long calculateGlobalLimitV2(long frozeBalance, + long totalLimit, long totalWeight) { + return BigInteger.valueOf(frozeBalance) + .multiply(BigInteger.valueOf(totalLimit)) + .divide(BigInteger.valueOf(TRX_PRECISION) + .multiply(BigInteger.valueOf(totalWeight))) + .longValueExact(); + } } diff --git a/chainbase/src/main/java/org/tron/core/store/DynamicPropertiesStore.java b/chainbase/src/main/java/org/tron/core/store/DynamicPropertiesStore.java index e0adb0d444a..12dfca5e59a 100644 --- a/chainbase/src/main/java/org/tron/core/store/DynamicPropertiesStore.java +++ b/chainbase/src/main/java/org/tron/core/store/DynamicPropertiesStore.java @@ -240,6 +240,9 @@ public class DynamicPropertiesStore extends TronStoreWithRevoking private static final byte[] ALLOW_TVM_OSAKA = "ALLOW_TVM_OSAKA".getBytes(); + private static final byte[] ALLOW_HARDEN_RESOURCE_CALCULATION = + "ALLOW_HARDEN_RESOURCE_CALCULATION".getBytes(); + @Autowired private DynamicPropertiesStore(@Value("properties") String dbName) { super(dbName); @@ -2993,6 +2996,21 @@ public void saveAllowTvmOsaka(long value) { this.put(ALLOW_TVM_OSAKA, new BytesCapsule(ByteArray.fromLong(value))); } + public long getAllowHardenResourceCalculation() { + return Optional.ofNullable(getUnchecked(ALLOW_HARDEN_RESOURCE_CALCULATION)) + .map(BytesCapsule::getData) + .map(ByteArray::toLong) + .orElse(0L); + } + + public void saveAllowHardenResourceCalculation(long value) { + this.put(ALLOW_HARDEN_RESOURCE_CALCULATION, new BytesCapsule(ByteArray.fromLong(value))); + } + + public boolean allowHardenResourceCalculation() { + return getAllowHardenResourceCalculation() == 1L; + } + private static class DynamicResourceProperties { private static final byte[] ONE_DAY_NET_LIMIT = "ONE_DAY_NET_LIMIT".getBytes(); diff --git a/common/src/main/java/org/tron/common/parameter/CommonParameter.java b/common/src/main/java/org/tron/common/parameter/CommonParameter.java index a73158a718a..e7957c917e2 100644 --- a/common/src/main/java/org/tron/common/parameter/CommonParameter.java +++ b/common/src/main/java/org/tron/common/parameter/CommonParameter.java @@ -119,6 +119,9 @@ public class CommonParameter { public int maxTps; // clearParam: 1000 @Getter @Setter + public int maxBlockInvPerSecond = 10; // default: 10 block inv hashes/s per peer + @Getter + @Setter public int minParticipationRate; @Getter public P2pConfig p2pConfig; diff --git a/common/src/main/java/org/tron/core/config/args/NodeConfig.java b/common/src/main/java/org/tron/core/config/args/NodeConfig.java index c3305e976de..f9cf05a917f 100644 --- a/common/src/main/java/org/tron/core/config/args/NodeConfig.java +++ b/common/src/main/java/org/tron/core/config/args/NodeConfig.java @@ -35,6 +35,7 @@ public class NodeConfig { private boolean openPrintLog = true; private boolean openTransactionSort = false; private int maxTps = 1000; + private int maxBlockInvPerSecond = 10; // Config key "isOpenFullTcpDisconnect" cannot auto-bind — read manually in fromConfig() @Getter(lombok.AccessLevel.NONE) @Setter(lombok.AccessLevel.NONE) @@ -452,6 +453,11 @@ private void postProcess() { inactiveThreshold = 1; } + // maxBlockInvPerSecond: minimum 1 + if (maxBlockInvPerSecond < 1) { + maxBlockInvPerSecond = 1; + } + // maxFastForwardNum: clamp to [1, MAX_ACTIVE_WITNESS_NUM] if (maxFastForwardNum > MAX_ACTIVE_WITNESS_NUM) { maxFastForwardNum = MAX_ACTIVE_WITNESS_NUM; diff --git a/common/src/main/java/org/tron/core/vm/config/VMConfig.java b/common/src/main/java/org/tron/core/vm/config/VMConfig.java index 1a7f0c058a4..94c1e50284e 100644 --- a/common/src/main/java/org/tron/core/vm/config/VMConfig.java +++ b/common/src/main/java/org/tron/core/vm/config/VMConfig.java @@ -63,6 +63,8 @@ public class VMConfig { private static boolean ALLOW_TVM_OSAKA = false; + private static boolean ALLOW_HARDEN_RESOURCE_CALCULATION = false; + private VMConfig() { } @@ -178,6 +180,10 @@ public static void initAllowTvmOsaka(long allow) { ALLOW_TVM_OSAKA = allow == 1; } + public static void initAllowHardenResourceCalculation(long allow) { + ALLOW_HARDEN_RESOURCE_CALCULATION = allow == 1; + } + public static boolean getEnergyLimitHardFork() { return CommonParameter.ENERGY_LIMIT_HARD_FORK; } @@ -281,4 +287,8 @@ public static boolean allowTvmSelfdestructRestriction() { public static boolean allowTvmOsaka() { return ALLOW_TVM_OSAKA; } + + public static boolean allowHardenResourceCalculation() { + return ALLOW_HARDEN_RESOURCE_CALCULATION; + } } diff --git a/common/src/main/resources/reference.conf b/common/src/main/resources/reference.conf index 11970a0a673..07f2114d061 100644 --- a/common/src/main/resources/reference.conf +++ b/common/src/main/resources/reference.conf @@ -227,6 +227,8 @@ node { # Threshold for broadcast transactions received from each peer per second, # transactions exceeding this are discarded maxTps = 1000 + # Max block inv hashes accepted per peer per second. Minimum: 1. + maxBlockInvPerSecond = 10 isOpenFullTcpDisconnect = false inactiveThreshold = 600 // seconds diff --git a/framework/build.gradle b/framework/build.gradle index d884b6a7c49..1aa266da3cd 100644 --- a/framework/build.gradle +++ b/framework/build.gradle @@ -42,8 +42,8 @@ dependencies { implementation group: 'io.dropwizard.metrics', name: 'metrics-core', version: '3.1.2' implementation group: 'com.github.davidb', name: 'metrics-influxdb', version: '0.8.2' // http - implementation 'org.eclipse.jetty:jetty-server:9.4.57.v20241219' - implementation 'org.eclipse.jetty:jetty-servlet:9.4.57.v20241219' + implementation 'org.eclipse.jetty:jetty-server:9.4.58.v20250814' + implementation 'org.eclipse.jetty:jetty-servlet:9.4.58.v20250814' implementation 'com.alibaba:fastjson:1.2.83' // end http @@ -53,7 +53,7 @@ dependencies { // https://mvnrepository.com/artifact/javax.portlet/portlet-api compileOnly group: 'javax.portlet', name: 'portlet-api', version: '3.0.1' - implementation (group: 'org.pf4j', name: 'pf4j', version: '3.10.0') { + implementation (group: 'org.pf4j', name: 'pf4j', version: '3.14.1') { exclude group: "org.slf4j", module: "slf4j-api" } diff --git a/framework/src/main/java/org/tron/core/Wallet.java b/framework/src/main/java/org/tron/core/Wallet.java index efbceda1b16..2c35fbd6447 100755 --- a/framework/src/main/java/org/tron/core/Wallet.java +++ b/framework/src/main/java/org/tron/core/Wallet.java @@ -1481,6 +1481,11 @@ public Protocol.ChainParameters getChainParameters() { .setValue(dbManager.getDynamicPropertiesStore().getAllowTvmOsaka()) .build()); + builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder() + .setKey("getAllowHardenResourceCalculation") + .setValue(dbManager.getDynamicPropertiesStore().getAllowHardenResourceCalculation()) + .build()); + return builder.build(); } 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 index f91c6a437ac..62786b23927 100644 --- a/framework/src/main/java/org/tron/core/config/args/Args.java +++ b/framework/src/main/java/org/tron/core/config/args/Args.java @@ -615,6 +615,7 @@ private static void applyNodeConfig(NodeConfig nc) { PARAMETER.minActiveConnections = nc.getMinActiveConnections(); PARAMETER.maxConnectionsWithSameIp = nc.getMaxConnectionsWithSameIp(); PARAMETER.maxTps = nc.getMaxTps(); + PARAMETER.maxBlockInvPerSecond = nc.getMaxBlockInvPerSecond(); PARAMETER.minParticipationRate = nc.getMinParticipationRate(); PARAMETER.nodeListenPort = nc.getListenPort(); PARAMETER.nodeEnableIpv6 = nc.isEnableIpv6(); diff --git a/framework/src/main/java/org/tron/core/consensus/ProposalService.java b/framework/src/main/java/org/tron/core/consensus/ProposalService.java index 1bec0c2bda3..54e0c6fa362 100644 --- a/framework/src/main/java/org/tron/core/consensus/ProposalService.java +++ b/framework/src/main/java/org/tron/core/consensus/ProposalService.java @@ -396,6 +396,11 @@ public static boolean process(Manager manager, ProposalCapsule proposalCapsule) manager.getDynamicPropertiesStore().saveAllowTvmOsaka(entry.getValue()); break; } + case ALLOW_HARDEN_RESOURCE_CALCULATION: { + manager.getDynamicPropertiesStore() + .saveAllowHardenResourceCalculation(entry.getValue()); + break; + } default: find = false; break; diff --git a/framework/src/main/java/org/tron/core/net/P2pEventHandlerImpl.java b/framework/src/main/java/org/tron/core/net/P2pEventHandlerImpl.java index 9cfa5058e8c..b9173b95cde 100644 --- a/framework/src/main/java/org/tron/core/net/P2pEventHandlerImpl.java +++ b/framework/src/main/java/org/tron/core/net/P2pEventHandlerImpl.java @@ -36,6 +36,7 @@ import org.tron.core.net.service.effective.EffectiveCheckService; import org.tron.core.net.service.handshake.HandshakeService; import org.tron.core.net.service.keepalive.KeepAliveService; +import org.tron.core.net.service.statistics.MessageStatistics; import org.tron.p2p.P2pEventHandler; import org.tron.p2p.connection.Channel; import org.tron.protos.Protocol; @@ -91,6 +92,7 @@ public class P2pEventHandlerImpl extends P2pEventHandler { private byte MESSAGE_MAX_TYPE = 127; private int maxCountIn10s = Args.getInstance().getMaxTps() * 10; + private int maxBlockInvIn10s = Args.getInstance().getMaxBlockInvPerSecond() * 10; public P2pEventHandlerImpl() { Set set = new HashSet<>(); @@ -149,19 +151,8 @@ private void processMessage(PeerConnection peer, byte[] data) { msg = TronMessageFactory.create(data); type = msg.getType(); - if (INVENTORY.equals(type)) { - InventoryMessage message = (InventoryMessage) msg; - Protocol.Inventory.InventoryType inventoryType = message.getInventoryType(); - int count = peer.getPeerStatistics().messageStatistics.tronInTrxInventoryElement - .getCount(10); - if (inventoryType.equals(Protocol.Inventory.InventoryType.TRX) && count > maxCountIn10s) { - logger.warn("Drop inventory from Peer {}, cur:{}, max:{}", - peer.getInetAddress(), count, maxCountIn10s); - if (Args.getInstance().isOpenPrintLog()) { - logger.warn("[overload]Drop tx list is: {}", ((InventoryMessage) msg).getHashList()); - } - return; - } + if (INVENTORY.equals(type) && !checkInvRateLimit(peer, (InventoryMessage) msg)) { + return; } peer.getPeerStatistics().messageStatistics.addTcpInMessage(msg); @@ -224,6 +215,32 @@ private void processMessage(PeerConnection peer, byte[] data) { } } + private boolean checkInvRateLimit(PeerConnection peer, InventoryMessage msg) { + InventoryType invType = msg.getInventoryType(); + int currentSize = msg.getInventory().getIdsCount(); + MessageStatistics stats = peer.getPeerStatistics().messageStatistics; + + if (invType == InventoryType.TRX) { + int count = stats.tronInTrxInventoryElement.getCount(10); + if (count + currentSize > maxCountIn10s) { + logger.warn("Drop TRX inv from {}, window:{}, cur:{}, max:{}", + peer.getInetAddress(), count, currentSize, maxCountIn10s); + if (Args.getInstance().isOpenPrintLog()) { + logger.warn("[overload] Drop tx list: {}", msg.getHashList()); + } + return false; + } + } else if (invType == InventoryType.BLOCK) { + int count = stats.tronInBlockInventoryElement.getCount(10); + if (count + currentSize > maxBlockInvIn10s) { + logger.warn("Drop BLOCK inv from {}, window:{}, cur:{}, max:{}", + peer.getInetAddress(), count, currentSize, maxBlockInvIn10s); + return false; + } + } + return true; + } + private void updateLastInteractiveTime(PeerConnection peer, TronMessage msg) { MessageTypes type = msg.getType(); diff --git a/framework/src/main/java/org/tron/core/services/jsonrpc/JsonRpcApiUtil.java b/framework/src/main/java/org/tron/core/services/jsonrpc/JsonRpcApiUtil.java index 08c1068e3a2..70673d2148a 100644 --- a/framework/src/main/java/org/tron/core/services/jsonrpc/JsonRpcApiUtil.java +++ b/framework/src/main/java/org/tron/core/services/jsonrpc/JsonRpcApiUtil.java @@ -442,6 +442,50 @@ public static boolean paramQuantityIsNull(String quantity) { return StringUtils.isEmpty(quantity) || quantity.equals("0x0"); } + /** + * Validation mode for {@link #requireValidHex}. + */ + public enum HexMode { + /** + * Execution-apis BYTES schema: requires {@code 0x} prefix and + * even total length; {@code ""} is accepted as empty bytes per + * geth's {@code hexutil.Bytes.UnmarshalText}. + */ + STRICT, + /** + * {@link ByteArray#fromHexString}'s lenient parsing: accepts bare + * hex and odd-length input. Kept for backward compatibility. + */ + LENIENT + } + + /** + * Throws if {@code value} is not parseable hex under the given + * {@code mode}. {@code null} is treated as absent and returns + * silently. {@code fieldName} is used only in error messages. + */ + public static void requireValidHex(String fieldName, String value, HexMode mode) + throws JsonRpcInvalidParamsException { + if (value == null) { + return; + } + if (mode == HexMode.STRICT) { + if (value.isEmpty()) { + return; + } + if (!value.startsWith("0x") || value.length() % 2 != 0) { + throw new JsonRpcInvalidParamsException( + "invalid hex string for \"" + fieldName + "\""); + } + } + try { + ByteArray.fromHexString(value); + } catch (Exception e) { + throw new JsonRpcInvalidParamsException( + "invalid hex string for \"" + fieldName + "\""); + } + } + public static long parseQuantityValue(String value) throws JsonRpcInvalidParamsException { long callValue = 0L; diff --git a/framework/src/main/java/org/tron/core/services/jsonrpc/TronJsonRpcImpl.java b/framework/src/main/java/org/tron/core/services/jsonrpc/TronJsonRpcImpl.java index 72fc579aa56..ea8f15cd088 100644 --- a/framework/src/main/java/org/tron/core/services/jsonrpc/TronJsonRpcImpl.java +++ b/framework/src/main/java/org/tron/core/services/jsonrpc/TronJsonRpcImpl.java @@ -645,7 +645,7 @@ public String estimateGas(CallArguments args) throws JsonRpcInvalidRequestExcept estimateEnergy(ownerAddress, contractAddress, args.parseValue(), - ByteArray.fromHexString(args.getData()), + ByteArray.fromHexString(args.resolveData()), trxExtBuilder, retBuilder, estimateBuilder); @@ -653,7 +653,7 @@ public String estimateGas(CallArguments args) throws JsonRpcInvalidRequestExcept callTriggerConstantContract(ownerAddress, contractAddress, args.parseValue(), - ByteArray.fromHexString(args.getData()), + ByteArray.fromHexString(args.resolveData()), trxExtBuilder, retBuilder); } @@ -1007,7 +1007,7 @@ public String getCall(CallArguments transactionCall, Object blockParamObj) byte[] contractAddressData = addressCompatibleToByteArray(transactionCall.getTo()); return call(addressData, contractAddressData, transactionCall.parseValue(), - ByteArray.fromHexString(transactionCall.getData())); + ByteArray.fromHexString(transactionCall.resolveData())); } @Override @@ -1114,7 +1114,8 @@ private TransactionJson buildCreateSmartContractTransaction(byte[] ownerAddress, smartBuilder.setOriginAddress(ByteString.copyFrom(ownerAddress)); // bytecode + parameter - smartBuilder.setBytecode(ByteString.copyFrom(ByteArray.fromHexString(args.getData()))); + smartBuilder.setBytecode( + ByteString.copyFrom(ByteArray.fromHexString(args.resolveData()))); if (StringUtils.isNotEmpty(args.getName())) { smartBuilder.setName(args.getName()); @@ -1159,8 +1160,9 @@ private TransactionJson buildTriggerSmartContractTransaction(byte[] ownerAddress build.setOwnerAddress(ByteString.copyFrom(ownerAddress)) .setContractAddress(ByteString.copyFrom(contractAddress)); - if (StringUtils.isNotEmpty(args.getData())) { - build.setData(ByteString.copyFrom(ByteArray.fromHexString(args.getData()))); + String callData = args.resolveData(); + if (StringUtils.isNotEmpty(callData)) { + build.setData(ByteString.copyFrom(ByteArray.fromHexString(callData))); } else { build.setData(ByteString.copyFrom(new byte[0])); } diff --git a/framework/src/main/java/org/tron/core/services/jsonrpc/types/BuildArguments.java b/framework/src/main/java/org/tron/core/services/jsonrpc/types/BuildArguments.java index 490219a13d9..ef4e958ae44 100644 --- a/framework/src/main/java/org/tron/core/services/jsonrpc/types/BuildArguments.java +++ b/framework/src/main/java/org/tron/core/services/jsonrpc/types/BuildArguments.java @@ -4,8 +4,10 @@ import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.paramQuantityIsNull; import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.paramStringIsNull; import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.parseQuantityValue; +import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.requireValidHex; import com.google.protobuf.ByteString; +import java.util.Arrays; import lombok.AllArgsConstructor; import lombok.Getter; import lombok.NoArgsConstructor; @@ -13,9 +15,11 @@ import lombok.ToString; import org.apache.commons.lang3.StringUtils; import org.tron.api.GrpcAPI.BytesMessage; +import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; import org.tron.core.exception.jsonrpc.JsonRpcInvalidParamsException; import org.tron.core.exception.jsonrpc.JsonRpcInvalidRequestException; +import org.tron.core.services.jsonrpc.JsonRpcApiUtil.HexMode; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.SmartContractOuterClass.SmartContract; @@ -24,6 +28,16 @@ @ToString public class BuildArguments { + /** + * Conflict error message wording. Mirrors go-ethereum's + * {@code setDefaults} verbatim — external EVM tooling may + * pattern-match this string. Do not change the wording without + * coordinating with downstream consumers. + */ + private static final String CONFLICT_ERR_MSG = + "both \"data\" and \"input\" are set and not equal. " + + "Please use \"input\" to pass transaction call data"; + @Getter @Setter private String from; @@ -44,6 +58,9 @@ public class BuildArguments { private String data; @Getter @Setter + private String input; + @Getter + @Setter private String nonce = ""; //not used @Getter @@ -83,16 +100,50 @@ public BuildArguments(CallArguments args) { gasPrice = args.getGasPrice(); value = args.getValue(); data = args.getData(); + input = args.getInput(); + } + + /** + * Returns {@code input} if non-null, else {@code data}. Pure + * precedence resolution, mirroring go-ethereum's + * {@code TransactionArgs.data()}. + * + *

Both fields are first validated by + * {@link org.tron.core.services.jsonrpc.JsonRpcApiUtil#requireValidHex} + * — strict for {@code input}, lenient for {@code data} (see that + * method for the rules). + * + *

Conflict between {@code input} and {@code data} is not checked + * here. Build-path callers must route through + * {@link #getContractType(Wallet)} for the geth-equivalent + * {@code setDefaults} enforcement. + * + *

Java callers using positional constructors should pass + * {@code null} (not {@code ""}) for unset {@code input}. + * + *

Verb-prefix name (not {@code getXxx}) keeps Jackson and + * FastJSON's JavaBean introspection from invoking it during + * serialisation; two regression tests per DTO pin this invariant. + */ + public String resolveData() throws JsonRpcInvalidParamsException { + requireValidHex("input", input, HexMode.STRICT); + requireValidHex("data", data, HexMode.LENIENT); + return input != null ? input : data; } public ContractType getContractType(Wallet wallet) throws JsonRpcInvalidRequestException, JsonRpcInvalidParamsException { + // Fail fast on bad hex / conflict before the state lookup; + // calldataEquals relies on resolveData() having validated hex first. + String resolvedData = resolveData(); + validateCallDataConflict(); + ContractType contractType; // to is null if (paramStringIsNull(to)) { // data is null - if (paramStringIsNull(data)) { + if (paramStringIsNull(resolvedData)) { throw new JsonRpcInvalidRequestException("invalid json request"); } @@ -136,4 +187,22 @@ private boolean availableTransferAsset() { return tokenId > 0 && tokenValue > 0 && paramQuantityIsNull(value); } + /** + * Throws when both fields decode to non-equal bytes. Wording matches + * geth's setDefaults so existing tooling can detect the error string. + */ + private void validateCallDataConflict() throws JsonRpcInvalidParamsException { + if (input != null && data != null && !calldataEquals(input, data)) { + throw new JsonRpcInvalidParamsException(CONFLICT_ERR_MSG); + } + } + + /** + * Byte-level equality, so {@code "0xDEAD"} equals {@code "0xdead"}. Both + * args must have passed {@code requireValidHex} first. + */ + private static boolean calldataEquals(String a, String b) { + return Arrays.equals(ByteArray.fromHexString(a), ByteArray.fromHexString(b)); + } + } \ No newline at end of file diff --git a/framework/src/main/java/org/tron/core/services/jsonrpc/types/CallArguments.java b/framework/src/main/java/org/tron/core/services/jsonrpc/types/CallArguments.java index 70edd1ad94f..1715636a2a4 100644 --- a/framework/src/main/java/org/tron/core/services/jsonrpc/types/CallArguments.java +++ b/framework/src/main/java/org/tron/core/services/jsonrpc/types/CallArguments.java @@ -3,6 +3,7 @@ import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.addressCompatibleToByteArray; import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.paramStringIsNull; import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.parseQuantityValue; +import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.requireValidHex; import com.google.protobuf.ByteString; import lombok.AllArgsConstructor; @@ -15,6 +16,7 @@ import org.tron.core.Wallet; import org.tron.core.exception.jsonrpc.JsonRpcInvalidParamsException; import org.tron.core.exception.jsonrpc.JsonRpcInvalidRequestException; +import org.tron.core.services.jsonrpc.JsonRpcApiUtil.HexMode; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.SmartContractOuterClass.SmartContract; @@ -43,21 +45,41 @@ public class CallArguments { private String data; @Getter @Setter + private String input; + @Getter + @Setter private String nonce; // not used + /** + * Returns {@code input} if non-null, else {@code data}. Pure + * precedence resolution, mirroring go-ethereum's + * {@code TransactionArgs.data()}; no conflict check on the query + * path (matches geth's {@code ToMessage}). See + * {@link BuildArguments#resolveData()} for the rationale on + * naming, validation split, and serialiser interaction. + */ + public String resolveData() throws JsonRpcInvalidParamsException { + requireValidHex("input", input, HexMode.STRICT); + requireValidHex("data", data, HexMode.LENIENT); + return input != null ? input : data; + } + /** * just support TransferContract, CreateSmartContract and TriggerSmartContract * */ public ContractType getContractType(Wallet wallet) throws JsonRpcInvalidRequestException, JsonRpcInvalidParamsException { - ContractType contractType; - // from or to is null if (paramStringIsNull(from)) { throw new JsonRpcInvalidRequestException("invalid json request"); - } else if (paramStringIsNull(to)) { + } + // Fail fast on bad hex before the state lookup. + String resolvedData = resolveData(); + + ContractType contractType; + if (paramStringIsNull(to)) { // data is null - if (paramStringIsNull(data)) { + if (paramStringIsNull(resolvedData)) { throw new JsonRpcInvalidRequestException("invalid json request"); } diff --git a/framework/src/test/java/org/tron/core/actuator/utils/ProposalUtilTest.java b/framework/src/test/java/org/tron/core/actuator/utils/ProposalUtilTest.java index c26da5a7bf7..2a9de1ea3b1 100644 --- a/framework/src/test/java/org/tron/core/actuator/utils/ProposalUtilTest.java +++ b/framework/src/test/java/org/tron/core/actuator/utils/ProposalUtilTest.java @@ -343,6 +343,8 @@ public void validateCheck() { testAllowTvmSelfdestructRestrictionProposal(); + testAllowHardenResourceCalculationProposal(); + forkUtils.getManager().getDynamicPropertiesStore() .statsByVersion(ForkBlockVersionEnum.ENERGY_LIMIT.getValue(), stats); forkUtils.reset(); @@ -569,6 +571,48 @@ private void testAllowTvmSelfdestructRestrictionProposal() { e3.getMessage()); } + private void testAllowHardenResourceCalculationProposal() { + byte[] stats = new byte[27]; + forkUtils.getManager().getDynamicPropertiesStore() + .statsByVersion(ForkBlockVersionEnum.VERSION_4_8_1.getValue(), stats); + ContractValidateException e1 = Assert.assertThrows(ContractValidateException.class, + () -> ProposalUtil.validator(dynamicPropertiesStore, forkUtils, + ProposalType.ALLOW_HARDEN_RESOURCE_CALCULATION.getCode(), 1)); + Assert.assertEquals( + "Bad chain parameter id [ALLOW_HARDEN_RESOURCE_CALCULATION]", + e1.getMessage()); + + long maintenanceTimeInterval = forkUtils.getManager().getDynamicPropertiesStore() + .getMaintenanceTimeInterval(); + + long hardForkTime = + ((ForkBlockVersionEnum.VERSION_4_8_2.getHardForkTime() - 1) / maintenanceTimeInterval + 1) + * maintenanceTimeInterval; + forkUtils.getManager().getDynamicPropertiesStore() + .saveLatestBlockHeaderTimestamp(hardForkTime + 1); + + stats = new byte[27]; + Arrays.fill(stats, (byte) 1); + forkUtils.getManager().getDynamicPropertiesStore() + .statsByVersion(ForkBlockVersionEnum.VERSION_4_8_2.getValue(), stats); + + // Should fail because the proposal value is invalid + ContractValidateException e2 = Assert.assertThrows(ContractValidateException.class, + () -> ProposalUtil.validator(dynamicPropertiesStore, forkUtils, + ProposalType.ALLOW_HARDEN_RESOURCE_CALCULATION.getCode(), 2)); + Assert.assertEquals( + "This value[ALLOW_HARDEN_RESOURCE_CALCULATION] is only allowed to be 1", + e2.getMessage()); + + dynamicPropertiesStore.saveAllowHardenResourceCalculation(1); + ContractValidateException e3 = Assert.assertThrows(ContractValidateException.class, + () -> ProposalUtil.validator(dynamicPropertiesStore, forkUtils, + ProposalType.ALLOW_HARDEN_RESOURCE_CALCULATION.getCode(), 1)); + Assert.assertEquals( + "[ALLOW_HARDEN_RESOURCE_CALCULATION] has been valid, no need to propose again", + e3.getMessage()); + } + private void testAllowMarketTransaction() { ThrowingRunnable off = () -> ProposalUtil.validator(dynamicPropertiesStore, forkUtils, ProposalType.ALLOW_MARKET_TRANSACTION.getCode(), 0); diff --git a/framework/src/test/java/org/tron/core/db/CalculateGlobalLimitHardenTest.java b/framework/src/test/java/org/tron/core/db/CalculateGlobalLimitHardenTest.java new file mode 100644 index 00000000000..1df362fff42 --- /dev/null +++ b/framework/src/test/java/org/tron/core/db/CalculateGlobalLimitHardenTest.java @@ -0,0 +1,346 @@ +package org.tron.core.db; + +import com.google.protobuf.ByteString; +import java.math.BigInteger; +import lombok.extern.slf4j.Slf4j; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.tron.common.BaseTest; +import org.tron.common.TestConstants; +import org.tron.common.utils.ByteArray; +import org.tron.core.Wallet; +import org.tron.core.capsule.AccountCapsule; +import org.tron.core.config.args.Args; +import org.tron.protos.Protocol.AccountType; + +@Slf4j +public class CalculateGlobalLimitHardenTest extends BaseTest { + + private static final String OWNER_ADDRESS; + + static { + Args.setParam(new String[]{"--output-directory", dbPath()}, TestConstants.TEST_CONF); + OWNER_ADDRESS = Wallet.getAddressPreFixString() + "548794500882809695a8a687866e76d4271a1abc"; + } + + private EnergyProcessor energyProcessor; + private BandwidthProcessor bandwidthProcessor; + private AccountCapsule ownerCapsule; + + @Before + public void setUp() { + ownerCapsule = new AccountCapsule( + ByteString.copyFromUtf8("owner"), + ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS)), + AccountType.Normal, 0L); + dbManager.getAccountStore().put(ownerCapsule.getAddress().toByteArray(), ownerCapsule); + + energyProcessor = new EnergyProcessor( + dbManager.getDynamicPropertiesStore(), dbManager.getAccountStore()); + bandwidthProcessor = new BandwidthProcessor(dbManager.getChainBaseManager()); + } + + @After + public void tearDown() { + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(0); + dbManager.getDynamicPropertiesStore().saveUnfreezeDelayDays(0); + } + + @Test + public void testGlobalEnergyLimitParity() { + dbManager.getDynamicPropertiesStore().saveTotalEnergyCurrentLimit(50_000_000_000L); + dbManager.getDynamicPropertiesStore().saveTotalEnergyWeight(2_000_000_000L); + ownerCapsule.setFrozenForEnergy(10_000_000_000L, 0L); + dbManager.getAccountStore().put(ownerCapsule.getAddress().toByteArray(), ownerCapsule); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(0); + long resultOld = energyProcessor.calculateGlobalEnergyLimit(ownerCapsule); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + long resultNew = energyProcessor.calculateGlobalEnergyLimit(ownerCapsule); + + Assert.assertEquals(resultOld, resultNew); + } + + @Test + public void testGlobalEnergyLimitOverflowDetectedWithHardening() { + dbManager.getDynamicPropertiesStore().saveTotalEnergyCurrentLimit(Long.MAX_VALUE / 2); + dbManager.getDynamicPropertiesStore().saveTotalEnergyWeight(1L); + ownerCapsule.setFrozenForEnergy(Long.MAX_VALUE / 4, 0L); + dbManager.getAccountStore().put(ownerCapsule.getAddress().toByteArray(), ownerCapsule); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + + Assert.assertThrows(ArithmeticException.class, + () -> energyProcessor.calculateGlobalEnergyLimit(ownerCapsule)); + } + + @Test + public void testGlobalEnergyLimitV2Parity() { + dbManager.getDynamicPropertiesStore().saveTotalEnergyCurrentLimit(50_000_000_000L); + dbManager.getDynamicPropertiesStore().saveTotalEnergyWeight(2_000_000_000L); + long frozeBalance = 10_000_000_000L; + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(0); + long resultOld = energyProcessor.calculateGlobalEnergyLimitV2(frozeBalance); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + long resultNew = energyProcessor.calculateGlobalEnergyLimitV2(frozeBalance); + + Assert.assertEquals(resultOld, resultNew); + } + + @Test + public void testGlobalEnergyLimitV2CorrectVsDoublePrecisionLoss() { + long totalEnergyLimit = 50_000_000_000L; + long totalEnergyWeight = 1_234_567L; + long frozeBalance = 9_876_543_210_000_000L; // ~9.8e15 + + dbManager.getDynamicPropertiesStore().saveTotalEnergyCurrentLimit(totalEnergyLimit); + dbManager.getDynamicPropertiesStore().saveTotalEnergyWeight(totalEnergyWeight); + + BigInteger expected = BigInteger.valueOf(frozeBalance) + .multiply(BigInteger.valueOf(totalEnergyLimit)) + .divide(BigInteger.valueOf(1_000_000L) + .multiply(BigInteger.valueOf(totalEnergyWeight))); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + long actual = energyProcessor.calculateGlobalEnergyLimitV2(frozeBalance); + Assert.assertEquals(expected.longValueExact(), actual); + } + + @Test + public void testGlobalNetLimitParity() { + dbManager.getDynamicPropertiesStore().saveTotalNetLimit(43_200_000_000L); + dbManager.getDynamicPropertiesStore().saveTotalNetWeight(2_000_000_000L); + ownerCapsule.setFrozenForBandwidth(10_000_000_000L, 0L); + dbManager.getAccountStore().put(ownerCapsule.getAddress().toByteArray(), ownerCapsule); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(0); + long resultOld = bandwidthProcessor.calculateGlobalNetLimit(ownerCapsule); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + long resultNew = bandwidthProcessor.calculateGlobalNetLimit(ownerCapsule); + + Assert.assertEquals(resultOld, resultNew); + } + + @Test + public void testGlobalNetLimitOverflowDetectedWithHardening() { + dbManager.getDynamicPropertiesStore().saveTotalNetLimit(Long.MAX_VALUE / 2); + dbManager.getDynamicPropertiesStore().saveTotalNetWeight(1L); + ownerCapsule.setFrozenForBandwidth(Long.MAX_VALUE / 4, 0L); + dbManager.getAccountStore().put(ownerCapsule.getAddress().toByteArray(), ownerCapsule); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + + Assert.assertThrows(ArithmeticException.class, + () -> bandwidthProcessor.calculateGlobalNetLimit(ownerCapsule)); + } + + + @Test + public void testGlobalNetLimitV2Parity() { + dbManager.getDynamicPropertiesStore().saveTotalNetLimit(43_200_000_000L); + dbManager.getDynamicPropertiesStore().saveTotalNetWeight(2_000_000_000L); + long frozeBalance = 10_000_000_000L; + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(0); + long resultOld = bandwidthProcessor.calculateGlobalNetLimitV2(frozeBalance); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + long resultNew = bandwidthProcessor.calculateGlobalNetLimitV2(frozeBalance); + + Assert.assertEquals(resultOld, resultNew); + } + + @Test + public void testGlobalNetLimitV2ExactPrecision() { + long totalNetLimit = 43_200_000_000L; + long totalNetWeight = 1_234_567L; + long frozeBalance = 9_876_543_210_000_000L; + + dbManager.getDynamicPropertiesStore().saveTotalNetLimit(totalNetLimit); + dbManager.getDynamicPropertiesStore().saveTotalNetWeight(totalNetWeight); + + BigInteger expected = BigInteger.valueOf(frozeBalance) + .multiply(BigInteger.valueOf(totalNetLimit)) + .divide(BigInteger.valueOf(1_000_000L) + .multiply(BigInteger.valueOf(totalNetWeight))); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + long actual = bandwidthProcessor.calculateGlobalNetLimitV2(frozeBalance); + Assert.assertEquals(expected.longValueExact(), actual); + } + + @Test + public void testGlobalEnergyLimitV2BelowTrxPrecisionMatchesDouble() { + long totalEnergyLimit = 50_000_000_000L; + long totalEnergyWeight = 2_000_000_000L; + long frozeBalance = 500_000L; // < TRX_PRECISION (1_000_000) + + dbManager.getDynamicPropertiesStore().saveTotalEnergyCurrentLimit(totalEnergyLimit); + dbManager.getDynamicPropertiesStore().saveTotalEnergyWeight(totalEnergyWeight); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(0); + long resultOld = energyProcessor.calculateGlobalEnergyLimitV2(frozeBalance); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + long resultNew = energyProcessor.calculateGlobalEnergyLimitV2(frozeBalance); + + Assert.assertEquals(12L, resultNew); + Assert.assertEquals(resultOld, resultNew); + } + + @Test + public void testGlobalNetLimitV2BelowTrxPrecisionMatchesDouble() { + long totalNetLimit = 43_200_000_000L; + long totalNetWeight = 2_000_000_000L; + long frozeBalance = 500_000L; // < TRX_PRECISION + + dbManager.getDynamicPropertiesStore().saveTotalNetLimit(totalNetLimit); + dbManager.getDynamicPropertiesStore().saveTotalNetWeight(totalNetWeight); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(0); + long resultOld = bandwidthProcessor.calculateGlobalNetLimitV2(frozeBalance); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + long resultNew = bandwidthProcessor.calculateGlobalNetLimitV2(frozeBalance); + + Assert.assertEquals(resultOld, resultNew); + Assert.assertTrue("non-zero proportional result expected", resultNew > 0); + } + + @Test + public void testGlobalEnergyLimitV1NonIntegerRatioParity() { + dbManager.getDynamicPropertiesStore().saveUnfreezeDelayDays(0); // force V1 path + long totalEnergyLimit = 50_000_000_000L; + long totalEnergyWeight = 1_234_567L; // not an exact divisor of totalEnergyLimit + dbManager.getDynamicPropertiesStore().saveTotalEnergyCurrentLimit(totalEnergyLimit); + dbManager.getDynamicPropertiesStore().saveTotalEnergyWeight(totalEnergyWeight); + ownerCapsule.setFrozenForEnergy(10_000_000_000L, 0L); + dbManager.getAccountStore().put(ownerCapsule.getAddress().toByteArray(), ownerCapsule); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(0); + long resultOld = energyProcessor.calculateGlobalEnergyLimit(ownerCapsule); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + long resultNew = energyProcessor.calculateGlobalEnergyLimit(ownerCapsule); + + Assert.assertEquals(resultOld, resultNew); + } + + @Test + public void testV1FlooredWeightVsV2FractionalWeight() { + dbManager.getDynamicPropertiesStore().saveTotalEnergyCurrentLimit(50_000_000_000L); + dbManager.getDynamicPropertiesStore().saveTotalEnergyWeight(2_000_000_000L); + long frozeBalance = 1_500_000L; // 1.5 x TRX_PRECISION + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + + // V1 path + dbManager.getDynamicPropertiesStore().saveUnfreezeDelayDays(0); + ownerCapsule.setFrozenForEnergy(frozeBalance, 0L); + dbManager.getAccountStore().put(ownerCapsule.getAddress().toByteArray(), ownerCapsule); + long v1New = energyProcessor.calculateGlobalEnergyLimit(ownerCapsule); + + // Legacy V1 expectation: floor(1.5) * 25.0 = 1 * 25 = 25 + Assert.assertEquals(25L, v1New); + + // V2 path with the same balance keeps the fractional weight + long v2New = energyProcessor.calculateGlobalEnergyLimitV2(frozeBalance); + // Legacy V2 expectation: 1.5 * 25.0 = 37.5 -> 37 + Assert.assertEquals(37L, v2New); + + // And both must match their respective legacy doubles + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(0); + long v1Old = energyProcessor.calculateGlobalEnergyLimit(ownerCapsule); + long v2Old = energyProcessor.calculateGlobalEnergyLimitV2(frozeBalance); + Assert.assertEquals(v1Old, v1New); + Assert.assertEquals(v2Old, v2New); + } + + @Test + public void testGlobalNetLimitV1UsesTotalNetWeightNotLimit() { + dbManager.getDynamicPropertiesStore().saveUnfreezeDelayDays(0); // force V1 path + long totalNetLimit = 43_200_000_000L; + long totalNetWeight = 2_000_000_000L; // distinct from totalNetLimit + dbManager.getDynamicPropertiesStore().saveTotalNetLimit(totalNetLimit); + dbManager.getDynamicPropertiesStore().saveTotalNetWeight(totalNetWeight); + long frozeBalance = 10_000_000_000L; + ownerCapsule.setFrozenForBandwidth(frozeBalance, 0L); + dbManager.getAccountStore().put(ownerCapsule.getAddress().toByteArray(), ownerCapsule); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + long actual = bandwidthProcessor.calculateGlobalNetLimit(ownerCapsule); + + Assert.assertEquals(216_000L, actual); + Assert.assertNotEquals(10_000L, actual); + } + + @Test + public void testGlobalNetLimitV2UsesTotalNetWeightNotLimit() { + long totalNetLimit = 43_200_000_000L; + long totalNetWeight = 2_000_000_000L; + dbManager.getDynamicPropertiesStore().saveTotalNetLimit(totalNetLimit); + dbManager.getDynamicPropertiesStore().saveTotalNetWeight(totalNetWeight); + long frozeBalance = 10_000_000_000L; + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + long actual = bandwidthProcessor.calculateGlobalNetLimitV2(frozeBalance); + + Assert.assertEquals(216_000L, actual); + Assert.assertNotEquals(10_000L, actual); + } + + + @Test + public void testUpdateAdaptiveTotalEnergyLimitParity() { + dbManager.getDynamicPropertiesStore().saveTotalEnergyAverageUsage(20_000_000L); + dbManager.getDynamicPropertiesStore().saveTotalEnergyTargetLimit(10_000_000L); + dbManager.getDynamicPropertiesStore().saveTotalEnergyCurrentLimit(50_000_000_000L); + dbManager.getDynamicPropertiesStore().saveTotalEnergyLimit(50_000_000_000L); + dbManager.getDynamicPropertiesStore().saveAdaptiveResourceLimitMultiplier(1000L); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(0); + energyProcessor.updateAdaptiveTotalEnergyLimit(); + long resultOld = dbManager.getDynamicPropertiesStore().getTotalEnergyCurrentLimit(); + + dbManager.getDynamicPropertiesStore().saveTotalEnergyCurrentLimit(50_000_000_000L); + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + energyProcessor.updateAdaptiveTotalEnergyLimit(); + long resultNew = dbManager.getDynamicPropertiesStore().getTotalEnergyCurrentLimit(); + + Assert.assertEquals(resultOld, resultNew); + } + + @Test + public void testUpdateAdaptiveTotalEnergyLimitOverflowDetected() { + dbManager.getDynamicPropertiesStore().saveTotalEnergyAverageUsage(0L); + dbManager.getDynamicPropertiesStore().saveTotalEnergyTargetLimit(Long.MAX_VALUE); + dbManager.getDynamicPropertiesStore().saveTotalEnergyCurrentLimit( + 10_000_000_000_000_000L); + dbManager.getDynamicPropertiesStore().saveTotalEnergyLimit(10_000_000_000_000_000L); + dbManager.getDynamicPropertiesStore().saveAdaptiveResourceLimitMultiplier(1000L); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + + Assert.assertThrows(ArithmeticException.class, + () -> energyProcessor.updateAdaptiveTotalEnergyLimit()); + } + + @Test + public void testUpdateAdaptiveLimitMultiplierOverflowDetected() { + dbManager.getDynamicPropertiesStore().saveTotalEnergyAverageUsage(0L); + dbManager.getDynamicPropertiesStore().saveTotalEnergyTargetLimit(Long.MAX_VALUE); + dbManager.getDynamicPropertiesStore().saveTotalEnergyCurrentLimit(1_000_000L); + dbManager.getDynamicPropertiesStore().saveTotalEnergyLimit(Long.MAX_VALUE / 100); + dbManager.getDynamicPropertiesStore().saveAdaptiveResourceLimitMultiplier(1000L); + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + + Assert.assertThrows(ArithmeticException.class, + () -> energyProcessor.updateAdaptiveTotalEnergyLimit()); + } +} diff --git a/framework/src/test/java/org/tron/core/db/ResourceProcessorHardenTest.java b/framework/src/test/java/org/tron/core/db/ResourceProcessorHardenTest.java new file mode 100644 index 00000000000..ee096abd382 --- /dev/null +++ b/framework/src/test/java/org/tron/core/db/ResourceProcessorHardenTest.java @@ -0,0 +1,281 @@ +package org.tron.core.db; + +import com.google.protobuf.ByteString; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.tron.common.BaseTest; +import org.tron.common.TestConstants; +import org.tron.common.utils.ByteArray; +import org.tron.core.Wallet; +import org.tron.core.capsule.AccountCapsule; +import org.tron.core.config.args.Args; +import org.tron.protos.Protocol.AccountType; +import org.tron.protos.contract.Common; +import org.tron.protos.contract.Common.ResourceCode; + +@Slf4j +public class ResourceProcessorHardenTest extends BaseTest { + + private static final String OWNER_ADDRESS; + private static final String RECEIVER_ADDRESS; + + static { + Args.setParam(new String[]{"--output-directory", dbPath()}, TestConstants.TEST_CONF); + OWNER_ADDRESS = + Wallet.getAddressPreFixString() + "548794500882809695a8a687866e76d4271a1abc"; + RECEIVER_ADDRESS = + Wallet.getAddressPreFixString() + "abd4b9367799eaa3197fecb144eb71de1e049abc"; + } + + private EnergyProcessor processor; + private AccountCapsule ownerCapsule; + private AccountCapsule receiverCapsule; + + @Before + public void setUp() { + ownerCapsule = new AccountCapsule( + ByteString.copyFromUtf8("owner"), + ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS)), + AccountType.Normal, 10_000_000_000L); + + receiverCapsule = new AccountCapsule( + ByteString.copyFromUtf8("receiver"), + ByteString.copyFrom(ByteArray.fromHexString(RECEIVER_ADDRESS)), + AccountType.Normal, 10_000_000_000L); + + dbManager.getAccountStore().put( + ownerCapsule.getAddress().toByteArray(), ownerCapsule); + dbManager.getAccountStore().put( + receiverCapsule.getAddress().toByteArray(), receiverCapsule); + + dbManager.getDynamicPropertiesStore().saveLatestBlockHeaderTimestamp(10000L); + dbManager.getDynamicPropertiesStore().saveTotalEnergyWeight(10_000_000L); + + processor = new EnergyProcessor( + dbManager.getDynamicPropertiesStore(), dbManager.getAccountStore()); + } + + @Test + public void testIncreaseNormalValuesConsistent() { + long lastUsage = 1000L; + long usage = 500L; + long lastTime = 9990L; + long now = 9995L; + long windowSize = 28800L; // 24h in slots + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(0); + long resultOld = processor.increase(lastUsage, usage, lastTime, now, windowSize); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + long resultNew = processor.increase(lastUsage, usage, lastTime, now, windowSize); + + Assert.assertEquals(resultOld, resultNew); + } + + @Test + public void testIncreaseV2NormalValuesConsistent() { + dbManager.getDynamicPropertiesStore().saveUnfreezeDelayDays(14); + dbManager.getDynamicPropertiesStore().saveAllowCancelAllUnfreezeV2(1); + + long lastUsage = 70_000_000L; + long usage = 2345L; + long lastTime = 9999L; + long now = 10000L; + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(0); + ownerCapsule.setNewWindowSize(Common.ResourceCode.ENERGY, 28800); + ownerCapsule.setWindowOptimized(Common.ResourceCode.ENERGY, true); + ownerCapsule.setLatestConsumeTimeForEnergy(lastTime); + ownerCapsule.setEnergyUsage(lastUsage); + long resultOld = processor.increaseV2(ownerCapsule, ResourceCode.ENERGY, + lastUsage, usage, lastTime, now); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + ownerCapsule.setNewWindowSize(Common.ResourceCode.ENERGY, 28800); + ownerCapsule.setWindowOptimized(Common.ResourceCode.ENERGY, true); + ownerCapsule.setLatestConsumeTimeForEnergy(lastTime); + ownerCapsule.setEnergyUsage(lastUsage); + long resultNew = processor.increaseV2(ownerCapsule, ResourceCode.ENERGY, + lastUsage, usage, lastTime, now); + + Assert.assertEquals(resultOld, resultNew); + } + + @Test + public void testIncreaseOverflowDetectedWithHardening() { + long lastUsage = Long.MAX_VALUE / 10; // ~9.2e17 + long usage = 1L; + long lastTime = 9990L; + long now = 9995L; + long windowSize = 28800L; + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + + Assert.assertThrows(ArithmeticException.class, + () -> processor.increase(lastUsage, usage, lastTime, now, windowSize)); + } + + @Test + public void testIncreaseOverflowSilentWithoutHardening() { + long lastUsage = Long.MAX_VALUE / 10; + long usage = 1L; + long lastTime = 9990L; + long now = 9995L; + long windowSize = 28800L; + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(0); + processor.increase(lastUsage, usage, lastTime, now, windowSize); + } + + @Test + public void testIncreaseAcceptsIntermediateOverflowWhenResultFits() { + long lastUsage = Long.MAX_VALUE / 100; // ~9.2e16 + long usage = 1L; + long lastTime = 9990L; + long now = 9995L; + long windowSize = 28800L; + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + long result = processor.increase(lastUsage, usage, lastTime, now, windowSize); + Assert.assertTrue("Result should be a valid long", result >= 0); + } + + @Test + public void testIncreaseWithAccountCapsuleConsistent() { + dbManager.getDynamicPropertiesStore().saveUnfreezeDelayDays(14); + + long lastUsage = 5_000_000L; + long usage = 1_000L; + long lastTime = 9990L; + long now = 9995L; + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(0); + ownerCapsule.setNewWindowSize(ResourceCode.ENERGY, 28800); + ownerCapsule.setLatestConsumeTimeForEnergy(lastTime); + ownerCapsule.setEnergyUsage(lastUsage); + long resultOld = processor.increase(ownerCapsule, ResourceCode.ENERGY, + lastUsage, usage, lastTime, now); + long windowOld = ownerCapsule.getWindowSize(ResourceCode.ENERGY); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + ownerCapsule.setNewWindowSize(ResourceCode.ENERGY, 28800); + ownerCapsule.setLatestConsumeTimeForEnergy(lastTime); + ownerCapsule.setEnergyUsage(lastUsage); + long resultNew = processor.increase(ownerCapsule, ResourceCode.ENERGY, + lastUsage, usage, lastTime, now); + long windowNew = ownerCapsule.getWindowSize(ResourceCode.ENERGY); + + Assert.assertEquals(resultOld, resultNew); + Assert.assertEquals(windowOld, windowNew); + } + + @Test + public void testUnDelegateIncreaseV2NormalValuesConsistent() { + dbManager.getDynamicPropertiesStore().saveUnfreezeDelayDays(14); + dbManager.getDynamicPropertiesStore().saveAllowCancelAllUnfreezeV2(1); + + long transferUsage = 1000L; + long now = 10000L; + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(0); + setupForUnDelegate(now); + processor.unDelegateIncreaseV2(ownerCapsule, receiverCapsule, + transferUsage, ResourceCode.ENERGY, now); + long usageOld = ownerCapsule.getUsage(ResourceCode.ENERGY); + long windowOld = ownerCapsule.getWindowSizeV2(ResourceCode.ENERGY); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + setupForUnDelegate(now); + processor.unDelegateIncreaseV2(ownerCapsule, receiverCapsule, + transferUsage, ResourceCode.ENERGY, now); + long usageNew = ownerCapsule.getUsage(ResourceCode.ENERGY); + long windowNew = ownerCapsule.getWindowSizeV2(ResourceCode.ENERGY); + + Assert.assertEquals(usageOld, usageNew); + Assert.assertEquals(windowOld, windowNew); + } + + @Test + public void testUnDelegateIncreaseV2ConsistentWithHardening() { + dbManager.getDynamicPropertiesStore().saveUnfreezeDelayDays(14); + dbManager.getDynamicPropertiesStore().saveAllowCancelAllUnfreezeV2(1); + + long transferUsage = 5_000_000L; + long now = 10000L; + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(0); + setupForUnDelegateWithUsage(now, 2_000_000L, 3_000_000L); + processor.unDelegateIncreaseV2(ownerCapsule, receiverCapsule, + transferUsage, ResourceCode.ENERGY, now); + long usageOld = ownerCapsule.getUsage(ResourceCode.ENERGY); + long windowOld = ownerCapsule.getWindowSizeV2(ResourceCode.ENERGY); + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + setupForUnDelegateWithUsage(now, 2_000_000L, 3_000_000L); + processor.unDelegateIncreaseV2(ownerCapsule, receiverCapsule, + transferUsage, ResourceCode.ENERGY, now); + long usageNew = ownerCapsule.getUsage(ResourceCode.ENERGY); + long windowNew = ownerCapsule.getWindowSizeV2(ResourceCode.ENERGY); + + Assert.assertEquals(usageOld, usageNew); + Assert.assertEquals(windowOld, windowNew); + } + + @Test + public void testIncreaseV2OverflowDetected() { + dbManager.getDynamicPropertiesStore().saveUnfreezeDelayDays(14); + dbManager.getDynamicPropertiesStore().saveAllowCancelAllUnfreezeV2(1); + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + + long lastUsage = Long.MAX_VALUE / 10; // ~9.2e17, above threshold + long usage = 1000L; + long lastTime = 9999L; + long now = 10000L; + + ownerCapsule.setNewWindowSize(ResourceCode.ENERGY, 28800); + ownerCapsule.setWindowOptimized(ResourceCode.ENERGY, true); + ownerCapsule.setLatestConsumeTimeForEnergy(lastTime); + ownerCapsule.setEnergyUsage(lastUsage); + dbManager.getAccountStore().put( + ownerCapsule.getAddress().toByteArray(), ownerCapsule); + + Assert.assertThrows(ArithmeticException.class, + () -> processor.increaseV2(ownerCapsule, ResourceCode.ENERGY, + lastUsage, usage, lastTime, now)); + } + + @Test + public void testLargeButSafeValuesWithHardening() { + long lastUsage = 300_000_000_000L; // 300 billion + long usage = 100L; + long lastTime = 9990L; + long now = 9995L; + long windowSize = 28800L; + + dbManager.getDynamicPropertiesStore().saveAllowHardenResourceCalculation(1); + long result = processor.increase(lastUsage, usage, lastTime, now, windowSize); + Assert.assertTrue("Result should be positive", result > 0); + } + + private void setupForUnDelegate(long now) { + setupForUnDelegateWithUsage(now, 5_000_000L, 3_000_000L); + } + + private void setupForUnDelegateWithUsage(long now, long ownerUsage, long receiverUsage) { + ownerCapsule.setLatestConsumeTimeForEnergy(now); + ownerCapsule.setEnergyUsage(ownerUsage); + ownerCapsule.setNewWindowSize(ResourceCode.ENERGY, 28800); + ownerCapsule.setWindowOptimized(ResourceCode.ENERGY, true); + dbManager.getAccountStore().put( + ownerCapsule.getAddress().toByteArray(), ownerCapsule); + + receiverCapsule.setLatestConsumeTimeForEnergy(now - 100); + receiverCapsule.setEnergyUsage(receiverUsage); + receiverCapsule.setNewWindowSize(ResourceCode.ENERGY, 28800); + receiverCapsule.setWindowOptimized(ResourceCode.ENERGY, true); + dbManager.getAccountStore().put( + receiverCapsule.getAddress().toByteArray(), receiverCapsule); + } +} diff --git a/framework/src/test/java/org/tron/core/net/P2pEventHandlerImplTest.java b/framework/src/test/java/org/tron/core/net/P2pEventHandlerImplTest.java index 03c79f495ee..2e79bbf5809 100644 --- a/framework/src/test/java/org/tron/core/net/P2pEventHandlerImplTest.java +++ b/framework/src/test/java/org/tron/core/net/P2pEventHandlerImplTest.java @@ -34,6 +34,7 @@ public static void init() throws Exception { public void testProcessInventoryMessage() throws Exception { CommonParameter parameter = CommonParameter.getInstance(); parameter.setMaxTps(10); + parameter.setMaxBlockInvPerSecond(10); PeerStatistics peerStatistics = new PeerStatistics(); @@ -75,7 +76,7 @@ public void testProcessInventoryMessage() throws Exception { count = peer.getPeerStatistics().messageStatistics.tronInTrxInventoryElement.getCount(10); - Assert.assertEquals(110, count); + Assert.assertEquals(10, count); // 100 hashes dropped: 10+100=110 > maxCountIn10s(100) list.clear(); for (int i = 0; i < 100; i++) { @@ -88,7 +89,7 @@ public void testProcessInventoryMessage() throws Exception { count = peer.getPeerStatistics().messageStatistics.tronInTrxInventoryElement.getCount(10); - Assert.assertEquals(110, count); + Assert.assertEquals(10, count); // still dropped: window=10, 10+100=110 > 100 list.clear(); for (int i = 0; i < 200; i++) { @@ -101,7 +102,7 @@ public void testProcessInventoryMessage() throws Exception { count = peer.getPeerStatistics().messageStatistics.tronInBlockInventoryElement.getCount(10); - Assert.assertEquals(200, count); + Assert.assertEquals(0, count); // 200 hashes dropped: 0+200=200 > maxBlockInvIn10s(100) list.clear(); for (int i = 0; i < 100; i++) { @@ -114,10 +115,100 @@ public void testProcessInventoryMessage() throws Exception { count = peer.getPeerStatistics().messageStatistics.tronInBlockInventoryElement.getCount(10); - Assert.assertEquals(300, count); + Assert.assertEquals(100, count); // passes: window=0, 0+100=100, not > 100 } + @Test + public void testCheckInvRateLimitTrxBoundary() throws Exception { + // maxTps=10 → maxCountIn10s=100 + CommonParameter parameter = CommonParameter.getInstance(); + parameter.setMaxTps(10); + parameter.setMaxBlockInvPerSecond(10); + + PeerStatistics peerStatistics = new PeerStatistics(); + PeerConnection peer = mock(PeerConnection.class); + Mockito.when(peer.getPeerStatistics()).thenReturn(peerStatistics); + + P2pEventHandlerImpl handler = new P2pEventHandlerImpl(); + Method method = handler.getClass() + .getDeclaredMethod("processMessage", PeerConnection.class, byte[].class); + method.setAccessible(true); + + // Fill window to 91: send 91 TRX hashes → passes (0+91=91 ≤ 100) + List list91 = new ArrayList<>(); + for (int i = 0; i < 91; i++) { + list91.add(new Sha256Hash(i, new byte[32])); + } + InventoryMessage msg91 = new InventoryMessage(list91, InventoryType.TRX); + method.invoke(handler, peer, msg91.getSendBytes()); + Assert.assertEquals(91, + peer.getPeerStatistics().messageStatistics.tronInTrxInventoryElement.getCount(10)); + + // Send 9 more TRX hashes → passes (91+9=100, not > 100) + List list9 = new ArrayList<>(); + for (int i = 0; i < 9; i++) { + list9.add(new Sha256Hash(i, new byte[32])); + } + InventoryMessage msg9 = new InventoryMessage(list9, InventoryType.TRX); + method.invoke(handler, peer, msg9.getSendBytes()); + Assert.assertEquals(100, + peer.getPeerStatistics().messageStatistics.tronInTrxInventoryElement.getCount(10)); + + // Send 1 more TRX hash → DROPPED (100+1=101 > 100) + List list1 = new ArrayList<>(); + list1.add(new Sha256Hash(0, new byte[32])); + InventoryMessage msg1 = new InventoryMessage(list1, InventoryType.TRX); + method.invoke(handler, peer, msg1.getSendBytes()); + Assert.assertEquals(100, // count unchanged: message was dropped + peer.getPeerStatistics().messageStatistics.tronInTrxInventoryElement.getCount(10)); + } + + @Test + public void testCheckInvRateLimitBlockBoundary() throws Exception { + // maxBlockInvPerSecond=10 → maxBlockInvIn10s=100 + CommonParameter parameter = CommonParameter.getInstance(); + parameter.setMaxTps(1000); + parameter.setMaxBlockInvPerSecond(10); + + PeerStatistics peerStatistics = new PeerStatistics(); + PeerConnection peer = mock(PeerConnection.class); + Mockito.when(peer.getPeerStatistics()).thenReturn(peerStatistics); + + P2pEventHandlerImpl handler = new P2pEventHandlerImpl(); + Method method = handler.getClass() + .getDeclaredMethod("processMessage", PeerConnection.class, byte[].class); + method.setAccessible(true); + + // Send 101 BLOCK hashes → DROPPED (0+101=101 > 100) + List list101 = new ArrayList<>(); + for (int i = 0; i < 101; i++) { + list101.add(new Sha256Hash(i, new byte[32])); + } + InventoryMessage msgBlock101 = new InventoryMessage(list101, InventoryType.BLOCK); + method.invoke(handler, peer, msgBlock101.getSendBytes()); + Assert.assertEquals(0, + peer.getPeerStatistics().messageStatistics.tronInBlockInventoryElement.getCount(10)); + + // Send 100 BLOCK hashes → passes (0+100=100, not > 100) + List list100 = new ArrayList<>(); + for (int i = 0; i < 100; i++) { + list100.add(new Sha256Hash(i, new byte[32])); + } + InventoryMessage msgBlock100 = new InventoryMessage(list100, InventoryType.BLOCK); + method.invoke(handler, peer, msgBlock100.getSendBytes()); + Assert.assertEquals(100, + peer.getPeerStatistics().messageStatistics.tronInBlockInventoryElement.getCount(10)); + + // Send 1 more BLOCK hash → DROPPED (100+1=101 > 100) + List list1 = new ArrayList<>(); + list1.add(new Sha256Hash(0, new byte[32])); + InventoryMessage msgBlock1 = new InventoryMessage(list1, InventoryType.BLOCK); + method.invoke(handler, peer, msgBlock1.getSendBytes()); + Assert.assertEquals(100, // count unchanged: message was dropped + peer.getPeerStatistics().messageStatistics.tronInBlockInventoryElement.getCount(10)); + } + @Test public void testUpdateLastInteractiveTime() throws Exception { PeerConnection peer = new PeerConnection(); diff --git a/framework/src/test/java/org/tron/core/services/jsonrpc/BuildArgumentsTest.java b/framework/src/test/java/org/tron/core/services/jsonrpc/BuildArgumentsTest.java index 26699bc63f6..5ad2c85d181 100644 --- a/framework/src/test/java/org/tron/core/services/jsonrpc/BuildArgumentsTest.java +++ b/framework/src/test/java/org/tron/core/services/jsonrpc/BuildArgumentsTest.java @@ -1,5 +1,6 @@ package org.tron.core.services.jsonrpc; +import com.fasterxml.jackson.databind.ObjectMapper; import javax.annotation.Resource; import org.junit.Assert; import org.junit.Before; @@ -29,9 +30,9 @@ public class BuildArgumentsTest extends BaseTest { public void initBuildArgs() { buildArguments = new BuildArguments( "0x0000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000001","0x10","0.01","0x100", - "","0",9L,10000L,"",10L, - 2000L,"args",1,"",true); + "0x0000000000000000000000000000000000000001", "0x10", "0.01", "0x100", + "", "", "0", 9L, 10000L, "", 10L, + 2000L, "args", 1, "", true); } @@ -39,15 +40,13 @@ public void initBuildArgs() { public void testBuildArgument() { CallArguments callArguments = new CallArguments( "0x0000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000001","0x10","0.01","0x100", - "","0"); - BuildArguments buildArguments = new BuildArguments(callArguments); - Assert.assertEquals(buildArguments.getFrom(), - "0x0000000000000000000000000000000000000000"); - Assert.assertEquals(buildArguments.getTo(), - "0x0000000000000000000000000000000000000001"); - Assert.assertEquals(buildArguments.getGas(), "0x10"); - Assert.assertEquals(buildArguments.getGasPrice(), "0.01"); + "0x0000000000000000000000000000000000000001", "0x10", "0.01", "0x100", + "", "", "0"); + BuildArguments args = new BuildArguments(callArguments); + Assert.assertEquals("0x0000000000000000000000000000000000000000", args.getFrom()); + Assert.assertEquals("0x0000000000000000000000000000000000000001", args.getTo()); + Assert.assertEquals("0x10", args.getGas()); + Assert.assertEquals("0.01", args.getGasPrice()); } @Test @@ -55,19 +54,275 @@ public void testGetContractType() throws JsonRpcInvalidRequestException, JsonRpcInvalidParamsException { Protocol.Transaction.Contract.ContractType contractType = buildArguments.getContractType(wallet); - Assert.assertEquals(contractType, Protocol.Transaction.Contract.ContractType.TransferContract); + Assert.assertEquals(Protocol.Transaction.Contract.ContractType.TransferContract, contractType); } @Test public void testParseValue() throws JsonRpcInvalidParamsException { long value = buildArguments.parseValue(); - Assert.assertEquals(value, 256L); + Assert.assertEquals(256L, value); } @Test public void testParseGas() throws JsonRpcInvalidParamsException { long gas = buildArguments.parseGas(); - Assert.assertEquals(gas, 16L); + Assert.assertEquals(16L, gas); + } + + @Test + public void resolveData_inputOnly_returnsInput() throws JsonRpcInvalidParamsException { + BuildArguments args = new BuildArguments(); + args.setInput("0xdeadbeef"); + Assert.assertEquals("0xdeadbeef", args.resolveData()); + } + + @Test + public void resolveData_dataOnly_returnsData() throws JsonRpcInvalidParamsException { + BuildArguments args = new BuildArguments(); + args.setData("0xcafebabe"); + Assert.assertEquals("0xcafebabe", args.resolveData()); + } + + @Test + public void resolveData_bothPresentSame_returnsValue() throws JsonRpcInvalidParamsException { + BuildArguments args = new BuildArguments(); + args.setData("0xfeedface"); + args.setInput("0xfeedface"); + Assert.assertEquals("0xfeedface", args.resolveData()); + } + + /** Pins that "0x" on both sides decodes to []==[] and is not a conflict. */ + @Test + public void resolveData_bothZeroX_returnsZeroX() throws JsonRpcInvalidParamsException { + BuildArguments args = new BuildArguments(); + args.setInput("0x"); + args.setData("0x"); + Assert.assertEquals("0x", args.resolveData()); + } + + @Test + public void resolveData_inputZeroXOnly_returnsZeroX() throws JsonRpcInvalidParamsException { + BuildArguments args = new BuildArguments(); + args.setInput("0x"); + Assert.assertEquals("0x", args.resolveData()); + } + + @Test + public void resolveData_dataZeroXOnly_returnsZeroX() throws JsonRpcInvalidParamsException { + BuildArguments args = new BuildArguments(); + args.setData("0x"); + Assert.assertEquals("0x", args.resolveData()); + } + + @Test + public void resolveData_caseDifference_returnsInput() + throws JsonRpcInvalidParamsException { + BuildArguments args = new BuildArguments(); + args.setInput("0xDEADbeef"); + args.setData("0xdeadbeef"); + Assert.assertEquals("0xDEADbeef", args.resolveData()); + } + + /** + * Pins geth-equivalent semantics: empty string is presence with + * empty bytes, so paired with non-empty data the byte values differ + * and the build path raises the geth setDefaults conflict at the + * {@code getContractType()} entry point. + */ + @Test + public void getContractType_inputEmptyDataNonEmpty_throwsConflict() { + BuildArguments args = new BuildArguments(); + args.setFrom("0x0000000000000000000000000000000000000001"); + args.setInput(""); + args.setData("0xdeadbeef"); + Assert.assertThrows(JsonRpcInvalidParamsException.class, + () -> args.getContractType(wallet)); + } + + /** + * Wording matches go-ethereum's setDefaults so existing tooling can + * detect the error string. + */ + @Test + public void getContractType_inputAndDataConflict_throwsInvalidParams() { + BuildArguments args = new BuildArguments(); + args.setFrom("0x0000000000000000000000000000000000000001"); + args.setInput("0xdeadbeef"); + args.setData("0xcafebabe"); + + JsonRpcInvalidParamsException ex = Assert.assertThrows( + JsonRpcInvalidParamsException.class, + () -> args.getContractType(wallet)); + Assert.assertTrue( + "error message should match go-ethereum's wording: " + ex.getMessage(), + ex.getMessage().contains("both \"data\" and \"input\" are set and not equal")); + } + + @Test + public void getContractType_inputZeroXDataNonEmpty_throwsConflict() { + BuildArguments args = new BuildArguments(); + args.setFrom("0x0000000000000000000000000000000000000001"); + args.setInput("0x"); + args.setData("0xdeadbeef"); + + Assert.assertThrows( + JsonRpcInvalidParamsException.class, + () -> args.getContractType(wallet)); + } + + @Test + public void getContractType_inputAndDataEqual_succeeds() + throws JsonRpcInvalidRequestException, JsonRpcInvalidParamsException { + BuildArguments args = new BuildArguments(); + args.setFrom("0x0000000000000000000000000000000000000001"); + args.setInput("0xdeadbeef"); + args.setData("0xdeadbeef"); + Assert.assertEquals( + Protocol.Transaction.Contract.ContractType.CreateSmartContract, + args.getContractType(wallet)); + } + + /** Reproduces issue #6517 contract-creation symptom on the build path. */ + @Test + public void getContractType_createSmartContractViaInput_succeeds() + throws JsonRpcInvalidRequestException, JsonRpcInvalidParamsException { + BuildArguments args = new BuildArguments(); + args.setFrom("0x0000000000000000000000000000000000000001"); + args.setInput("0xdeadbeef"); + Assert.assertEquals( + Protocol.Transaction.Contract.ContractType.CreateSmartContract, + args.getContractType(wallet)); + } + + @Test + public void copyConstructor_preservesBothInputAndData() { + CallArguments src = new CallArguments(); + src.setFrom("0x0000000000000000000000000000000000000001"); + src.setData("0xcafebabe"); + src.setInput("0xdeadbeef"); + + BuildArguments copy = new BuildArguments(src); + Assert.assertEquals("0xcafebabe", copy.getData()); + Assert.assertEquals("0xdeadbeef", copy.getInput()); + } + + @Test + public void copyConstructor_propagatesConflictToBuildPath() { + CallArguments src = new CallArguments(); + src.setData("0xcafebabe"); + src.setInput("0xdeadbeef"); + + BuildArguments copy = new BuildArguments(src); + Assert.assertThrows(JsonRpcInvalidParamsException.class, + () -> copy.getContractType(wallet)); + } + + @Test + public void deserializeWithInputField_succeedsAndResolvesToInput() throws Exception { + String json = "{\"from\":\"0x0000000000000000000000000000000000000001\"," + + "\"to\":\"0x0000000000000000000000000000000000000002\"," + + "\"input\":\"0xdeadbeef\"}"; + BuildArguments args = new ObjectMapper().readValue(json, BuildArguments.class); + Assert.assertEquals("0xdeadbeef", args.resolveData()); + Assert.assertEquals("0xdeadbeef", args.getInput()); + Assert.assertNull(args.getData()); + } + + /** + * Regression guard: a future {@code getXxx} rename would expose + * {@code resolveData} as a wire property and risk throwing during + * serialisation. + */ + @Test + public void jacksonSerialize_doesNotExposeResolveDataOrThrowOnConflict() + throws Exception { + BuildArguments args = new BuildArguments(); + args.setInput("0xdeadbeef"); + args.setData("0xcafebabe"); // conflicting bytes, would throw if resolveData() were invoked + String json = new ObjectMapper().writeValueAsString(args); + Assert.assertFalse("should not leak resolveData: " + json, + json.contains("resolveData")); + } + + /** Same guarantee for FastJSON, which also discovers bean getters. */ + @Test + public void fastjsonSerialize_doesNotExposeResolveDataOrThrowOnConflict() { + BuildArguments args = new BuildArguments(); + args.setInput("0xdeadbeef"); + args.setData("0xcafebabe"); + String json = com.alibaba.fastjson.JSON.toJSONString(args); + Assert.assertFalse("should not leak resolveData: " + json, + json.contains("resolveData")); + } + + /** Validates the loser field too, not only the precedence winner. */ + @Test + public void resolveData_inputValidDataMalformed_throwsInvalidParams() { + BuildArguments args = new BuildArguments(); + args.setInput("0xdeadbeef"); + args.setData("0xzz"); + Assert.assertThrows(JsonRpcInvalidParamsException.class, args::resolveData); + } + + @Test + public void resolveData_inputMalformedDataValid_throwsInvalidParams() { + BuildArguments args = new BuildArguments(); + args.setInput("0xzz"); + args.setData("0xdeadbeef"); + Assert.assertThrows(JsonRpcInvalidParamsException.class, args::resolveData); + } + + @Test + public void resolveData_inputMalformedDataAbsent_throwsInvalidParams() { + BuildArguments args = new BuildArguments(); + args.setInput("0xzz"); + Assert.assertThrows(JsonRpcInvalidParamsException.class, args::resolveData); + } + + @Test + public void resolveData_dataMalformedInputAbsent_throwsInvalidParams() { + BuildArguments args = new BuildArguments(); + args.setData("0xzz"); + Assert.assertThrows(JsonRpcInvalidParamsException.class, args::resolveData); + } + + /** + * {@code input} is the new spec-aligned field: missing {@code 0x} prefix + * is rejected per the execution-apis BYTES schema. + */ + @Test + public void resolveData_inputNoPrefix_throwsInvalidParams() { + BuildArguments args = new BuildArguments(); + args.setInput("deadbeef"); + Assert.assertThrows(JsonRpcInvalidParamsException.class, args::resolveData); + } + + @Test + public void resolveData_inputOddLength_throwsInvalidParams() { + BuildArguments args = new BuildArguments(); + args.setInput("0x123"); + Assert.assertThrows(JsonRpcInvalidParamsException.class, args::resolveData); + } + + /** + * {@code data} is the legacy field: bare hex (no {@code 0x} prefix) + * stays accepted for backward compatibility with existing callers + * (e.g. BuildTransactionTest.testCreateSmartContract). + */ + @Test + public void resolveData_dataNoPrefix_acceptedForBackwardCompat() + throws JsonRpcInvalidParamsException { + BuildArguments args = new BuildArguments(); + args.setData("deadbeef"); + Assert.assertEquals("deadbeef", args.resolveData()); + } + + @Test + public void resolveData_dataOddLength_acceptedForBackwardCompat() + throws JsonRpcInvalidParamsException { + BuildArguments args = new BuildArguments(); + args.setData("0x123"); + Assert.assertEquals("0x123", args.resolveData()); } } diff --git a/framework/src/test/java/org/tron/core/services/jsonrpc/CallArgumentsTest.java b/framework/src/test/java/org/tron/core/services/jsonrpc/CallArgumentsTest.java index 2148e1a2fe0..66fb8e0a0c7 100644 --- a/framework/src/test/java/org/tron/core/services/jsonrpc/CallArgumentsTest.java +++ b/framework/src/test/java/org/tron/core/services/jsonrpc/CallArgumentsTest.java @@ -1,5 +1,6 @@ package org.tron.core.services.jsonrpc; +import com.fasterxml.jackson.databind.ObjectMapper; import javax.annotation.Resource; import org.junit.Assert; import org.junit.Before; @@ -26,9 +27,11 @@ public class CallArgumentsTest extends BaseTest { @Before public void init() { - callArguments = new CallArguments("0x0000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000001","0x10","0.01","0x100", - "","0"); + callArguments = new CallArguments( + "0x0000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000001", + "0x10", "0.01", "0x100", + "", "", "0"); } @Test @@ -44,4 +47,200 @@ public void testParseValue() throws JsonRpcInvalidParamsException { Assert.assertEquals(256L, value); } + @Test + public void resolveData_inputOnly_returnsInput() throws JsonRpcInvalidParamsException { + CallArguments args = new CallArguments(); + args.setInput("0xdeadbeef"); + Assert.assertEquals("0xdeadbeef", args.resolveData()); + } + + @Test + public void resolveData_dataOnly_returnsData() throws JsonRpcInvalidParamsException { + CallArguments args = new CallArguments(); + args.setData("0xcafebabe"); + Assert.assertEquals("0xcafebabe", args.resolveData()); + } + + @Test + public void resolveData_bothPresentSame_returnsValue() throws JsonRpcInvalidParamsException { + CallArguments args = new CallArguments(); + args.setData("0xfeedface"); + args.setInput("0xfeedface"); + Assert.assertEquals("0xfeedface", args.resolveData()); + } + + @Test + public void resolveData_bothPresentDifferent_inputWinsNoError() + throws JsonRpcInvalidParamsException { + CallArguments args = new CallArguments(); + args.setData("0xcafebabe"); + args.setInput("0xdeadbeef"); + Assert.assertEquals("0xdeadbeef", args.resolveData()); + } + + @Test + public void resolveData_inputIsZeroX_dataNonEmpty_returnsInput() + throws JsonRpcInvalidParamsException { + CallArguments args = new CallArguments(); + args.setInput("0x"); + args.setData("0xdeadbeef"); + Assert.assertEquals("0x", args.resolveData()); + } + + @Test + public void resolveData_dataIsZeroX_inputNonEmpty_returnsInput() + throws JsonRpcInvalidParamsException { + CallArguments args = new CallArguments(); + args.setInput("0xdeadbeef"); + args.setData("0x"); + Assert.assertEquals("0xdeadbeef", args.resolveData()); + } + + @Test + public void resolveData_caseDifference_returnsInput() + throws JsonRpcInvalidParamsException { + CallArguments args = new CallArguments(); + args.setInput("0xDEADbeef"); + args.setData("0xdeadbeef"); + Assert.assertEquals("0xDEADbeef", args.resolveData()); + } + + /** Pins geth-equivalent semantics: "" is presence, wins over data by precedence. */ + @Test + public void resolveData_inputEmpty_dataNonEmpty_inputWinsAsEmpty() + throws JsonRpcInvalidParamsException { + CallArguments args = new CallArguments(); + args.setInput(""); + args.setData("0xdeadbeef"); + Assert.assertEquals("", args.resolveData()); + } + + @Test + public void resolveData_neitherPresent_returnsNull() + throws JsonRpcInvalidParamsException { + CallArguments args = new CallArguments(); + Assert.assertNull(args.resolveData()); + } + + /** Validates the loser field too, not only the precedence winner. */ + @Test + public void resolveData_inputValidDataMalformed_throwsInvalidParams() { + CallArguments args = new CallArguments(); + args.setInput("0xdeadbeef"); + args.setData("0xzz"); + Assert.assertThrows(JsonRpcInvalidParamsException.class, args::resolveData); + } + + @Test + public void resolveData_inputMalformedDataValid_throwsInvalidParams() { + CallArguments args = new CallArguments(); + args.setInput("0xzz"); + args.setData("0xdeadbeef"); + Assert.assertThrows(JsonRpcInvalidParamsException.class, args::resolveData); + } + + @Test + public void resolveData_inputMalformedDataAbsent_throwsInvalidParams() { + CallArguments args = new CallArguments(); + args.setInput("0xzz"); + Assert.assertThrows(JsonRpcInvalidParamsException.class, args::resolveData); + } + + @Test + public void resolveData_dataMalformedInputAbsent_throwsInvalidParams() { + CallArguments args = new CallArguments(); + args.setData("0xzz"); + Assert.assertThrows(JsonRpcInvalidParamsException.class, args::resolveData); + } + + /** + * {@code input} is the new spec-aligned field: missing {@code 0x} prefix + * is rejected per the execution-apis BYTES schema. + */ + @Test + public void resolveData_inputNoPrefix_throwsInvalidParams() { + CallArguments args = new CallArguments(); + args.setInput("deadbeef"); + Assert.assertThrows(JsonRpcInvalidParamsException.class, args::resolveData); + } + + @Test + public void resolveData_inputOddLength_throwsInvalidParams() { + CallArguments args = new CallArguments(); + args.setInput("0x123"); + Assert.assertThrows(JsonRpcInvalidParamsException.class, args::resolveData); + } + + /** + * {@code data} is the legacy field: bare hex (no {@code 0x} prefix) + * stays accepted for backward compatibility with existing callers + * (e.g. BuildTransactionTest.testCreateSmartContract). + */ + @Test + public void resolveData_dataNoPrefix_acceptedForBackwardCompat() + throws JsonRpcInvalidParamsException { + CallArguments args = new CallArguments(); + args.setData("deadbeef"); + Assert.assertEquals("deadbeef", args.resolveData()); + } + + @Test + public void resolveData_dataOddLength_acceptedForBackwardCompat() + throws JsonRpcInvalidParamsException { + CallArguments args = new CallArguments(); + args.setData("0x123"); + Assert.assertEquals("0x123", args.resolveData()); + } + + /** Reproduces issue #6517 contract-creation symptom. */ + @Test + public void getContractType_createSmartContractViaInput_succeeds() + throws JsonRpcInvalidRequestException, JsonRpcInvalidParamsException { + CallArguments args = new CallArguments(); + args.setFrom("0x0000000000000000000000000000000000000001"); + args.setInput("0xdeadbeef"); + Assert.assertEquals( + Protocol.Transaction.Contract.ContractType.CreateSmartContract, + args.getContractType(wallet)); + } + + /** Reproduces issue #6517 Jackson parse-error symptom. */ + @Test + public void deserializeWithInputField_succeedsAndResolvesToInput() throws Exception { + String json = "{\"from\":\"0x0000000000000000000000000000000000000001\"," + + "\"to\":\"0x0000000000000000000000000000000000000002\"," + + "\"input\":\"0xdeadbeef\"}"; + CallArguments args = new ObjectMapper().readValue(json, CallArguments.class); + Assert.assertEquals("0xdeadbeef", args.resolveData()); + Assert.assertEquals("0xdeadbeef", args.getInput()); + Assert.assertNull(args.getData()); + } + + /** + * Regression guard: a future {@code getXxx} rename would expose + * {@code resolveData} as a wire property and risk throwing during + * serialisation. + */ + @Test + public void jacksonSerialize_doesNotExposeResolveDataOrThrowOnConflict() + throws Exception { + CallArguments args = new CallArguments(); + args.setInput("0xdeadbeef"); + args.setData("0xcafebabe"); // would throw conflict in build path + String json = new ObjectMapper().writeValueAsString(args); + Assert.assertFalse("should not leak resolveData: " + json, + json.contains("resolveData")); + } + + /** Same guarantee for FastJSON, which also discovers bean getters. */ + @Test + public void fastjsonSerialize_doesNotExposeResolveDataOrThrowOnConflict() { + CallArguments args = new CallArguments(); + args.setInput("0xdeadbeef"); + args.setData("0xcafebabe"); + String json = com.alibaba.fastjson.JSON.toJSONString(args); + Assert.assertFalse("should not leak resolveData: " + json, + json.contains("resolveData")); + } + } diff --git a/framework/src/test/java/org/tron/core/vm/repository/RepositoryImplHardenTest.java b/framework/src/test/java/org/tron/core/vm/repository/RepositoryImplHardenTest.java new file mode 100644 index 00000000000..6b15409edd6 --- /dev/null +++ b/framework/src/test/java/org/tron/core/vm/repository/RepositoryImplHardenTest.java @@ -0,0 +1,280 @@ +package org.tron.core.vm.repository; + +import com.google.protobuf.ByteString; +import java.lang.reflect.Method; +import lombok.extern.slf4j.Slf4j; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.tron.common.BaseTest; +import org.tron.common.TestConstants; +import org.tron.common.utils.ByteArray; +import org.tron.core.Wallet; +import org.tron.core.capsule.AccountCapsule; +import org.tron.core.config.args.Args; +import org.tron.core.store.StoreFactory; +import org.tron.core.vm.config.VMConfig; +import org.tron.protos.Protocol.AccountType; + +@Slf4j +public class RepositoryImplHardenTest extends BaseTest { + + static { + Args.setParam(new String[]{"--output-directory", dbPath()}, TestConstants.TEST_CONF); + } + + private RepositoryImpl repository; + private Method increaseMethod; + private Method getUsageMethod; + private Method usageToBalanceMethod; + + @Before + public void setUp() throws Exception { + repository = RepositoryImpl.createRoot(StoreFactory.getInstance()); + + increaseMethod = RepositoryImpl.class.getDeclaredMethod( + "increase", long.class, long.class, long.class, long.class, long.class); + increaseMethod.setAccessible(true); + + getUsageMethod = RepositoryImpl.class.getDeclaredMethod( + "getUsage", long.class, long.class); + getUsageMethod.setAccessible(true); + + usageToBalanceMethod = RepositoryImpl.class.getDeclaredMethod( + "usageToBalance", long.class, long.class, long.class); + usageToBalanceMethod.setAccessible(true); + } + + @After + public void tearDown() { + VMConfig.initAllowHardenResourceCalculation(0); + } + + private long invokeIncrease(long lastUsage, long usage, long lastTime, + long now, long windowSize) throws Exception { + try { + return (long) increaseMethod.invoke( + repository, lastUsage, usage, lastTime, now, windowSize); + } catch (java.lang.reflect.InvocationTargetException e) { + if (e.getCause() instanceof RuntimeException) { + throw (RuntimeException) e.getCause(); + } + throw e; + } + } + + private long invokeGetUsage(long usage, long windowSize) throws Exception { + try { + return (long) getUsageMethod.invoke(repository, usage, windowSize); + } catch (java.lang.reflect.InvocationTargetException e) { + if (e.getCause() instanceof RuntimeException) { + throw (RuntimeException) e.getCause(); + } + throw e; + } + } + + private long invokeUsageToBalance(long usage, long totalWeight, long totalLimit) + throws Exception { + try { + return (long) usageToBalanceMethod.invoke( + repository, usage, totalWeight, totalLimit); + } catch (java.lang.reflect.InvocationTargetException e) { + if (e.getCause() instanceof RuntimeException) { + throw (RuntimeException) e.getCause(); + } + throw e; + } + } + + @Test + public void testIncreaseNormalValuesParity() throws Exception { + long lastUsage = 1_000L; + long usage = 500L; + long lastTime = 9990L; + long now = 9995L; + long windowSize = 28800L; + + VMConfig.initAllowHardenResourceCalculation(0); + long resultOld = invokeIncrease(lastUsage, usage, lastTime, now, windowSize); + + VMConfig.initAllowHardenResourceCalculation(1); + long resultNew = invokeIncrease(lastUsage, usage, lastTime, now, windowSize); + + Assert.assertEquals(resultOld, resultNew); + } + + @Test + public void testGetUsageNormalValuesParity() throws Exception { + long usage = 100_000L; + long windowSize = 28800L; + + VMConfig.initAllowHardenResourceCalculation(0); + long resultOld = invokeGetUsage(usage, windowSize); + + VMConfig.initAllowHardenResourceCalculation(1); + long resultNew = invokeGetUsage(usage, windowSize); + + Assert.assertEquals(resultOld, resultNew); + } + + @Test + public void testIncreaseOverflowDetectedWithHardening() { + long lastUsage = Long.MAX_VALUE / 10; // ~9.2e17 + long usage = 1L; + long lastTime = 9990L; + long now = 9995L; + long windowSize = 28800L; + + VMConfig.initAllowHardenResourceCalculation(1); + + Assert.assertThrows(ArithmeticException.class, + () -> invokeIncrease(lastUsage, usage, lastTime, now, windowSize)); + } + + @Test + public void testIncreaseOverflowSilentWithoutHardening() throws Exception { + long lastUsage = Long.MAX_VALUE / 10; + long usage = 1L; + long lastTime = 9990L; + long now = 9995L; + long windowSize = 28800L; + + VMConfig.initAllowHardenResourceCalculation(0); + invokeIncrease(lastUsage, usage, lastTime, now, windowSize); + } + + @Test + public void testGetUsageCorrectAcrossOverflowBoundary() throws Exception { + long usage = Long.MAX_VALUE / 1000; // ~9.2e15 + long windowSize = 28800L; + + long expected = java.math.BigInteger.valueOf(usage) + .multiply(java.math.BigInteger.valueOf(windowSize)) + .divide(java.math.BigInteger.valueOf(1_000_000L)) + .longValueExact(); + + VMConfig.initAllowHardenResourceCalculation(1); + long actual = invokeGetUsage(usage, windowSize); + Assert.assertEquals(expected, actual); + + VMConfig.initAllowHardenResourceCalculation(0); + long wrapped = invokeGetUsage(usage, windowSize); + Assert.assertNotEquals(expected, wrapped); + } + + @Test + public void testGetUsageLargeButSafeWithHardening() throws Exception { + long usage = 500_000_000_000L; // 5e11 + long windowSize = 28800L; + + VMConfig.initAllowHardenResourceCalculation(1); + long expected = java.math.BigInteger.valueOf(usage) + .multiply(java.math.BigInteger.valueOf(windowSize)) + .divide(java.math.BigInteger.valueOf(1_000_000L)) + .longValueExact(); + + long actual = invokeGetUsage(usage, windowSize); + Assert.assertEquals(expected, actual); + } + + + @Test + public void testUsageToBalanceParity() throws Exception { + long usage = 1_000_000L; + long totalWeight = 2_000_000_000L; + long totalLimit = 50_000_000_000L; + + VMConfig.initAllowHardenResourceCalculation(0); + long resultOld = invokeUsageToBalance(usage, totalWeight, totalLimit); + + VMConfig.initAllowHardenResourceCalculation(1); + long resultNew = invokeUsageToBalance(usage, totalWeight, totalLimit); + + Assert.assertEquals(resultOld, resultNew); + } + + @Test + public void testUsageToBalanceCorrectAcrossDoublePrecision() throws Exception { + long usage = 100_000_000L; // 1e8 + long totalWeight = 100_000_000_000L; // 1e11 -> usage * weight = 1e19, beyond 2^53 + long totalLimit = 50_000_000_000L; + + java.math.BigInteger expected = java.math.BigInteger.valueOf(usage) + .multiply(java.math.BigInteger.valueOf(totalWeight)) + .multiply(java.math.BigInteger.valueOf(1_000_000L)) + .divide(java.math.BigInteger.valueOf(totalLimit)); + + VMConfig.initAllowHardenResourceCalculation(1); + long actual = invokeUsageToBalance(usage, totalWeight, totalLimit); + + Assert.assertEquals(expected.longValueExact(), actual); + } + + @Test + public void testUsageToBalanceOverflowDetectedWithHardening() { + long usage = 1_000_000_000L; + long totalWeight = 1_000_000_000_000L; + long totalLimit = 1L; + + VMConfig.initAllowHardenResourceCalculation(1); + + Assert.assertThrows(ArithmeticException.class, + () -> invokeUsageToBalance(usage, totalWeight, totalLimit)); + } + + @Test + public void testCalculateGlobalEnergyLimitHardenedParityWithNonIntegerRatio() { + long totalEnergyLimit = 50_000_000_000L; + long totalEnergyWeight = 1_234_567L; + long frozeBalance = 10_000_000_000L; + + dbManager.getDynamicPropertiesStore().saveTotalEnergyCurrentLimit(totalEnergyLimit); + dbManager.getDynamicPropertiesStore().saveTotalEnergyWeight(totalEnergyWeight); + + AccountCapsule account = new AccountCapsule( + ByteString.copyFromUtf8("owner"), + ByteString.copyFrom(ByteArray.fromHexString( + Wallet.getAddressPreFixString() + "548794500882809695a8a687866e76d4271a1abc")), + AccountType.Normal, 0L); + account.setFrozenForEnergy(frozeBalance, 0L); + + VMConfig.initAllowHardenResourceCalculation(0); + long resultOld = repository.calculateGlobalEnergyLimit(account); + + VMConfig.initAllowHardenResourceCalculation(1); + long resultNew = repository.calculateGlobalEnergyLimit(account); + + long expected = java.math.BigInteger.valueOf(10000L) + .multiply(java.math.BigInteger.valueOf(totalEnergyLimit)) + .divide(java.math.BigInteger.valueOf(totalEnergyWeight)) + .longValueExact(); + Assert.assertEquals(expected, resultNew); + Assert.assertEquals(resultOld, resultNew); + + long buggy = 10000L * (totalEnergyLimit / totalEnergyWeight); + Assert.assertNotEquals(buggy, resultNew); + } + + @Test + public void testCalculateGlobalEnergyLimitHardenedOverflowDetected() { + long totalEnergyLimit = Long.MAX_VALUE / 2; + long totalEnergyWeight = 1L; + long frozeBalance = Long.MAX_VALUE / 4; + + dbManager.getDynamicPropertiesStore().saveTotalEnergyCurrentLimit(totalEnergyLimit); + dbManager.getDynamicPropertiesStore().saveTotalEnergyWeight(totalEnergyWeight); + + AccountCapsule account = new AccountCapsule( + ByteString.copyFromUtf8("owner"), + ByteString.copyFrom(ByteArray.fromHexString( + Wallet.getAddressPreFixString() + "548794500882809695a8a687866e76d4271a1abc")), + AccountType.Normal, 0L); + account.setFrozenForEnergy(frozeBalance, 0L); + + VMConfig.initAllowHardenResourceCalculation(1); + Assert.assertThrows(ArithmeticException.class, + () -> repository.calculateGlobalEnergyLimit(account)); + } +} diff --git a/gradle/verification-metadata.xml b/gradle/verification-metadata.xml index 86880157f35..8ef39e7669b 100644 --- a/gradle/verification-metadata.xml +++ b/gradle/verification-metadata.xml @@ -289,12 +289,12 @@ - - - + + + - - + + @@ -315,12 +315,12 @@ - - - + + + - - + + @@ -347,12 +347,12 @@ - - - + + + - - + + @@ -363,9 +363,9 @@ - - - + + + @@ -386,12 +386,12 @@ - - - + + + - - + + @@ -404,9 +404,9 @@ - - - + + + @@ -417,12 +417,12 @@ - - - + + + - - + + @@ -467,15 +467,15 @@ - - - + + + - - + + - - + + @@ -508,14 +508,14 @@ - - - + + + - - - + + + @@ -539,12 +539,12 @@ - - - + + + - - + + @@ -888,194 +888,191 @@ - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + - - - - - - - - - - - - + + + + + + - - + + + + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + @@ -1654,12 +1651,12 @@ - - - + + + - - + + @@ -1699,12 +1696,12 @@ - - - + + + - - + + @@ -1712,9 +1709,9 @@ - - - + + + @@ -1722,9 +1719,9 @@ - - - + + + @@ -1751,65 +1748,65 @@ - - - + + + - - + + - - - + + + - - + + - - - + + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + - - - + + + - - + + @@ -2012,6 +2009,17 @@ + + + + + + + + + + + @@ -2044,6 +2052,22 @@ + + + + + + + + + + + + + + + + @@ -2168,17 +2192,17 @@ - - - + + + - - + + - - - + + + diff --git a/plugins/README.md b/plugins/README.md index b6540beef1a..f14e070c01a 100644 --- a/plugins/README.md +++ b/plugins/README.md @@ -75,16 +75,20 @@ DB lite provides lite database, parameters are compatible with previous `LiteFul - `-fn | --fn-data-path`: The database path to be split or merged. - `-ds | --dataset-path`: When operation is `split`,`dataset-path` is the path that store the `snapshot` or `history`, when operation is `split`, `dataset-path` is the `history` data path. +- `--exclude-historical-balance`: Only used with `operate=split -t snapshot`, default: false. When set to true, `balance-trace` and `account-trace` are excluded from the lite snapshot. The flag has functional impact only when the source full node ran with `historyBalanceLookup=true` (off by default; most operators are unaffected). **WARNING:** for nodes that had `historyBalanceLookup=true`, this loss is permanent — a lite node booted from such a snapshot cannot safely serve historical balance lookups (`getBlockBalance` may fail, and `getAccountBalance` may return `balance=0` when `account-trace` data is missing), and running `merge` afterwards will NOT restore the feature. If you need historical balance lookup on the resulting lite node, do **not** enable this flag. `split -t history` and `merge` ignore this flag. - `-h | --help`: Provide the help info. ### Examples: ```shell script # full command - java -jar Toolkit.jar db lite [-h] -ds= -fn= [-o=] [-t=] + java -jar Toolkit.jar db lite [-h] -ds= -fn= [-o=] [-t=] [--exclude-historical-balance] # examples #split and get a snapshot dataset java -jar Toolkit.jar db lite -o split -t snapshot --fn-data-path output-directory/database --dataset-path /tmp + #split and get a snapshot dataset without balance-trace / account-trace (smaller snapshot; + #historical balance lookup cannot be safely served on the resulting lite node) + java -jar Toolkit.jar db lite -o split -t snapshot --fn-data-path output-directory/database --dataset-path /tmp --exclude-historical-balance #split and get a history dataset java -jar Toolkit.jar db lite -o split -t history --fn-data-path output-directory/database --dataset-path /tmp #merge history dataset and snapshot dataset diff --git a/plugins/build.gradle b/plugins/build.gradle index 2e358a884a3..fc9ef5e00d6 100644 --- a/plugins/build.gradle +++ b/plugins/build.gradle @@ -43,7 +43,7 @@ dependencies { implementation group: 'info.picocli', name: 'picocli', version: '4.6.3' implementation group: 'com.typesafe', name: 'config', version: '1.3.2' implementation group: 'me.tongfei', name: 'progressbar', version: '0.9.3' - implementation group: 'org.bouncycastle', name: 'bcprov-jdk18on', version: '1.79' + implementation group: 'org.bouncycastle', name: 'bcprov-jdk18on', version: '1.84' if (rootProject.archInfo.isArm64) { testRuntimeOnly group: 'org.fusesource.hawtjni', name: 'hawtjni-runtime', version: '1.18' // for test implementation project(":platform") diff --git a/plugins/src/main/java/common/org/tron/plugins/DbLite.java b/plugins/src/main/java/common/org/tron/plugins/DbLite.java index 3f8a6cb58c8..1a7e4e270f7 100644 --- a/plugins/src/main/java/common/org/tron/plugins/DbLite.java +++ b/plugins/src/main/java/common/org/tron/plugins/DbLite.java @@ -20,6 +20,7 @@ import java.util.concurrent.Callable; import java.util.stream.Collectors; import java.util.stream.LongStream; +import java.util.stream.Stream; import lombok.extern.slf4j.Slf4j; import me.tongfei.progressbar.ProgressBar; import org.rocksdb.RocksDBException; @@ -57,6 +58,8 @@ public class DbLite implements Callable { private static final String TRANSACTION_HISTORY_DB_NAME = "transactionHistoryStore"; private static final String PROPERTIES_DB_NAME = "properties"; private static final String TRANS_CACHE_DB_NAME = "trans-cache"; + private static final String BALANCE_TRACE_DB_NAME = "balance-trace"; + private static final String ACCOUNT_TRACE_DB_NAME = "account-trace"; private static final List archiveDbs = Arrays.asList( BLOCK_DB_NAME, @@ -65,6 +68,10 @@ public class DbLite implements Callable { TRANSACTION_RET_DB_NAME, TRANSACTION_HISTORY_DB_NAME); + private static final List traceDbs = Arrays.asList( + BALANCE_TRACE_DB_NAME, + ACCOUNT_TRACE_DB_NAME); + enum Operate { split, merge } enum Type { snapshot, history } @@ -105,8 +112,26 @@ enum Type { snapshot, history } private String datasetPath; @CommandLine.Option( - names = {"--help", "-h"}, + names = {"--exclude-historical-balance"}, + defaultValue = "false", + description = "only used with `operate=split -t snapshot`: when true, balance-trace " + + "and account-trace are excluded from the lite snapshot. " + + "Default: ${DEFAULT-VALUE} (legacy behavior; trace stores stay in the snapshot). " + + "This flag only has a functional impact when the source full node ran with " + + "`historyBalanceLookup=true` (off by default; most operators are unaffected). " + + "WARNING: when historyBalanceLookup was enabled, this loss is permanent: a lite " + + "node booted from such a snapshot cannot safely serve historical balance lookups " + + "(getBlockBalance may fail, and getAccountBalance may return balance=0 when " + + "account-trace data is missing). Running merge afterwards will NOT restore the " + + "feature. If you need to keep historyBalanceLookup working on the resulting " + + "lite node, do NOT enable this flag. `split -t history` and `merge` ignore " + + "this flag.", order = 5) + private boolean excludeHistoricalBalance; + + @CommandLine.Option( + names = {"--help", "-h"}, + order = 6) private boolean help; @@ -120,6 +145,7 @@ public Integer call() { switch (this.operate) { case split: if (Type.snapshot == this.type) { + warnIfExcludingHistoricalBalance(); generateSnapshot(fnDataPath, datasetPath); } else if (Type.history == type) { generateHistory(fnDataPath, datasetPath); @@ -253,12 +279,52 @@ public void completeHistoryData(String historyDir, String liteDir) { spec.commandLine().getOut().format("Merge history finished, take %d s.", during).println(); } + /** + * Compute the directories to exclude from the lite snapshot. + *

+ * Default ({@code --exclude-historical-balance=false}): the legacy archive set + * (5 dbs); {@link #BALANCE_TRACE_DB_NAME} / {@link #ACCOUNT_TRACE_DB_NAME} + * stay with the snapshot as state-style stores. + *

+ * Opt-in ({@code --exclude-historical-balance=true}): the trace stores are + * additionally excluded, producing a smaller lite snapshot at the cost of + * dropping historical balance lookup support on the resulting lite node. + * Only {@code split -t snapshot} consults this. {@code split -t history} + * and {@code merge} always use the legacy archive set. + */ + private List snapshotExclusion() { + if (!excludeHistoricalBalance) { + return archiveDbs; + } + return Stream.concat(archiveDbs.stream(), traceDbs.stream()) + .collect(Collectors.toList()); + } + + private void warnIfExcludingHistoricalBalance() { + if (!excludeHistoricalBalance) { + return; + } + String msg = "WARNING: --exclude-historical-balance is enabled. balance-trace / account-trace " + + "will be excluded from the lite snapshot. This only matters when the source full " + + "node ran with historyBalanceLookup=true (off by default; most operators are " + + "unaffected). When that switch was enabled, this loss is permanent: lite nodes " + + "booted from this snapshot cannot safely serve historical balance lookups " + + "(getBlockBalance may fail, and getAccountBalance may return balance=0 when " + + "account-trace data is missing). Running merge afterwards will NOT restore the " + + "feature. If you need to keep historyBalanceLookup working on the resulting " + + "lite node, do NOT use this flag."; + logger.warn(msg); + spec.commandLine().getErr().println(spec.commandLine().getColorScheme() + .errorText(msg)); + } + private List getSnapshotDbs(String sourceDir) { List snapshotDbs = Lists.newArrayList(); File basePath = new File(sourceDir); + List excluded = snapshotExclusion(); Arrays.stream(Objects.requireNonNull(basePath.listFiles())) .filter(File::isDirectory) - .filter(dir -> !archiveDbs.contains(dir.getName())) + .filter(dir -> !excluded.contains(dir.getName())) .forEach(dir -> snapshotDbs.add(dir.getName())); return snapshotDbs; } @@ -723,4 +789,3 @@ public long getSnapshotMaxNum() { } - diff --git a/plugins/src/test/java/org/tron/plugins/DbLiteTest.java b/plugins/src/test/java/org/tron/plugins/DbLiteTest.java index 07bddc461a0..f7cb7b7f74f 100644 --- a/plugins/src/test/java/org/tron/plugins/DbLiteTest.java +++ b/plugins/src/test/java/org/tron/plugins/DbLiteTest.java @@ -1,11 +1,14 @@ package org.tron.plugins; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; import static org.tron.common.utils.PublicMethod.getRandomPrivateKey; import io.grpc.ManagedChannel; import io.grpc.ManagedChannelBuilder; import java.io.File; import java.io.IOException; +import java.nio.file.Path; import java.nio.file.Paths; import lombok.extern.slf4j.Slf4j; import org.junit.After; @@ -68,7 +71,7 @@ public void shutdown() throws InterruptedException { context.close(); } - public void init(String dbType) throws IOException { + public void init(String dbType, boolean historyBalanceLookup) throws IOException { dbPath = folder.newFolder().toString(); Args.setParam(new String[] { "-d", dbPath, "-w", "--p2p-disable", "true", "--storage-db-engine", dbType}, @@ -77,6 +80,7 @@ public void init(String dbType) throws IOException { Args.getInstance().setAllowAccountStateRoot(1); Args.getInstance().setRpcPort(PublicMethod.chooseRandomPort()); Args.getInstance().setRpcEnable(true); + Args.getInstance().setHistoryBalanceLookup(historyBalanceLookup); databaseDir = Args.getInstance().getStorage().getDbDirectory(); // init dbBackupConfig to avoid NPE Args.getInstance().dbBackupConfig = DbBackupConfig.getInstance(); @@ -89,10 +93,20 @@ public void clear() { public void testTools(String dbType, int checkpointVersion) throws InterruptedException, IOException { - logger.info("dbType {}, checkpointVersion {}", dbType, checkpointVersion); - init(dbType); - final String[] argsForSnapshot = - new String[] {"-o", "split", "-t", "snapshot", "--fn-data-path", + testTools(dbType, checkpointVersion, false); + } + + public void testTools(String dbType, int checkpointVersion, boolean excludeHistoricalBalance) + throws InterruptedException, IOException { + logger.info("dbType {}, checkpointVersion {}, excludeHistoricalBalance {}", + dbType, checkpointVersion, excludeHistoricalBalance); + boolean historyBalanceLookup = excludeHistoricalBalance; + init(dbType, historyBalanceLookup); + final String[] argsForSnapshot = excludeHistoricalBalance + ? new String[] {"-o", "split", "-t", "snapshot", "--fn-data-path", + dbPath + File.separator + databaseDir, "--dataset-path", + dbPath, "--exclude-historical-balance"} + : new String[] {"-o", "split", "-t", "snapshot", "--fn-data-path", dbPath + File.separator + databaseDir, "--dataset-path", dbPath}; final String[] argsForHistory = @@ -114,6 +128,16 @@ public void testTools(String dbType, int checkpointVersion) FileUtil.deleteDir(Paths.get(dbPath, databaseDir, "trans-cache").toFile()); // generate snapshot cli.execute(argsForSnapshot); + Path snapshotDir = Paths.get(dbPath, "snapshot"); + if (excludeHistoricalBalance) { + // when --exclude-historical-balance=true, the lite snapshot must not ship + // balance-trace / account-trace + assertFalse(snapshotDir.resolve("balance-trace").toFile().exists()); + assertFalse(snapshotDir.resolve("account-trace").toFile().exists()); + } else { + assertTrue(snapshotDir.resolve("balance-trace").toFile().exists()); + assertTrue(snapshotDir.resolve("account-trace").toFile().exists()); + } // start fullNode startApp(); // produce transactions diff --git a/plugins/src/test/java/org/tron/plugins/rocksdb/DbLiteExcludeHistoricalBalanceRocksDbTest.java b/plugins/src/test/java/org/tron/plugins/rocksdb/DbLiteExcludeHistoricalBalanceRocksDbTest.java new file mode 100644 index 00000000000..766fe6d0924 --- /dev/null +++ b/plugins/src/test/java/org/tron/plugins/rocksdb/DbLiteExcludeHistoricalBalanceRocksDbTest.java @@ -0,0 +1,13 @@ +package org.tron.plugins.rocksdb; + +import java.io.IOException; +import org.junit.Test; +import org.tron.plugins.DbLiteTest; + +public class DbLiteExcludeHistoricalBalanceRocksDbTest extends DbLiteTest { + + @Test + public void testToolsWithExcludeHistoricalBalance() throws InterruptedException, IOException { + testTools("ROCKSDB", 1, true); + } +} diff --git a/protocol/build.gradle b/protocol/build.gradle index 04d970b59db..0ce01a9bfb8 100644 --- a/protocol/build.gradle +++ b/protocol/build.gradle @@ -2,7 +2,8 @@ apply plugin: 'com.google.protobuf' apply from: 'protoLint.gradle' def protobufVersion = '3.25.8' -def grpcVersion = '1.75.0' +// keep same version as protoc-gen-grpc-java for arm64 or macOS, see rootProject.archInfo.requires.ProtocGenVersion +def grpcVersion = '1.81.0' dependencies { api group: 'com.google.protobuf', name: 'protobuf-java', version: protobufVersion