From f322441343e63f8deb46b7d3146b06ccbb03e9d6 Mon Sep 17 00:00:00 2001 From: sophiawang Date: Thu, 3 Jul 2025 15:16:14 +0800 Subject: [PATCH 01/15] add --experimental--via-ir for compile contract --- .../stest/tron/wallet/common/client/utils/PublicMethed.java | 6 +++--- .../dailybuild/tvmnewcommand/newGrammar/BlobTest.java | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java b/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java index 64fe5bd1..844edb30 100644 --- a/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java +++ b/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java @@ -5683,7 +5683,7 @@ public static HashMap getBycodeAbiNoOptimize( logger.debug("outputPath: " + outputPath); String cmd = compile - + " --bin --abi --overwrite " + + " --bin --abi --experimental--via-ir --overwrite " + absolutePath + "/" + solFile @@ -5740,7 +5740,7 @@ public synchronized static HashMap getBycodeAbi(String solFile, logger.debug("outputPath: " + outputPath); String cmd = compile - + " --optimize --evm-version cancun --bin --abi --overwrite " + + " --optimize --experimental--via-ir --bin --abi --overwrite " + absolutePath + "/" + solFile @@ -5798,7 +5798,7 @@ public synchronized static HashMap getBycodeAbiWithParam(String logger.debug("outputPath: " + outputPath); String cmd = compile - + " --optimize " + param +" --evm-version cancun --bin --abi --overwrite " + + " --optimize " + param +" --bin --abi --overwrite " + absolutePath + "/" + solFile diff --git a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/BlobTest.java b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/BlobTest.java index 9cc26b0b..2b3f4b75 100644 --- a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/BlobTest.java +++ b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/BlobTest.java @@ -55,7 +55,7 @@ public void beforeClass() { String filePath = "src/test/resources/soliditycode/blob.sol"; String contractName = "C"; - String compileParam = "--via-ir"; + String compileParam = "--experimental--via-ir"; HashMap retMap = PublicMethed.getBycodeAbiWithParam(filePath, contractName, compileParam); String code = retMap.get("byteCode").toString(); String abi = retMap.get("abI").toString(); From 5bb5757588ee72479713eedda459a1f5984e0eec Mon Sep 17 00:00:00 2001 From: sophiawang Date: Thu, 3 Jul 2025 17:57:39 +0800 Subject: [PATCH 02/15] change --experimental--via-ir into --experimental-via-ir --- .../stest/tron/wallet/common/client/utils/PublicMethed.java | 4 ++-- .../wallet/dailybuild/tvmnewcommand/newGrammar/BlobTest.java | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java b/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java index 844edb30..3f5d77a5 100644 --- a/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java +++ b/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java @@ -5683,7 +5683,7 @@ public static HashMap getBycodeAbiNoOptimize( logger.debug("outputPath: " + outputPath); String cmd = compile - + " --bin --abi --experimental--via-ir --overwrite " + + " --bin --abi --experimental-via-ir --overwrite " + absolutePath + "/" + solFile @@ -5740,7 +5740,7 @@ public synchronized static HashMap getBycodeAbi(String solFile, logger.debug("outputPath: " + outputPath); String cmd = compile - + " --optimize --experimental--via-ir --bin --abi --overwrite " + + " --optimize --experimental-via-ir --bin --abi --overwrite " + absolutePath + "/" + solFile diff --git a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/BlobTest.java b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/BlobTest.java index 2b3f4b75..3ef23141 100644 --- a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/BlobTest.java +++ b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/BlobTest.java @@ -55,7 +55,7 @@ public void beforeClass() { String filePath = "src/test/resources/soliditycode/blob.sol"; String contractName = "C"; - String compileParam = "--experimental--via-ir"; + String compileParam = "--experimental-via-ir"; HashMap retMap = PublicMethed.getBycodeAbiWithParam(filePath, contractName, compileParam); String code = retMap.get("byteCode").toString(); String abi = retMap.get("abI").toString(); From 23ed714b319d1dd15e7d926db8104d2c8052ec00 Mon Sep 17 00:00:00 2001 From: sophiawang Date: Wed, 9 Jul 2025 23:10:01 +0800 Subject: [PATCH 03/15] enable vote cases --- .../tvmnewcommand/newGrammar/TvmVote.java | 32 ++++++++----------- .../test/resources/soliditycode/tvmVote.sol | 10 +++--- 2 files changed, 20 insertions(+), 22 deletions(-) diff --git a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/TvmVote.java b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/TvmVote.java index 5ecba3cd..e89f27cd 100644 --- a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/TvmVote.java +++ b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/TvmVote.java @@ -59,12 +59,12 @@ public void beforeClass() throws Exception { .build(); blockingStubFull = WalletGrpc.newBlockingStub(channelFull); - if(PublicMethed.freezeV2ProposalIsOpen(blockingStubFull)) { - if (channelFull != null) { - channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); - } - throw new SkipException("Skipping freezeV2 test case"); - } +// if(PublicMethed.freezeV2ProposalIsOpen(blockingStubFull)) { +// if (channelFull != null) { +// channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); +// } +// throw new SkipException("Skipping freezeV2 test case"); +// } Assert.assertTrue(PublicMethed .sendcoin(contractExcAddress, 300100_000_000L, @@ -106,9 +106,9 @@ public void test01QueryRewardBalance() { @Test(enabled = true, description = "freeze balance and vote witness") public void test02VoteWitness() { - String methodStr = "freeze(address,uint256,uint256)"; + String methodStr = "freezev2(uint256,uint256)"; String receiverAdd = Base58.encode58Check(mapKeyContract); - String args = "\"" + receiverAdd + "\"," + freezeCount + ",1"; + String args = "" + freezeCount + ",1"; String triggerTxid = PublicMethed.triggerContract(mapKeyContract, methodStr, args, false, 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); @@ -120,7 +120,7 @@ public void test02VoteWitness() { transactionInfo.get().getReceipt().getResult()); Protocol.InternalTransaction internal = transactionInfo.get().getInternalTransactions(0); String note = internal.getNote().toStringUtf8(); - Assert.assertEquals("freezeForEnergy", note); + Assert.assertEquals("freezeBalanceV2ForEnergy", note); Assert.assertEquals(freezeCount, internal.getCallValueInfo(0).getCallValue()); String witness58Add = Base58.encode58Check(witnessAddress); @@ -279,8 +279,8 @@ public void test11WithdrawReward() { @Test(enabled = true, description = "unfreeze energy") public void test12Unfreeze() { - String methodStr = "unfreeze(address,uint256)"; - String args = "\"" + Base58.encode58Check(mapKeyContract) + "\",1"; + String methodStr = "unfreezev2(uint256,uint256)"; + String args = ""+freezeCount+",1"; String triggerTxid = PublicMethed.triggerContract(mapKeyContract, methodStr, args, false, 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); @@ -292,7 +292,7 @@ public void test12Unfreeze() { Protocol.InternalTransaction internal = transactionInfo.get().getInternalTransactions(0); String note = internal.getNote().toStringUtf8(); - Assert.assertEquals("unfreezeForEnergy", note); + Assert.assertEquals("unfreezeBalanceV2ForEnergy", note); Assert.assertEquals(freezeCount, internal.getCallValueInfo(0).getCallValue()); } @@ -305,13 +305,9 @@ public void test13Suicide() { PublicMethed.waitProduceNextBlock(blockingStubFull); Optional transactionInfo = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); - Assert.assertEquals(0, transactionInfo.get().getResultValue()); - Assert.assertEquals(Protocol.Transaction.Result.contractResult.SUCCESS, + Assert.assertEquals(1, transactionInfo.get().getResultValue()); + Assert.assertEquals(Protocol.Transaction.Result.contractResult.REVERT, transactionInfo.get().getReceipt().getResult()); - PublicMethed.waitProduceNextBlock(blockingStubFull); - SmartContractOuterClass.SmartContract smartContract = PublicMethed - .getContract(mapKeyContract, blockingStubFull); - Assert.assertEquals("", smartContract.getAbi().toString()); } diff --git a/testcase/src/test/resources/soliditycode/tvmVote.sol b/testcase/src/test/resources/soliditycode/tvmVote.sol index 214c7c6b..e512cdb6 100644 --- a/testcase/src/test/resources/soliditycode/tvmVote.sol +++ b/testcase/src/test/resources/soliditycode/tvmVote.sol @@ -9,8 +9,9 @@ contract TestVote { * @dev Freeze `amount` balance of contract to get resource for `receiver` * which type is `res` (0 for bandwidth, 1 for energy). */ - function freeze(address payable receiver, uint amount, uint res) external { - receiver.freeze(amount, res); + function freezev2(uint amount, uint res) external { + freezebalancev2(amount, res); +// emit BalanceFreezedV2(amount, res); } /** @@ -18,8 +19,9 @@ contract TestVote { * `receiver' and 'res' (0 for bandwidth, 1 for energy) parameters to * unfreeze specific balance. */ - function unfreeze(address payable receiver, uint res) external { - receiver.unfreeze(res); + function unfreezev2(uint amount, uint resourceType) external { + unfreezebalancev2(amount, resourceType); +// emit BalanceUnfreezedV2(amount, resourceType); } /** From c5672f02a833a5325025493e020442d5d97b9c99 Mon Sep 17 00:00:00 2001 From: sophiawang Date: Thu, 10 Jul 2025 11:23:59 +0800 Subject: [PATCH 04/15] add withdraw to freezev2 --- .../separateExecution/NewFreezeContractTest.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/testcase/src/test/java/stest/tron/wallet/dailybuild/separateExecution/NewFreezeContractTest.java b/testcase/src/test/java/stest/tron/wallet/dailybuild/separateExecution/NewFreezeContractTest.java index a3e28286..f2d17c7c 100644 --- a/testcase/src/test/java/stest/tron/wallet/dailybuild/separateExecution/NewFreezeContractTest.java +++ b/testcase/src/test/java/stest/tron/wallet/dailybuild/separateExecution/NewFreezeContractTest.java @@ -636,6 +636,7 @@ void test18UnfreezeTriggerPortialUnvote() { String witnessTB4 = "TB4B1RMhoPeivkj4Hebm6tttHjRY9yQFes"; String args = "[\"" + witnessTT1 + "\",\"" + witnessTB4 + "\"],[200,200]"; voteWitness(contractAddress, args); + withdrawReward(contractAddress); String methedStr = "unfreezeBalanceV2(uint256,uint256)"; String argsStr = "10000000,0"; String txid = PublicMethed.triggerContract(contractAddress, methedStr, argsStr, @@ -805,6 +806,21 @@ public void voteWitness(byte[] con, String args) { logger.info("transactionInfo: " + transactionInfo.toString()); } + public void withdrawReward(byte[] con) { + String methodStr = "withdrawReward()"; + + String triggerTxid = PublicMethed.triggerContract(con, methodStr, "#", false, + 0, maxFeeLimit, testFoundationAddress, testFoundationKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + TransactionInfo transactionInfo = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull).get(); + Assert.assertEquals(0, transactionInfo.getResultValue()); + Assert.assertEquals(contractResult.SUCCESS, + transactionInfo.getReceipt().getResult()); + + } + void create2NewFreezeContract() { String methedStr = "getPredictedAddress(bytes32)"; From 6aafacf14ae0e13c5cf4e8048fe45ea2120ee7cf Mon Sep 17 00:00:00 2001 From: sophiawang Date: Fri, 11 Jul 2025 19:55:47 +0800 Subject: [PATCH 05/15] add case for solidity v0.8.25 --- .../newGrammar/NewFeatureForSolc0825.java | 117 ++++++++++++++++++ .../resources/soliditycode/NewFeature0825.sol | 15 +++ 2 files changed, 132 insertions(+) create mode 100644 testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/NewFeatureForSolc0825.java create mode 100644 testcase/src/test/resources/soliditycode/NewFeature0825.sol diff --git a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/NewFeatureForSolc0825.java b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/NewFeatureForSolc0825.java new file mode 100644 index 00000000..3ce8793a --- /dev/null +++ b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/NewFeatureForSolc0825.java @@ -0,0 +1,117 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.newGrammar; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.codec.binary.Hex; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI; +import org.tron.api.WalletGrpc; +import org.tron.protos.Protocol; +import org.tron.protos.contract.SmartContractOuterClass; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.utils.ByteArray; +import stest.tron.wallet.common.client.utils.ECKey; +import stest.tron.wallet.common.client.utils.PublicMethed; +import stest.tron.wallet.common.client.utils.Utils; + +import java.util.HashMap; +import java.util.concurrent.TimeUnit; + +@Slf4j +public class NewFeatureForSolc0825 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + byte[] contractC = null; + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext() + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 11010_000_000L, + testNetAccountAddress, testNetAccountKey, blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/NewFeature0825.sol"; + String contractName = "C"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + Assert.assertTrue(code.contains("5e")); + contractC = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContractOuterClass.SmartContract smartContract = PublicMethed.getContract(contractC, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + + @Test(enabled = true, description = "Code Generator: Use ``MCOPY`` instead of ``MLOAD``/``MSTORE`` loop " + + "when copying byte arrays.") + public void test001CopyBytes() { + String txid = PublicMethed + .triggerContract(contractC,"copyBytes()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Protocol.TransactionInfo info = PublicMethed.getTransactionInfoById(txid, blockingStubFull).get(); + Assert.assertEquals(Protocol.TransactionInfo.code.SUCESS, info.getResult()); + String out = ByteArray.toHexString(info.getContractResult(0).toByteArray()).substring(128); + Assert.assertEquals("6161616161000000000000000000000000000000000000000000000000000000", out); +// out.equalsIgnoreCase("6161616161000000000000000000000000000000000000000000000000000000") + } + + @Test(enabled = true, description = "Code Generator: Use ``MCOPY`` instead of ``MLOAD``/``MSTORE`` loop " + + "when copying byte arrays.") + public void test002CopyString() { + String txid = PublicMethed + .triggerContract(contractC, "copyString()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Protocol.TransactionInfo info = PublicMethed.getTransactionInfoById(txid, blockingStubFull).get(); + Assert.assertEquals(Protocol.TransactionInfo.code.SUCESS, info.getResult()); + String out = ByteArray.toHexString(info.getContractResult(0).toByteArray()).substring(128); + Assert.assertEquals("72657475726e20737472696e6700000000000000000000000000000000000000", out); + + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + PublicMethed.freedResource(contractExcAddress, contractExcKey, + testNetAccountAddress, blockingStubFull); + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} + diff --git a/testcase/src/test/resources/soliditycode/NewFeature0825.sol b/testcase/src/test/resources/soliditycode/NewFeature0825.sol new file mode 100644 index 00000000..86b04bad --- /dev/null +++ b/testcase/src/test/resources/soliditycode/NewFeature0825.sol @@ -0,0 +1,15 @@ +// SPDX-License-Identifier: GPL-3.0 +pragma solidity >=0.0.0; + +contract C { + function copyBytes() external returns (bytes memory) + { + bytes memory ret = "aaaaa"; + return ret; + } + + function copyString() external returns (string memory) + { + return "return string"; + } +} From de8edfb461115dd1532a0888d29129935a4ccfde Mon Sep 17 00:00:00 2001 From: sophiawang Date: Fri, 11 Jul 2025 19:56:51 +0800 Subject: [PATCH 06/15] delete useless code --- .../tvmnewcommand/newGrammar/NewFeatureForSolc0825.java | 1 - 1 file changed, 1 deletion(-) diff --git a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/NewFeatureForSolc0825.java b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/NewFeatureForSolc0825.java index 3ce8793a..5db72b55 100644 --- a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/NewFeatureForSolc0825.java +++ b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/NewFeatureForSolc0825.java @@ -83,7 +83,6 @@ public void test001CopyBytes() { Assert.assertEquals(Protocol.TransactionInfo.code.SUCESS, info.getResult()); String out = ByteArray.toHexString(info.getContractResult(0).toByteArray()).substring(128); Assert.assertEquals("6161616161000000000000000000000000000000000000000000000000000000", out); -// out.equalsIgnoreCase("6161616161000000000000000000000000000000000000000000000000000000") } @Test(enabled = true, description = "Code Generator: Use ``MCOPY`` instead of ``MLOAD``/``MSTORE`` loop " + From 757a6fccfb5f86c590ca9fec090064419356b296 Mon Sep 17 00:00:00 2001 From: sophiawang Date: Mon, 14 Jul 2025 12:16:29 +0800 Subject: [PATCH 07/15] add contract cases for "warning first occurrence of tstore" --- .../src/test/resources/soliditycode/NewFeature0825.sol | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/testcase/src/test/resources/soliditycode/NewFeature0825.sol b/testcase/src/test/resources/soliditycode/NewFeature0825.sol index 86b04bad..7949ae71 100644 --- a/testcase/src/test/resources/soliditycode/NewFeature0825.sol +++ b/testcase/src/test/resources/soliditycode/NewFeature0825.sol @@ -12,4 +12,14 @@ contract C { { return "return string"; } + +//Yul Analyzer: Emit transient storage warning only for the first occurrence of ``tstore``. + function warnTstore() external { + assembly { + tstore(0, 0) + tstore(0, 1) + } + } + + } From 696649de83ea689b04d7c1a7f349f233a379f0c4 Mon Sep 17 00:00:00 2001 From: sophiawang Date: Wed, 23 Jul 2025 14:54:37 +0800 Subject: [PATCH 08/15] add cases for push13-15,17-19,22-27,30 --- .../tvmnewcommand/newGrammar/Opcode.java | 23 ++++++---- .../test/resources/soliditycode/opCode.sol | 46 ++++++++++++------- 2 files changed, 43 insertions(+), 26 deletions(-) diff --git a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/Opcode.java b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/Opcode.java index ddb58e3f..9b484142 100644 --- a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/Opcode.java +++ b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/Opcode.java @@ -263,16 +263,19 @@ public void test08Swap() { @Test(enabled = true, description = "test opcode push13-30 but exclude push20 and push29," + "solidity cannot use optimize") public void test08Pushx() { - GrpcAPI.TransactionExtention transactionExtention = PublicMethed - .triggerConstantContractForExtention(mapKeyContract, - "pppushx()", "#", true, - 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); - Protocol.Transaction transaction = transactionExtention.getTransaction(); - String trueRes = ByteArray.toHexString(transactionExtention.getConstantResult(0).toByteArray()); - logger.info("truerRes: " + trueRes + " message:" + transaction.getRet(0).getRet()); - Assert.assertEquals("SUCESS", transaction.getRet(0).getRet().toString()); - Assert.assertTrue(trueRes.contains("000000000000000000000000000000000000001" - + "1223344556677889900112233")); + GrpcAPI.TransactionExtention transactionExtention; + for(int i=13;i<31;i++){ + transactionExtention = PublicMethed + .triggerConstantContractForExtention(mapKeyContract, + "pppushx(int8)", ""+i, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + Protocol.Transaction transaction = transactionExtention.getTransaction(); + String trueRes = ByteArray.toHexString(transactionExtention.getConstantResult(0).toByteArray()); + logger.info("truerRes: " + trueRes + " message:" + transaction.getRet(0).getRet()); + Assert.assertEquals("SUCESS", transaction.getRet(0).getRet().toString()); +// Assert.assertTrue(trueRes.contains("000000000000000000000000000000000000001" +// + "1223344556677889900112233")); + } } @Test(enabled = true, description = "test opcode callcode,difference with delegatecall " diff --git a/testcase/src/test/resources/soliditycode/opCode.sol b/testcase/src/test/resources/soliditycode/opCode.sol index b285a254..f91ef645 100644 --- a/testcase/src/test/resources/soliditycode/opCode.sol +++ b/testcase/src/test/resources/soliditycode/opCode.sol @@ -68,23 +68,37 @@ contract A { return (a); } - function pppushx() public returns (uint256) { + + function pppushx(int8 index) public returns (uint256) { + if(index == 13){ return 0x11223344556677889900112233; //push13 -// return 0x1122334455667788990011223344; //push14 -// return 0x112233445566778899001122334455; //push15 -// return 0x11223344556677889900112233445566; //push16 -// return 0x1122334455667788990011223344556611; //push17 -// return 0x112233445566778899001122334455661111; //push18 -// return 0x11223344556677889900112233445566111111; //push19 -// return 0x112233445566778899001122334455661111111111; //push21 -// return 0x11223344556677889900112233445566111111111111; //push22 -// return 0x1122334455667788990011223344556611111111111111; //push23 -// return 0x112233445566778899001122334455661111111111111111; //push24 -// return 0x11223344556677889900112233445566111111111111111111; //push25 -// return 0x1122334455667788990011223344556611111111111111111111; //push26 -// return 0x112233445566778899001122334455661111111111111111111111; //push27 -// return 0x11223344556677889900112233445566111111111111111111111111; //push28 -// return 0x112233445566778899001122334455661111111111111111111111111111; //push30 + }else if(index == 14){ + return 0x1122334455667788990011223344; + }else if(index == 15){ + return 0x112233445566778899001122334455; + }else if(index == 17){ + return 0x1122334455667788990011223344556677; + }else if(index == 18){ + return 0x112233445566778899001122334455667788; + }else if(index == 19){ + return 0x11223344556677889900112233445566111111; //push19 + }else if(index == 22){ + return 0x11223344556677889900112233445566111111111111; //push22 + }else if(index == 23){ + return 0x1122334455667788990011223344556611111111111111; //push23 + }else if(index == 24){ + return 0x112233445566778899001122334455661111111111111111; //push24 + }else if(index == 25){ + return 0x11223344556677889900112233445566111111111111111111; //push25 + }else if(index == 26){ + return 0x1122334455667788990011223344556611111111111111111111; //push26 + }else if(index == 27){ + return 0x112233445566778899001122334455661111111111111111111111; //push27 + }else if(index == 30){ + return 0x112233445566778899001122334455661111111111111111111111111111; //push30 + }else{ + return 0x01; + } } // for test09Callcode From eadda5583643873a0f43961635c5e9d48b84ddee Mon Sep 17 00:00:00 2001 From: sophiawang Date: Wed, 23 Jul 2025 16:05:48 +0800 Subject: [PATCH 09/15] add cases for swap14-16 --- .../common/client/utils/PublicMethed.java | 2 +- .../tvmnewcommand/newGrammar/Opcode.java | 31 ++++++++++--- .../test/resources/soliditycode/opCode.sol | 43 +++++++++++++++++-- 3 files changed, 65 insertions(+), 11 deletions(-) diff --git a/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java b/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java index 3f5d77a5..a6e72f3f 100644 --- a/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java +++ b/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java @@ -5683,7 +5683,7 @@ public static HashMap getBycodeAbiNoOptimize( logger.debug("outputPath: " + outputPath); String cmd = compile - + " --bin --abi --experimental-via-ir --overwrite " + + " --bin --abi --overwrite " + absolutePath + "/" + solFile diff --git a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/Opcode.java b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/Opcode.java index 9b484142..a1d0a3c4 100644 --- a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/Opcode.java +++ b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/Opcode.java @@ -248,12 +248,31 @@ public void test07Msize() { @Test(enabled = true, description = "test opcode swap14-16,solidity cannot use optimize") public void test08Swap() { - GrpcAPI.TransactionExtention transactionExtention = PublicMethed - .triggerConstantContractForExtention(mapKeyContract, - "ssswap()", "#", true, - 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); - Protocol.Transaction transaction = transactionExtention.getTransaction(); - int trueRes = ByteArray.toInt(transactionExtention.getConstantResult(0).toByteArray()); + GrpcAPI.TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(mapKeyContract, + "ssswap14()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + Protocol.Transaction transaction = transactionExtention.getTransaction(); + int trueRes = ByteArray.toInt(transactionExtention.getConstantResult(0).toByteArray()); + logger.info("truerRes: " + trueRes + " message:" + transaction.getRet(0).getRet()); + Assert.assertEquals("SUCESS", transaction.getRet(0).getRet().toString()); + Assert.assertEquals(1, trueRes); + transactionExtention = PublicMethed + .triggerConstantContractForExtention(mapKeyContract, + "ssswap15()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + transaction = transactionExtention.getTransaction(); + trueRes = ByteArray.toInt(transactionExtention.getConstantResult(0).toByteArray()); + logger.info("truerRes: " + trueRes + " message:" + transaction.getRet(0).getRet()); + Assert.assertEquals("SUCESS", transaction.getRet(0).getRet().toString()); + Assert.assertEquals(1, trueRes); + + transactionExtention = PublicMethed + .triggerConstantContractForExtention(mapKeyContract, + "ssswap16()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + transaction = transactionExtention.getTransaction(); + trueRes = ByteArray.toInt(transactionExtention.getConstantResult(0).toByteArray()); logger.info("truerRes: " + trueRes + " message:" + transaction.getRet(0).getRet()); Assert.assertEquals("SUCESS", transaction.getRet(0).getRet().toString()); Assert.assertEquals(1, trueRes); diff --git a/testcase/src/test/resources/soliditycode/opCode.sol b/testcase/src/test/resources/soliditycode/opCode.sol index f91ef645..63ff399a 100644 --- a/testcase/src/test/resources/soliditycode/opCode.sol +++ b/testcase/src/test/resources/soliditycode/opCode.sol @@ -49,7 +49,7 @@ contract A { // } // } - function ssswap() public returns (int a) { + function ssswap14() public returns (int a) { int a=1; int b=2; int c=3; @@ -62,9 +62,44 @@ contract A { int b1=2; int c1=3; int d1=3; - int e1=3; //swap 14 - int f1=3; //swap 15 - int g1=3; //swap 16 + int e1=3; + return (a); + } + + function ssswap15() public returns (int a) { + int a=1; + int b=2; + int c=3; + int d=3; + int e=3; + int f=3; + int g=3; + int h=3; + int a1=1; + int b1=2; + int c1=3; + int d1=3; + int e1=3; + int f1=3; + return (a); + } + + function ssswap16() public returns (int a) { + int a=1; + int b=2; + int c=3; + int d=3; + int e=3; + int f=3; + int g=3; + int h=3; + int a1=1; + int b1=2; + int c1=3; + int d1=3; + int e1=3; + int f1=3; + int g1=3; return (a); } From b1a68559f417a4ac4a1b29b196e016aa73a3346b Mon Sep 17 00:00:00 2001 From: sophiawang Date: Wed, 13 Aug 2025 17:35:26 +0800 Subject: [PATCH 10/15] remove "--experimental-via-ir" from PublicMethed.getBycodeAbi add NewFeatureForSolc086WithVIAIR.java for "--experimental-via-ir" param, compared with NewFeatureForSolc086.java which is without "--experimental-via-ir" --- .../common/client/utils/PublicMethed.java | 2 +- .../NewFeatureForSolc086WithVIAIR.java | 297 ++++++++++++++++++ 2 files changed, 298 insertions(+), 1 deletion(-) create mode 100644 testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/NewFeatureForSolc086WithVIAIR.java diff --git a/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java b/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java index a6e72f3f..0dd7d320 100644 --- a/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java +++ b/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java @@ -5740,7 +5740,7 @@ public synchronized static HashMap getBycodeAbi(String solFile, logger.debug("outputPath: " + outputPath); String cmd = compile - + " --optimize --experimental-via-ir --bin --abi --overwrite " + + " --optimize --bin --abi --overwrite " + absolutePath + "/" + solFile diff --git a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/NewFeatureForSolc086WithVIAIR.java b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/NewFeatureForSolc086WithVIAIR.java new file mode 100644 index 00000000..920450be --- /dev/null +++ b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/NewFeatureForSolc086WithVIAIR.java @@ -0,0 +1,297 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.newGrammar; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI; +import org.tron.api.WalletGrpc; +import org.tron.protos.Protocol; +import org.tron.protos.contract.SmartContractOuterClass; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.utils.*; + +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; + +@Slf4j +public class NewFeatureForSolc086WithVIAIR { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + byte[] mapKeyContract = null; + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private Long energyFee = 0L; + + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext() + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 300100_000_000L, + testNetAccountAddress, testNetAccountKey, blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + String filePath = "src/test/resources/soliditycode/NewFeature086.sol"; + String contractName = "C"; + HashMap retMap = PublicMethed.getBycodeAbiWithParam(filePath, contractName,"--experimental-via-ir"); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + mapKeyContract = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 500000000L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContractOuterClass.SmartContract smartContract = PublicMethed.getContract(mapKeyContract, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + energyFee = PublicMethed.getChainParametersValue( + ProposalEnum.GetEnergyFee.getProposalName(), blockingStubFull); + + } + + + @Test(enabled = true, description = "catch assert fail") + public void test01TrtCatchAssertFail() { + GrpcAPI.TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(mapKeyContract, + "catchAssertFail()", "#", true, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + int trueRes = ByteArray.toInt(transactionExtention.getConstantResult(0).toByteArray()); + Assert.assertEquals(true, transactionExtention.getResult().getResult()); + Assert.assertEquals("SUCESS", + transactionExtention.getTransaction().getRet(0).getRet().toString()); + Assert.assertEquals(1, trueRes); + + } + + @Test(enabled = true, description = "catch under flow") + public void test02CatchUnderFlow() { + GrpcAPI.TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(mapKeyContract, + "catchUnderFlow()", "#", true, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + int trueRes = ByteArray.toInt(transactionExtention.getConstantResult(0).toByteArray()); + Assert.assertEquals(true, transactionExtention.getResult().getResult()); + Assert.assertEquals("SUCESS", + transactionExtention.getTransaction().getRet(0).getRet().toString()); + Assert.assertEquals(17, trueRes); + + } + + @Test(enabled = true, description = "catch divide zero") + public void test03CatchDivideZero() { + GrpcAPI.TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(mapKeyContract, + "catchDivideZero()", "#", true, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + int trueRes = ByteArray.toInt(transactionExtention.getConstantResult(0).toByteArray()); + Assert.assertEquals(true, transactionExtention.getResult().getResult()); + Assert.assertEquals("SUCESS", + transactionExtention.getTransaction().getRet(0).getRet().toString()); + Assert.assertEquals(18, trueRes); + } + + @Test(enabled = true, description = "get address code length") + public void test04GetAddressCodeLength() { + String triggerTxid = PublicMethed.triggerContract(mapKeyContract, "getAddressCodeLength()", + "#", false, 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional transactionInfo = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + Assert.assertEquals(0, transactionInfo.get().getResultValue()); + Assert.assertEquals(Protocol.Transaction.Result.contractResult.SUCCESS, + transactionInfo.get().getReceipt().getResult()); + //as compile contract with --experimental-via-ir, trigger costs more energy than no via-ir + Assert.assertEquals(401, transactionInfo.get().getReceipt().getEnergyUsageTotal()); + } + + @Test(enabled = true, description = "fix kecca256 bug: differt length return same code") + public void test05Kecca256BugFix() { + String args = "\"abcd123\""; + String triggerTxid = PublicMethed.triggerContract(mapKeyContract, "keccak256Bug(string)", + args, false, 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional transactionInfo = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + Assert.assertEquals(0, transactionInfo.get().getResultValue()); + Assert.assertEquals(Protocol.Transaction.Result.contractResult.SUCCESS, + transactionInfo.get().getReceipt().getResult()); + Assert.assertEquals(0, + ByteArray.toInt(transactionInfo.get().getContractResult(0).toByteArray())); + logger.info(transactionInfo.toString()); + } + + @Test(enabled = true, description = "revert error type with params") + public void test06RevertErrorType() { + String args = "\"T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb\",1000000000"; + String triggerTxid = PublicMethed.triggerContract(mapKeyContract, "transfer(address,uint256)", + args, false, 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional transactionInfo = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + logger.info(transactionInfo.toString()); + Assert.assertEquals(1, transactionInfo.get().getResultValue()); + Assert.assertEquals(Protocol.Transaction.Result.contractResult.REVERT, + transactionInfo.get().getReceipt().getResult()); + Assert.assertEquals("cf479181", + ByteArray.toHexString(transactionInfo.get() + .getContractResult(0).substring(0, 4).toByteArray())); + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000000", + ByteArray.toHexString(transactionInfo.get().getContractResult(0) + .substring(4, 36).toByteArray())); + Assert.assertEquals("000000000000000000000000000000000000000000000000000000003b9aca00", + ByteArray.toHexString(transactionInfo.get().getContractResult(0) + .substring(36, 68).toByteArray())); + + } + + @Test(enabled = true, description = "revert error type no params") + public void test07RevertErrorType() { + String triggerTxid = PublicMethed.triggerContract(mapKeyContract, "withdraw()", "#", false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional transactionInfo = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + Assert.assertEquals(1, transactionInfo.get().getResultValue()); + Assert.assertEquals(Protocol.Transaction.Result.contractResult.REVERT, + transactionInfo.get().getReceipt().getResult()); + Assert.assertEquals("82b42900", + ByteArray.toHexString(transactionInfo.get().getContractResult(0) + .substring(0, 4).toByteArray())); + } + + @Test(enabled = true, description = "test bytes concat") + public void test08bytesConcat() { + String args = "\"0x1234\",\"p2\",\"0x48e2f56f2c57e3532146eef2587a2a72\""; + GrpcAPI.TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(mapKeyContract, + "bytesConcat(bytes,string,bytes16)", args, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + Assert.assertEquals(true, transactionExtention.getResult().getResult()); + Assert.assertEquals("SUCESS", + transactionExtention.getTransaction().getRet(0).getRet().toString()); + int trueRes = ByteArray.toInt(transactionExtention.getConstantResult(0).toByteArray()); + Assert.assertEquals(36, trueRes); + } + + @Test(enabled = true, description = "test emit event") + public void test09EmitEvent() { + String triggerTxid = PublicMethed.triggerContract(mapKeyContract, "testEmitEvent()", "#", false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional transactionInfo = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + logger.info(transactionInfo.toString()); + Assert.assertEquals(0, transactionInfo.get().getResultValue()); + Assert.assertEquals(Protocol.Transaction.Result.contractResult.SUCCESS, + transactionInfo.get().getReceipt().getResult()); + Assert.assertEquals(6, + ByteArray.toInt(transactionInfo.get().getLog(0).getData().toByteArray())); + } + + + @Test(enabled = true, description = "test bytes convert to byteN overflow") + public void test10Bytes2ByteN() { + String args = "\"0x12345678\""; + String triggerTxid = PublicMethed.triggerContract(mapKeyContract, "bytes2BytesN(bytes)", + args, false, 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional transactionInfo = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + logger.info(transactionInfo.toString()); + Assert.assertEquals(0, transactionInfo.get().getResultValue()); + Assert.assertEquals(Protocol.Transaction.Result.contractResult.SUCCESS, + transactionInfo.get().getReceipt().getResult()); + Assert.assertEquals("1234560000000000000000000000000000000000000000000000000000000000", + ByteArray.toHexString(transactionInfo.get().getContractResult(0).toByteArray())); + } + + @Test(enabled = true, description = "test bytes convert to byteN underflow") + public void test11Bytes2ByteN() { + String args = "\"0x1234\""; + String triggerTxid = PublicMethed.triggerContract(mapKeyContract, "bytes2BytesN(bytes)", + args, false, 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional transactionInfo = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + logger.info(transactionInfo.toString()); + Assert.assertEquals(0, transactionInfo.get().getResultValue()); + Assert.assertEquals(Protocol.Transaction.Result.contractResult.SUCCESS, + transactionInfo.get().getReceipt().getResult()); + Assert.assertEquals("1234000000000000000000000000000000000000000000000000000000000000", + ByteArray.toHexString(transactionInfo.get().getContractResult(0).toByteArray())); + } + + @Test(enabled = true, description = "get contract address by different function") + public void test12GetConcatAddress() { + GrpcAPI.TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(mapKeyContract, + "getContractAddress()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + Assert.assertEquals(true, transactionExtention.getResult().getResult()); + Assert.assertEquals("SUCESS", + transactionExtention.getTransaction().getRet(0).getRet().toString()); + String res1 = ByteArray.toHexString(transactionExtention.getConstantResult(0) + .substring(0, 32).toByteArray()); + String res2 = ByteArray.toHexString(transactionExtention.getConstantResult(0) + .substring(32, 64).toByteArray()); + Assert.assertEquals(res1, res2); + } + + @Test(enabled = true, description = "test bytes concat with empty string") + public void test13bytesConcatWithEmptyStr() { + GrpcAPI.TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(mapKeyContract, + "bytesConcatWithEmptyStr()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + Assert.assertEquals(true, transactionExtention.getResult().getResult()); + Assert.assertEquals("SUCESS", + transactionExtention.getTransaction().getRet(0).getRet().toString()); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + PublicMethed.freedResource(contractExcAddress, contractExcKey, + testNetAccountAddress, blockingStubFull); + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} + From e6056ebf5e97a8560b037509dd886179ddcc7b59 Mon Sep 17 00:00:00 2001 From: sophiawang Date: Wed, 13 Aug 2025 17:41:14 +0800 Subject: [PATCH 11/15] remove unused space --- .../stest/tron/wallet/common/client/utils/PublicMethed.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java b/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java index 0dd7d320..bbb65a34 100644 --- a/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java +++ b/testcase/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java @@ -5683,7 +5683,7 @@ public static HashMap getBycodeAbiNoOptimize( logger.debug("outputPath: " + outputPath); String cmd = compile - + " --bin --abi --overwrite " + + " --bin --abi --overwrite " + absolutePath + "/" + solFile From a04901b52d982954f3157bcba98dd48c44641e1b Mon Sep 17 00:00:00 2001 From: sophiawang Date: Wed, 13 Aug 2025 18:09:17 +0800 Subject: [PATCH 12/15] delegatecall can not trans msg.tokenid and msg.tokenvalue --- .../src/test/resources/soliditycode/contractTrcToken027.sol | 2 ++ 1 file changed, 2 insertions(+) diff --git a/testcase/src/test/resources/soliditycode/contractTrcToken027.sol b/testcase/src/test/resources/soliditycode/contractTrcToken027.sol index e7d6ee76..8580ae6a 100644 --- a/testcase/src/test/resources/soliditycode/contractTrcToken027.sol +++ b/testcase/src/test/resources/soliditycode/contractTrcToken027.sol @@ -17,6 +17,8 @@ contract B{ constructor() public payable{} fallback() external payable{} function transC(address callCAddress,address toAddress,uint256 amount, trcToken id) payable public{ + require(msg.tokenid == 0); + require(msg.tokenvalue == 0); callCAddress.call(abi.encodeWithSignature("trans(address,uint256,trcToken)",toAddress,amount,id)); } } From f7fa27b292cd640871807531cdd8fac4db6c5ef1 Mon Sep 17 00:00:00 2001 From: sophiawang Date: Thu, 14 Aug 2025 11:15:08 +0800 Subject: [PATCH 13/15] adjust energy to solidity v0.8.25 --- .../tvmnewcommand/newGrammar/EnergyAdjustmentTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/EnergyAdjustmentTest.java b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/EnergyAdjustmentTest.java index 97a1e7c7..6486d650 100644 --- a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/EnergyAdjustmentTest.java +++ b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/EnergyAdjustmentTest.java @@ -164,7 +164,7 @@ void sucideToActiveAcount02() { logger.info("sucideToActiveAcount02 info: " + info.toString()); Assert.assertEquals(code.SUCESS, info.getResult()); Assert.assertEquals(contractResult.SUCCESS, info.getReceipt().getResult()); - Assert.assertEquals(27283, info.getReceipt().getEnergyUsageTotal()); + Assert.assertEquals(26993, info.getReceipt().getEnergyUsageTotal()); String contractC = PublicMethed.queryAccount(contractAddressC, blockingStubFull).toString(); System.out.println("contractC ccc: " + contractC); Assert.assertEquals("", contractC); @@ -198,7 +198,7 @@ void sucideToActiveAcount03() { logger.info("sucideToActiveAcount03 info: " + info.toString()); Assert.assertEquals(code.SUCESS, info.getResult()); Assert.assertEquals(contractResult.SUCCESS, info.getReceipt().getResult()); - Assert.assertEquals(52283, info.getReceipt().getEnergyUsageTotal()); + Assert.assertEquals(51993, info.getReceipt().getEnergyUsageTotal()); String contractC = PublicMethed.queryAccount(contractAddressC, blockingStubFull).toString(); System.out.println("contractC ccc: " + contractC); Assert.assertEquals("", contractC); From 60b2cafc2efec0a71dad91bd477337544bd507e8 Mon Sep 17 00:00:00 2001 From: sophiawang Date: Thu, 14 Aug 2025 16:31:09 +0800 Subject: [PATCH 14/15] rename method name --- .../tvmnewcommand/newGrammar/NewFeatureForSolc0825.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/NewFeatureForSolc0825.java b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/NewFeatureForSolc0825.java index 5db72b55..f4e9f27a 100644 --- a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/NewFeatureForSolc0825.java +++ b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/newGrammar/NewFeatureForSolc0825.java @@ -73,7 +73,7 @@ public void beforeClass() { @Test(enabled = true, description = "Code Generator: Use ``MCOPY`` instead of ``MLOAD``/``MSTORE`` loop " + "when copying byte arrays.") - public void test001CopyBytes() { + public void test001McopyCopyBytes() { String txid = PublicMethed .triggerContract(contractC,"copyBytes()", "#", false, 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); @@ -87,7 +87,7 @@ public void test001CopyBytes() { @Test(enabled = true, description = "Code Generator: Use ``MCOPY`` instead of ``MLOAD``/``MSTORE`` loop " + "when copying byte arrays.") - public void test002CopyString() { + public void test002McopyCopyString() { String txid = PublicMethed .triggerContract(contractC, "copyString()", "#", false, 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); From 705177f8be7b0f4ea3e7d55bc82d9a844ab6211f Mon Sep 17 00:00:00 2001 From: sophiawang Date: Fri, 29 Aug 2025 14:11:05 +0800 Subject: [PATCH 15/15] fix zenproof cases --- .../zenProofCommand/VerifyMintProof001.java | 18 +++++++++++++---- .../verifyTransferProof001.java | 20 +++++++++++++++++-- 2 files changed, 32 insertions(+), 6 deletions(-) diff --git a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/zenProofCommand/VerifyMintProof001.java b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/zenProofCommand/VerifyMintProof001.java index 1b06b921..2e18ac41 100644 --- a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/zenProofCommand/VerifyMintProof001.java +++ b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/zenProofCommand/VerifyMintProof001.java @@ -443,10 +443,20 @@ public void verifyMintProofTest006() { logger.info("infoById : " + infoById); Assert.assertEquals(0, infoById.get().getResultValue()); - String contractResult = ByteArray.toHexString(infoById.get() - .getContractResult(0).toByteArray()); - - Assert.assertTrue(contractResult.length() > 1000); + String contractResult = ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()); + +// Assert.assertTrue(contractResult.length() > 1000); + String offset = contractResult.substring(0,64); + String length = contractResult.substring(64,128); + //data1: 1:success + String data1 = contractResult.substring(128,192); + String data2 = contractResult.substring(192,256); + String data3 = contractResult.substring(256,320); + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000020", offset); + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000003", length); + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000001", data1); + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000000", data2); + Assert.assertEquals("39e261b362110781a20878cc19f480cb50df5e6b896ed9a1fea8b8a9a4239a17", data3); } diff --git a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/zenProofCommand/verifyTransferProof001.java b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/zenProofCommand/verifyTransferProof001.java index 39eb38c2..cf791e32 100644 --- a/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/zenProofCommand/verifyTransferProof001.java +++ b/testcase/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/zenProofCommand/verifyTransferProof001.java @@ -772,8 +772,24 @@ public void test08Normal() { Optional infoById = PublicMethed .getTransactionInfoById(txid, blockingStubFull); Assert.assertEquals(0, infoById.get().getResultValue()); - Assert.assertTrue( - ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()).length() > 10000); +// Assert.assertTrue( +// ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()).length() > 10000); + String result = ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()); + String offset = result.substring(0,64); + String length = result.substring(64,128); + String data1 = result.substring(128,192); + String data2 = result.substring(192,256); + String data3 = result.substring(256,320); + String data4 = result.substring(320,384); + String data5 = result.substring(384,448); + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000020", offset); + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000005", length); + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000001", data1); + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000002", data2); + Assert.assertEquals("83a36b13f04fa5302213ae219b2bc77dd58deece0c2aa6311bce815a761c3f3b", data3); + Assert.assertEquals("94d22bf13665a04532f94d9822f79317670ade963b70feb2053755c5f36e1450", data4); + Assert.assertEquals("ae12ac48beebcaccbb395d4f532944cfead09a4c0ee09c1cb49742b7b6188669", data5); + } @AfterClass