Skip to content

Commit a780ba1

Browse files
huzhenyuanhuzhenyuan
authored
Merge pull request #1412 from tronprotocol/longvalue_exact
Longvalue exact
2 parents f7d24a5 + 6d33f2a commit a780ba1

File tree

7 files changed

+93
-101
lines changed

7 files changed

+93
-101
lines changed

‎src/main/java/org/tron/common/runtime/Runtime.java‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -224,7 +224,7 @@ private long getEnergyLimit(AccountCapsule account, long feeLimit, long callValu
224224
if (leftBalanceForEnergyFreeze >= feeLimit) {
225225
energyFromFeeLimit = BigInteger.valueOf(totalEnergyFromFreeze)
226226
.multiply(BigInteger.valueOf(feeLimit))
227-
.divide(BigInteger.valueOf(totalBalanceForEnergyFreeze)).longValue();
227+
.divide(BigInteger.valueOf(totalBalanceForEnergyFreeze)).longValueExact();
228228
} else {
229229
energyFromFeeLimit = Math
230230
.addExact(leftEnergyFromFreeze,
@@ -326,7 +326,7 @@ private void create()
326326
AccountCapsule creator = this.deposit
327327
.getAccount(newSmartContract.getOriginAddress().toByteArray());
328328
// if (executorType == ET_NORMAL_TYPE) {
329-
// long blockENERGYLeftInUs = getBlockENERGYLeftInUs().longValue();
329+
// long blockENERGYLeftInUs = getBlockENERGYLeftInUs().longValueExact();
330330
// thisTxENERGYLimitInUs = min(blockENERGYLeftInUs,
331331
// Constant.ENERGY_LIMIT_IN_ONE_TX_OF_SMART_CONTRACT);
332332
// } else {
@@ -337,6 +337,7 @@ private void create()
337337
.getMaxCpuTimeOfOneTX() * 1000;
338338

339339
long thisTxCPULimitInUs = (long) (MAX_CPU_TIME_OF_ONE_TX * getThisTxCPULimitInUsRatio());
340+
340341
long vmStartInUs = System.nanoTime() / 1000;
341342
long vmShouldEndInUs = vmStartInUs + thisTxCPULimitInUs;
342343

@@ -413,12 +414,11 @@ private void call()
413414

414415
long feeLimit = trx.getRawData().getFeeLimit();
415416
long energyLimit;
416-
417417
if (isCallConstant(contractAddress)) {
418418
energyLimit = Constant.MAX_ENERGY_IN_TX;
419-
}
420-
else
419+
} else {
421420
energyLimit = getEnergyLimit(creator, caller, contract, feeLimit, callValue);
421+
}
422422

423423
ProgramInvoke programInvoke = programInvokeFactory
424424
.createProgramInvoke(TRX_CONTRACT_CALL_TYPE, executorType, trx,
@@ -498,7 +498,7 @@ private long getEnergyFee(long callerEnergyUsage, long callerEnergyFrozen,
498498
return 0;
499499
}
500500
return BigInteger.valueOf(callerEnergyFrozen).multiply(BigInteger.valueOf(callerEnergyUsage))
501-
.divide(BigInteger.valueOf(callerEnergyTotal)).longValue();
501+
.divide(BigInteger.valueOf(callerEnergyTotal)).longValueExact();
502502
}
503503

504504
public boolean isCallConstant() throws ContractValidateException {

‎src/main/java/org/tron/common/runtime/vm/PrecompiledContracts.java‎

Lines changed: 39 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -35,31 +35,25 @@
3535
import java.util.HashMap;
3636
import java.util.List;
3737
import lombok.extern.slf4j.Slf4j;
38-
import org.apache.commons.lang3.StringUtils;
3938
import org.apache.commons.lang3.tuple.Pair;
4039
import org.spongycastle.util.encoders.Hex;
4140
import org.tron.common.crypto.ECKey;
42-
import org.tron.common.crypto.Hash;
4341
import org.tron.common.crypto.zksnark.BN128;
4442
import org.tron.common.crypto.zksnark.BN128Fp;
4543
import org.tron.common.crypto.zksnark.BN128G1;
4644
import org.tron.common.crypto.zksnark.BN128G2;
4745
import org.tron.common.crypto.zksnark.Fp;
4846
import org.tron.common.crypto.zksnark.PairingCheck;
4947
import org.tron.common.runtime.vm.program.Program;
50-
import org.tron.common.runtime.vm.program.Program.PrecompiledContractException;
5148
import org.tron.common.runtime.vm.program.ProgramResult;
5249
import org.tron.common.storage.Deposit;
5350
import org.tron.common.utils.BIUtil;
5451
import org.tron.common.utils.ByteArray;
55-
import org.tron.common.utils.ByteUtil;
5652
import org.tron.common.utils.Sha256Hash;
57-
import org.tron.core.Constant;
5853
import org.tron.core.Wallet;
5954
import org.tron.core.actuator.Actuator;
6055
import org.tron.core.actuator.ActuatorFactory;
6156
import org.tron.core.capsule.TransactionCapsule;
62-
import org.tron.core.config.args.Args;
6357
import org.tron.core.exception.ContractExeException;
6458
import org.tron.core.exception.ContractValidateException;
6559
import org.tron.protos.Contract;
@@ -88,7 +82,7 @@ public class PrecompiledContracts {
8882
private static final BN128Multiplication altBN128Mul = new BN128Multiplication();
8983
private static final BN128Pairing altBN128Pairing = new BN128Pairing();
9084
private static final VoteWitnessNative voteContract = new VoteWitnessNative();
91-
// private static final FreezeBalanceNative freezeBalance = new FreezeBalanceNative();
85+
// private static final FreezeBalanceNative freezeBalance = new FreezeBalanceNative();
9286
// private static final UnfreezeBalanceNative unFreezeBalance = new UnfreezeBalanceNative();
9387
private static final WithdrawBalanceNative withdrawBalance = new WithdrawBalanceNative();
9488
private static final ProposalApproveNative proposalApprove = new ProposalApproveNative();
@@ -97,10 +91,11 @@ public class PrecompiledContracts {
9791
private static final ConvertFromTronBytesAddressNative convertFromTronBytesAddress = new ConvertFromTronBytesAddressNative();
9892
private static final ConvertFromTronBase58AddressNative convertFromTronBase58Address = new ConvertFromTronBase58AddressNative();
9993
private static final TransferAssetNative transferAsset = new TransferAssetNative();
100-
private static final GetTransferAssetNative getTransferAssetAmount = new GetTransferAssetNative();
94+
private static final GetTransferAssetNative getTransferAssetAmount = new GetTransferAssetNative();
10195

10296
private static final ECKey addressCheckECKey = new ECKey();
103-
private static final String addressCheckECKeyAddress = Wallet.encode58Check(addressCheckECKey.getAddress());
97+
private static final String addressCheckECKeyAddress = Wallet
98+
.encode58Check(addressCheckECKey.getAddress());
10499

105100

106101
private static final DataWord ecRecoverAddr = new DataWord(
@@ -121,7 +116,7 @@ public class PrecompiledContracts {
121116
"0000000000000000000000000000000000000000000000000000000000000008");
122117
private static final DataWord voteContractAddr = new DataWord(
123118
"0000000000000000000000000000000000000000000000000000000000010001");
124-
// private static final DataWord freezeBalanceAddr = new DataWord(
119+
// private static final DataWord freezeBalanceAddr = new DataWord(
125120
// "0000000000000000000000000000000000000000000000000000000000010002");
126121
// private static final DataWord unFreezeBalanceAddr = new DataWord(
127122
// "0000000000000000000000000000000000000000000000000000000000010003");
@@ -194,10 +189,18 @@ public static PrecompiledContract getContractForAddress(DataWord address) {
194189
}
195190

196191
// Byzantium precompiles
197-
if (address.equals(modExpAddr)) return modExp;
198-
if (address.equals(altBN128AddAddr)) return altBN128Add;
199-
if (address.equals(altBN128MulAddr)) return altBN128Mul;
200-
if (address.equals(altBN128PairingAddr)) return altBN128Pairing;
192+
if (address.equals(modExpAddr)) {
193+
return modExp;
194+
}
195+
if (address.equals(altBN128AddAddr)) {
196+
return altBN128Add;
197+
}
198+
if (address.equals(altBN128MulAddr)) {
199+
return altBN128Mul;
200+
}
201+
if (address.equals(altBN128PairingAddr)) {
202+
return altBN128Pairing;
203+
}
201204
return null;
202205
}
203206

@@ -423,7 +426,7 @@ public long getEnergyForData(byte[] data) {
423426
.multiply(BigInteger.valueOf(Math.max(adjExpLen, 1)))
424427
.divide(GQUAD_DIVISOR);
425428

426-
return isLessThan(energy, BigInteger.valueOf(Long.MAX_VALUE)) ? energy.longValue()
429+
return isLessThan(energy, BigInteger.valueOf(Long.MAX_VALUE)) ? energy.longValueExact()
427430
: Long.MAX_VALUE;
428431
}
429432

@@ -701,7 +704,7 @@ public long getEnergyForData(byte[] data) {
701704
@Override
702705
public Pair<Boolean, byte[]> execute(byte[] data) {
703706

704-
if (isRootCallConstant()){
707+
if (isRootCallConstant()) {
705708
return Pair.of(true, new DataWord(0).getData());
706709
}
707710
if (data == null || data.length != 2 * DataWord.DATAWORD_UNIT_SIZE) {
@@ -887,7 +890,7 @@ public long getEnergyForData(byte[] data) {
887890
@Override
888891
public Pair<Boolean, byte[]> execute(byte[] data) {
889892

890-
if (isRootCallConstant()){
893+
if (isRootCallConstant()) {
891894
return Pair.of(true, new DataWord(0).getData());
892895
}
893896

@@ -944,7 +947,7 @@ public long getEnergyForData(byte[] data) {
944947
@Override
945948
public Pair<Boolean, byte[]> execute(byte[] data) {
946949

947-
if (isRootCallConstant()){
950+
if (isRootCallConstant()) {
948951
return Pair.of(true, new DataWord(0).getData());
949952
}
950953

@@ -1008,11 +1011,12 @@ public long getEnergyForData(byte[] data) {
10081011
@Override
10091012
public Pair<Boolean, byte[]> execute(byte[] data) {
10101013

1011-
if (isRootCallConstant()){
1014+
if (isRootCallConstant()) {
10121015
return Pair.of(true, new DataWord(0).getData());
10131016
}
10141017

1015-
if (data == null || data.length == 0 || (data.length % (2 * DataWord.DATAWORD_UNIT_SIZE) != 0 )) {
1018+
if (data == null || data.length == 0 || (data.length % (2 * DataWord.DATAWORD_UNIT_SIZE)
1019+
!= 0)) {
10161020
return Pair.of(false, new DataWord(0).getData());
10171021
}
10181022

@@ -1078,7 +1082,7 @@ public long getEnergyForData(byte[] data) {
10781082
@Override
10791083
public Pair<Boolean, byte[]> execute(byte[] data) {
10801084

1081-
if (isRootCallConstant()){
1085+
if (isRootCallConstant()) {
10821086
return Pair.of(true, new DataWord(0).getData());
10831087
}
10841088

@@ -1175,8 +1179,7 @@ public Pair<Boolean, byte[]> execute(byte[] data) {
11751179
}
11761180

11771181
/**
1178-
* Native function for transferring Asset to another account. <br/>
1179-
* <br/>
1182+
* Native function for transferring Asset to another account. <br/> <br/>
11801183
*
11811184
* Input data[]: <br/> toAddress, amount, assetName <br/>
11821185
*
@@ -1192,11 +1195,12 @@ public long getEnergyForData(byte[] data) {
11921195
@Override
11931196
public Pair<Boolean, byte[]> execute(byte[] data) {
11941197

1195-
if (isRootCallConstant()){
1198+
if (isRootCallConstant()) {
11961199
return Pair.of(true, new DataWord(0).getData());
11971200
}
11981201

1199-
if (data == null || (data.length <= DataWord.DATAWORD_UNIT_SIZE * 2 || data.length > DataWord.DATAWORD_UNIT_SIZE * 3)) {
1202+
if (data == null || (data.length <= DataWord.DATAWORD_UNIT_SIZE * 2
1203+
|| data.length > DataWord.DATAWORD_UNIT_SIZE * 3)) {
12001204
return Pair.of(false, new DataWord(0).getData());
12011205
}
12021206

@@ -1206,20 +1210,20 @@ public Pair<Boolean, byte[]> execute(byte[] data) {
12061210
System.arraycopy(data, 32 + 16 + 8, amount, 0, 8);
12071211
// we already have a restrict for token name length, no more than 32 bytes. don't need to check again
12081212
byte[] name = new byte[32];
1209-
System.arraycopy(data, 64, name, 0, data.length-64);
1210-
int length =name.length;
1211-
while(length>0 && name[length -1] ==0){
1213+
System.arraycopy(data, 64, name, 0, data.length - 64);
1214+
int length = name.length;
1215+
while (length > 0 && name[length - 1] == 0) {
12121216
length--;
12131217
}
1214-
name = ByteArray.subArray(name,0,length);
1218+
name = ByteArray.subArray(name, 0, length);
12151219
Contract.TransferAssetContract.Builder builder = Contract.TransferAssetContract
12161220
.newBuilder();
12171221
builder.setOwnerAddress(ByteString.copyFrom(getCallerAddress()));
1218-
builder.setToAddress(ByteString.copyFrom(convertToTronAddress(new DataWord(toAddress).getLast20Bytes())));
1222+
builder.setToAddress(
1223+
ByteString.copyFrom(convertToTronAddress(new DataWord(toAddress).getLast20Bytes())));
12191224
builder.setAmount(Longs.fromByteArray(amount));
12201225
builder.setAssetName(ByteString.copyFrom(name));
12211226

1222-
12231227
TransferAssetContract contract = builder.build();
12241228

12251229
TransactionCapsule trx = new TransactionCapsule(contract,
@@ -1246,10 +1250,8 @@ public Pair<Boolean, byte[]> execute(byte[] data) {
12461250
}
12471251

12481252

1249-
12501253
/**
1251-
* Native function for check Asset balance basing on targetAddress and Asset name. <br/>
1252-
* <br/>
1254+
* Native function for check Asset balance basing on targetAddress and Asset name. <br/> <br/>
12531255
*
12541256
* Input data[]: <br/> address targetAddress, byte[] assetName <br/>
12551257
*
@@ -1274,11 +1276,11 @@ public Pair<Boolean, byte[]> execute(byte[] data) {
12741276
// we already have a restrict for token name length, no more than 32 bytes. don't need to check again
12751277
byte[] name = new byte[32];
12761278
System.arraycopy(data, 32, name, 0, 32);
1277-
int length =name.length;
1278-
while(length>0 && name[length -1] ==0){
1279+
int length = name.length;
1280+
while (length > 0 && name[length - 1] == 0) {
12791281
length--;
12801282
}
1281-
name = ByteArray.subArray(name,0,length);
1283+
name = ByteArray.subArray(name, 0, length);
12821284

12831285
long assetBalance = this.getDeposit().getDbManager().getAccountStore().
12841286
get(convertToTronAddress(new DataWord(targetAddress).getLast20Bytes())).

‎src/main/java/org/tron/common/runtime/vm/VM.java‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -71,7 +71,7 @@ private long calcMemEnergy(EnergyCost energyCosts, long oldMemSize, BigInteger n
7171
checkMemorySize(op, newMemSize);
7272

7373
// memory drop consume calc
74-
long memoryUsage = (newMemSize.longValue() + 31) / 32 * 32;
74+
long memoryUsage = (newMemSize.longValueExact() + 31) / 32 * 32;
7575
if (memoryUsage > oldMemSize) {
7676
long memWords = (memoryUsage / 32);
7777
long memWordsOld = (oldMemSize / 32);
@@ -258,7 +258,7 @@ public void step(Program program) {
258258
throw new OutOfEnergyException(
259259
"Not enough energy for '%s' operation executing: opEnergy[%d], programEnergy[%d]",
260260
op.name(),
261-
dataCost.longValue(), program.getEnergyLimitLeft().longValueSafe());
261+
dataCost.longValueExact(), program.getEnergyLimitLeft().longValueSafe());
262262
}
263263
energyCost = energyCosts.getLOG_ENERGY() +
264264
energyCosts.getLOG_TOPIC_ENERGY() * nTopics +
@@ -1331,7 +1331,7 @@ public void play(Program program) {
13311331
this.step(program);
13321332
}
13331333

1334-
} catch (JVMStackOverFlowException e){
1334+
} catch (JVMStackOverFlowException e) {
13351335
throw new JVMStackOverFlowException();
13361336
} catch (RuntimeException e) {
13371337
if (StringUtils.isEmpty(e.getMessage())) {

‎src/main/java/org/tron/common/runtime/vm/program/Program.java‎

Lines changed: 11 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -111,13 +111,13 @@ public static Boolean getRootCallConstant() {
111111
return isRootCallConstant;
112112
}
113113

114-
public static void setRootCallConstant(Boolean rootCallConstant) {
114+
public static void setRootCallConstant(Boolean rootCallConstant) {
115115
isRootCallConstant = rootCallConstant;
116116
}
117117

118118
private static long nonce = 0;
119119
private static byte[] rootTransactionId = null;
120-
private static Boolean isRootCallConstant = null;
120+
private static Boolean isRootCallConstant = null;
121121

122122
private InternalTransaction transaction;
123123

@@ -445,7 +445,7 @@ public void createContract(DataWord value, DataWord memStart, DataWord memSize)
445445

446446
byte[] senderAddress = convertToTronAddress(this.getOwnerAddress().getLast20Bytes());
447447
// todo: need check the value > 0?
448-
long endowment = value.value().longValue();
448+
long endowment = value.value().longValueExact();
449449
if (getContractState().getBalance(senderAddress) < endowment) {
450450
stackPushZero();
451451
return;
@@ -508,7 +508,7 @@ public void createContract(DataWord value, DataWord memStart, DataWord memSize)
508508
newBalance = deposit.addBalance(newAddress, endowment);
509509
}
510510

511-
// BlockchainConfig blockchainConfig = config.getBlockchainConfig().getConfigForBlock(getNumber().longValue());
511+
// BlockchainConfig blockchainConfig = config.getBlockchainConfig().getConfigForBlock(getNumber().longValueExact());
512512
// actual energy subtract
513513
DataWord energyLimit = this.getCreateEnergy(getEnergyLimitLeft());
514514
spendEnergy(energyLimit.longValue(), "internal call");
@@ -637,7 +637,7 @@ public void callToAddress(MessageCall msg) {
637637

638638
// 2.1 PERFORM THE VALUE (endowment) PART
639639
// todo: need to check value >= 0?
640-
long endowment = msg.getEndowment().value().longValue();
640+
long endowment = msg.getEndowment().value().longValueExact();
641641
long senderBalance = deposit.getBalance(senderAddress);
642642
if (senderBalance < endowment) {
643643
stackPushZero();
@@ -739,7 +739,7 @@ this, new DataWord(contextAddress),
739739
if (result != null) {
740740
BigInteger refundEnergy = msg.getEnergy().value().subtract(toBI(result.getEnergyUsed()));
741741
if (isPositive(refundEnergy)) {
742-
refundEnergy(refundEnergy.longValue(), "remaining energy from the internal call");
742+
refundEnergy(refundEnergy.longValueExact(), "remaining energy from the internal call");
743743
if (logger.isInfoEnabled()) {
744744
logger.info("The remaining energy refunded, account: [{}], energy: [{}] ",
745745
Hex.toHexString(senderAddress),
@@ -1278,7 +1278,7 @@ public void callToPrecompiledAddress(MessageCall msg,
12781278
byte[] contextAddress = msg.getType().callIsStateless() ? senderAddress : codeAddress;
12791279

12801280
// todo: need check endowment > 0 and not exceed?? because of "senderBalance < endowment"
1281-
long endowment = msg.getEndowment().value().longValue();
1281+
long endowment = msg.getEndowment().value().longValueExact();
12821282
long senderBalance = deposit.getBalance(senderAddress);
12831283
if (senderBalance < endowment) {
12841284
stackPushZero();
@@ -1291,9 +1291,10 @@ public void callToPrecompiledAddress(MessageCall msg,
12911291

12921292
// Charge for endowment - is not reversible by rollback
12931293
if (!ArrayUtils.isEmpty(senderAddress) && !ArrayUtils.isEmpty(contextAddress)
1294-
&& senderAddress != contextAddress && msg.getEndowment().value().longValue() > 0) {
1294+
&& senderAddress != contextAddress && msg.getEndowment().value().longValueExact() > 0) {
12951295
try {
1296-
transfer(deposit, senderAddress, contextAddress, msg.getEndowment().value().longValue());
1296+
transfer(deposit, senderAddress, contextAddress,
1297+
msg.getEndowment().value().longValueExact());
12971298
} catch (ContractValidateException e) {
12981299
throw new BytecodeExecutionException("transfer failure");
12991300
}
@@ -1490,7 +1491,7 @@ public static PrecompiledContractException contractExecuteException(TronExceptio
14901491
public static OutOfEnergyException energyOverflow(BigInteger actualEnergy,
14911492
BigInteger energyLimit) {
14921493
return new OutOfEnergyException("Energy value overflow: actualEnergy[%d], energyLimit[%d];",
1493-
actualEnergy.longValue(), energyLimit.longValue());
1494+
actualEnergy.longValueExact(), energyLimit.longValueExact());
14941495
}
14951496

14961497
public static IllegalOperationException invalidOpCode(byte... opCode) {

0 commit comments

Comments
 (0)