diff --git a/.circleci/config.yml b/.circleci/config.yml index 2aaa0121d5b..74940a5a754 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -18,7 +18,7 @@ jobs: # # - run: # name: Daily Build Report -# command: curl http://60.205.215.34/Daily_Build_Task_Report +# command: curl http://47.95.206.44:50080/Daily_Build_Task_Report # # - run: # name: Download Links diff --git a/.gitignore b/.gitignore index b980800f353..9ba22fd1b58 100644 --- a/.gitignore +++ b/.gitignore @@ -54,4 +54,4 @@ nodeId.properties Wallet # vm_trace -/vm_trace/ +/vm_trace/ \ No newline at end of file diff --git a/DownloadLinks.sh b/DownloadLinks.sh index a3d05821084..babc5a266f6 100644 --- a/DownloadLinks.sh +++ b/DownloadLinks.sh @@ -1,21 +1,21 @@ -PassFlag=`curl -s http://60.205.215.34/Daily_Build_Task_Report | grep "Failed: 0" | wc -c` +PassFlag=`curl -s http://47.95.206.44:50080/Daily_Build_Task_Report | grep "Failed: 0" | wc -c` if [ $PassFlag -eq 0 ]; then echo "Daily Build Stest Fail" echo "To view Daily Replay and Stress Test logs please visit website below on browsers" - echo "--- http://60.205.215.34/latestReplayLog" - echo "--- http://60.205.215.34/latestStressLog" + echo "--- http://47.95.206.44:50080/latestReplayLog" + echo "--- http://47.95.206.44:50080/latestStressLog" else echo "Daily Build Stest Pass" echo "Build on `date +"%Y-%m-%d"` 3:00:00 (CST), UTC +8" echo "Please visit following website to download java-tron.jar on browsers" - echo "--- http://60.205.215.34/Daily_Build/java-tron.jar" + echo "--- http://47.95.206.44:50080/Daily_Build/jFava-tron.jar" echo "To view Daily Replay and Stress Test logs please visit website below on browsers" - echo "--- http://60.205.215.34/latestReplayLog" - echo "--- http://60.205.215.34/latestStressLog" + echo "--- http://47.95.206.44:50080/latestReplayLog" + echo "--- http://47.95.206.44:50080/latestStressLog" echo "The following compressed package is provided for user to set up Fullnode. Please use Linux OS to Download" - echo "--- curl -# -O http://60.205.215.34/Daily_Build/java-tron.tar.gz" + echo "--- curl -# -O http://47.95.206.44:50080/Daily_Build/java-tron.tar.gz" echo "To unzip file use the command below" echo "--- tar -xzvf java-tron.tar.gz" fi \ No newline at end of file diff --git a/build.gradle b/build.gradle index 4947903401a..98581105a01 100755 --- a/build.gradle +++ b/build.gradle @@ -24,7 +24,7 @@ apply plugin: "jacoco" apply plugin: 'maven-publish' jar.enabled = false -shadowJar.enabled = false +shadowJar.enabled = true sourceCompatibility = 1.8 [compileJava, compileTestJava]*.options*.encoding = 'UTF-8' diff --git a/deploy.sh b/deploy.sh index 3f21c8994e7..879e9614287 100644 --- a/deploy.sh +++ b/deploy.sh @@ -1,17 +1,19 @@ #!/bin/bash if [[ "$TRAVIS_BRANCH" = "develop" || "$TRAVIS_BRANCH" = "master" ]];then stestlogname="`date +%Y%m%d%H%M%S`_stest.log" + timeout 10 ping -c 5 47.93.42.145 > /dev/null || exit 1 + timeout 10 ping -c 5 47.93.18.60 > /dev/null || exit 1 stest_server="" - docker_num_in_67=`ssh -p 22008 -t java-tron@47.93.42.145 'docker ps -a | wc -l'` - docker_num_in_67=`echo $docker_num_in_67 | tr -d "\r"` - docker_num_in_122=`ssh -p 22008 -t java-tron@47.93.18.60 'docker ps -a | wc -l'` - docker_num_in_122=`echo $docker_num_in_122 | tr -d "\r"` - if [ $docker_num_in_67 -le $docker_num_in_122 ]; + docker_num_in_145=`ssh -p 22008 -t java-tron@47.93.42.145 'docker ps -a | wc -l'` + docker_num_in_145=`echo $docker_num_in_145 | tr -d "\r"` + docker_num_in_60=`ssh -p 22008 -t java-tron@47.93.18.60 'docker ps -a | wc -l'` + docker_num_in_60=`echo $docker_num_in_60 | tr -d "\r"` + if [ $docker_num_in_145 -le $docker_num_in_60 ]; then - docker_num=$docker_num_in_67 + docker_num=$docker_num_in_145 stest_server=47.93.42.145 else - docker_num=$docker_num_in_122 + docker_num=$docker_num_in_60 stest_server=47.93.18.60 fi diff --git a/src/main/java/org/tron/common/overlay/discover/node/NodeHandler.java b/src/main/java/org/tron/common/overlay/discover/node/NodeHandler.java index fece3822772..f60934bd96e 100644 --- a/src/main/java/org/tron/common/overlay/discover/node/NodeHandler.java +++ b/src/main/java/org/tron/common/overlay/discover/node/NodeHandler.java @@ -95,7 +95,7 @@ public NodeHandler(Node node, NodeManager nodeManager) { this.node = node; this.nodeManager = nodeManager; this.inetSocketAddress = new InetSocketAddress(node.getHost(), node.getPort()); - this.nodeStatistics = new NodeStatistics(node); + this.nodeStatistics = new NodeStatistics(); changeState(State.Discovered); } @@ -201,8 +201,7 @@ public void handlePing(PingMessage msg) { public void handlePong(PongMessage msg) { if (waitForPong) { waitForPong = false; - getNodeStatistics().discoverMessageLatency - .add((double) System.currentTimeMillis() - pingSent); + getNodeStatistics().discoverMessageLatency.add(System.currentTimeMillis() - pingSent); getNodeStatistics().lastPongReplyTime.set(System.currentTimeMillis()); node.setId(msg.getFrom().getId()); if (msg.getVersion() != Args.getInstance().getNodeP2pVersion()) { diff --git a/src/main/java/org/tron/common/overlay/discover/node/statistics/NodeStatistics.java b/src/main/java/org/tron/common/overlay/discover/node/statistics/NodeStatistics.java index 5b859658bc0..e6e14aee06a 100644 --- a/src/main/java/org/tron/common/overlay/discover/node/statistics/NodeStatistics.java +++ b/src/main/java/org/tron/common/overlay/discover/node/statistics/NodeStatistics.java @@ -21,6 +21,7 @@ import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; import lombok.Getter; +import lombok.Setter; import org.tron.common.overlay.discover.node.Node; import org.tron.core.config.args.Args; import org.tron.protos.Protocol.ReasonCode; @@ -48,12 +49,15 @@ public class NodeStatistics { public final MessageCount tcpFlow = new MessageCount(); public final SimpleStatter discoverMessageLatency; + public final SimpleStatter pingMessageLatency; + public final AtomicLong lastPongReplyTime = new AtomicLong(0L); // in milliseconds private Reputation reputation; - public NodeStatistics(Node node) { - discoverMessageLatency = new SimpleStatter(node.getIdString()); + public NodeStatistics() { + discoverMessageLatency = new SimpleStatter(); + pingMessageLatency = new SimpleStatter(); reputation = new Reputation(this); } @@ -182,40 +186,26 @@ public String toString() { } public class SimpleStatter { - - private final String name; - private volatile double last; - private volatile double sum; - private AtomicInteger count = new AtomicInteger(); - - public SimpleStatter(String name) { - this.name = name; - } - - public void add(double value) { + private long sum; + @Getter + private long count; + @Getter + private long last; + @Getter + private long min; + @Getter + private long max; + + public void add(long value) { last = value; sum += value; - count.incrementAndGet(); - } - - public double getLast() { - return last; - } - - public int getCount() { - return count.get(); - } - - public double getSum() { - return sum; - } - - public double getAvrg() { - return count.get() == 0 ? 0 : sum / count.get(); + min = min == 0? value : Math.min(min, value); + max = Math.max(max, value); + count++; } - public String getName() { - return name; + public long getAvrg() { + return count == 0 ? 0 : sum / count; } } diff --git a/src/main/java/org/tron/common/overlay/server/Channel.java b/src/main/java/org/tron/common/overlay/server/Channel.java index b2433855235..66b30c1cf7b 100644 --- a/src/main/java/org/tron/common/overlay/server/Channel.java +++ b/src/main/java/org/tron/common/overlay/server/Channel.java @@ -1,20 +1,3 @@ -/* - * Copyright (c) [2016] [ ] - * This file is part of the ethereumJ library. - * - * The ethereumJ library is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * The ethereumJ library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with the ethereumJ library. If not, see . - */ package org.tron.common.overlay.server; import io.netty.channel.ChannelHandlerContext; @@ -90,10 +73,6 @@ public class Channel { private volatile boolean isDisconnect; - private String remoteId; - - private PeerStatistics peerStats = new PeerStatistics(); - private boolean isTrustPeer; private boolean isFastForwardPeer; @@ -103,8 +82,6 @@ public void init(ChannelPipeline pipeline, String remoteId, boolean discoveryMod this.channelManager = channelManager; - this.remoteId = remoteId; - isActive = remoteId != null && !remoteId.isEmpty(); startTime = System.currentTimeMillis(); @@ -129,7 +106,7 @@ public void init(ChannelPipeline pipeline, String remoteId, boolean discoveryMod } public void publicHandshakeFinished(ChannelHandlerContext ctx, HelloMessage msg) { - isTrustPeer = channelManager.getTrustNodes().containsKey(getInetAddress()); + isTrustPeer = channelManager.getTrustNodes().getIfPresent(getInetAddress()) != null; isFastForwardPeer = channelManager.getFastForwardNodes().containsKey(getInetAddress()); ctx.pipeline().remove(handshakeHandler); msgQueue.activate(ctx); @@ -197,10 +174,6 @@ public enum TronState { SYNC_FAILED } - public PeerStatistics getPeerStats() { - return peerStats; - } - public Node getNode() { return node; } diff --git a/src/main/java/org/tron/common/overlay/server/ChannelManager.java b/src/main/java/org/tron/common/overlay/server/ChannelManager.java index b558c91b31b..d0565295080 100644 --- a/src/main/java/org/tron/common/overlay/server/ChannelManager.java +++ b/src/main/java/org/tron/common/overlay/server/ChannelManager.java @@ -50,7 +50,7 @@ public class ChannelManager { .maximumSize(1000).expireAfterWrite(30, TimeUnit.SECONDS).recordStats().build(); @Getter - private Map trustNodes = new ConcurrentHashMap(); + private Cache trustNodes = CacheBuilder.newBuilder().maximumSize(100).build(); @Getter private Map activeNodes = new ConcurrentHashMap(); @@ -126,7 +126,7 @@ public void notifyDisconnect(Channel channel) { public synchronized boolean processPeer(Channel peer) { - if (!trustNodes.containsKey(peer.getInetAddress())) { + if (trustNodes.getIfPresent(peer.getInetAddress()) == null) { if (recentlyDisconnected.getIfPresent(peer) != null) { logger.info("Peer {} recently disconnected.", peer.getInetAddress()); return false; diff --git a/src/main/java/org/tron/common/overlay/server/FastForward.java b/src/main/java/org/tron/common/overlay/server/FastForward.java index 83c911a0d64..37b539b19c1 100644 --- a/src/main/java/org/tron/common/overlay/server/FastForward.java +++ b/src/main/java/org/tron/common/overlay/server/FastForward.java @@ -1,5 +1,6 @@ package org.tron.common.overlay.server; +import com.google.protobuf.ByteString; import java.net.InetAddress; import java.net.InetSocketAddress; import java.util.List; @@ -13,10 +14,8 @@ import org.tron.common.backup.BackupManager; import org.tron.common.backup.BackupManager.BackupStatusEnum; import org.tron.common.overlay.discover.node.Node; -import org.tron.common.overlay.discover.node.NodeManager; import org.tron.core.config.args.Args; -import org.tron.core.db.Manager; -import org.tron.core.db.WitnessStore; +import org.tron.core.db.WitnessScheduleStore; import org.tron.core.services.WitnessService; import org.tron.protos.Protocol.ReasonCode; @@ -27,12 +26,6 @@ public class FastForward { @Autowired private ApplicationContext ctx; - private Manager manager; - - private WitnessStore witnessStore; - - private NodeManager nodeManager; - private ChannelManager channelManager; private BackupManager backupManager; @@ -41,7 +34,8 @@ public class FastForward { private Args args = Args.getInstance(); private List fastForwardNodes = args.getFastForwardNodes(); - private byte[] witnessAddress = args.getLocalWitnesses().getWitnessAccountAddress(); + private ByteString witnessAddress = ByteString + .copyFrom(args.getLocalWitnesses().getWitnessAccountAddress()); private int keySize = args.getLocalWitnesses().getPrivateKeys().size(); public void init() { @@ -53,21 +47,14 @@ public void init() { return; } - manager = ctx.getBean(Manager.class); - witnessStore = ctx.getBean(WitnessStore.class); - nodeManager = ctx.getBean(NodeManager.class); channelManager = ctx.getBean(ChannelManager.class); backupManager = ctx.getBean(BackupManager.class); - - if (args.getFastForwardNodes().size() > 0) { - fastForwardNodes = args.getFastForwardNodes(); - } + WitnessScheduleStore witnessScheduleStore = ctx.getBean(WitnessScheduleStore.class); executorService.scheduleWithFixedDelay(() -> { try { - if (witnessStore.get(witnessAddress) != null && - backupManager.getStatus().equals(BackupStatusEnum.MASTER) && - !WitnessService.isNeedSyncCheck()) { + if (witnessScheduleStore.getActiveWitnesses().contains(witnessAddress) && + backupManager.getStatus().equals(BackupStatusEnum.MASTER)) { connect(); } else { disconnect(); @@ -90,11 +77,10 @@ private void disconnect() { InetAddress address = new InetSocketAddress(node.getHost(), node.getPort()).getAddress(); channelManager.getActiveNodes().remove(address); channelManager.getActivePeers().forEach(channel -> { - if (channel.getNode().equals(node)) { + if (channel.getInetAddress().equals(address)) { channel.disconnect(ReasonCode.RESET); } }); }); } - } diff --git a/src/main/java/org/tron/common/overlay/server/HandshakeHandler.java b/src/main/java/org/tron/common/overlay/server/HandshakeHandler.java index 05760377ed1..9f9a6b54708 100644 --- a/src/main/java/org/tron/common/overlay/server/HandshakeHandler.java +++ b/src/main/java/org/tron/common/overlay/server/HandshakeHandler.java @@ -123,7 +123,7 @@ private void handleHelloMsg(ChannelHandlerContext ctx, HelloMessage msg) { if (remoteId.length != 64) { InetAddress address = ((InetSocketAddress) ctx.channel().remoteAddress()).getAddress(); - if (!channelManager.getTrustNodes().keySet().contains(address) && !syncPool.isCanConnect()) { + if (channelManager.getTrustNodes().getIfPresent(address) == null && !syncPool.isCanConnect()) { channel.disconnect(ReasonCode.TOO_MANY_PEERS); return; } diff --git a/src/main/java/org/tron/common/overlay/server/MessageQueue.java b/src/main/java/org/tron/common/overlay/server/MessageQueue.java index 3deb4532592..5da9bc172b4 100644 --- a/src/main/java/org/tron/common/overlay/server/MessageQueue.java +++ b/src/main/java/org/tron/common/overlay/server/MessageQueue.java @@ -30,6 +30,8 @@ public class MessageQueue { private volatile long sendTime; + private volatile long sendPing; + private Thread sendMsgThread; private Channel channel; @@ -90,8 +92,12 @@ public void setChannel(Channel channel) { } public boolean sendMessage(Message msg) { - if (msg instanceof PingMessage && sendTime > System.currentTimeMillis() - 10_000) { - return false; + long now = System.currentTimeMillis(); + if (msg instanceof PingMessage) { + if (now - sendTime < 10_000 && now - sendPing < 60_000) { + return false; + } + sendPing = now; } if (needToLog(msg)) { logger.info("Send to {}, {} ", ctx.channel().remoteAddress(), msg); @@ -111,10 +117,13 @@ public void receivedMessage(Message msg) { logger.info("Receive from {}, {}", ctx.channel().remoteAddress(), msg); } channel.getNodeStatistics().messageStatistics.addTcpInMessage(msg); - MessageRoundtrip messageRoundtrip = requestQueue.peek(); - if (messageRoundtrip != null && messageRoundtrip.getMsg().getAnswerMessage() == msg - .getClass()) { + MessageRoundtrip rt = requestQueue.peek(); + if (rt != null && rt.getMsg().getAnswerMessage() == msg.getClass()) { requestQueue.remove(); + if (rt.getMsg() instanceof PingMessage) { + channel.getNodeStatistics().pingMessageLatency + .add(System.currentTimeMillis() - rt.getTime()); + } } } @@ -150,23 +159,22 @@ private boolean needToLog(Message msg) { } private void send() { - MessageRoundtrip messageRoundtrip = requestQueue.peek(); - if (!sendMsgFlag || messageRoundtrip == null) { + MessageRoundtrip rt = requestQueue.peek(); + if (!sendMsgFlag || rt == null) { return; } - if (messageRoundtrip.getRetryTimes() > 0 && !messageRoundtrip.hasToRetry()) { + if (rt.getRetryTimes() > 0 && !rt.hasToRetry()) { return; } - if (messageRoundtrip.getRetryTimes() > 0) { + if (rt.getRetryTimes() > 0) { channel.getNodeStatistics().nodeDisconnectedLocal(ReasonCode.PING_TIMEOUT); - logger - .warn("Wait {} timeout. close channel {}.", messageRoundtrip.getMsg().getAnswerMessage(), - ctx.channel().remoteAddress()); + logger.warn("Wait {} timeout. close channel {}.", + rt.getMsg().getAnswerMessage(), ctx.channel().remoteAddress()); channel.close(); return; } - Message msg = messageRoundtrip.getMsg(); + Message msg = rt.getMsg(); ctx.writeAndFlush(msg.getSendData()).addListener((ChannelFutureListener) future -> { if (!future.isSuccess()) { @@ -174,8 +182,8 @@ private void send() { } }); - messageRoundtrip.incRetryTimes(); - messageRoundtrip.saveTime(); + rt.incRetryTimes(); + rt.saveTime(); } } diff --git a/src/main/java/org/tron/common/overlay/server/MessageRoundtrip.java b/src/main/java/org/tron/common/overlay/server/MessageRoundtrip.java index c72b131e5e4..4e05b80fec4 100644 --- a/src/main/java/org/tron/common/overlay/server/MessageRoundtrip.java +++ b/src/main/java/org/tron/common/overlay/server/MessageRoundtrip.java @@ -1,51 +1,18 @@ -/* - * Copyright (c) [2016] [ ] - * This file is part of the ethereumJ library. - * - * The ethereumJ library is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * The ethereumJ library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with the ethereumJ library. If not, see . - */ package org.tron.common.overlay.server; import org.tron.common.overlay.message.Message; -/** - * Utility wraps around a message to keep track of the number of times it has been offered This - * class also contains the last time a message was offered and is updated when an answer has been - * received to it can be removed from the queue. - * - * @author Roman Mandeleil - */ public class MessageRoundtrip { private final Message msg; - private long lastTimestamp = 0; + private long time = 0; private long retryTimes = 0; - private boolean answered = false; public MessageRoundtrip(Message msg) { this.msg = msg; saveTime(); } - public boolean isAnswered() { - return answered; - } - - public void answer() { - answered = true; - } - public long getRetryTimes() { return retryTimes; } @@ -55,15 +22,15 @@ public void incRetryTimes() { } public void saveTime() { - lastTimestamp = System.currentTimeMillis(); + time = System.currentTimeMillis(); } public long getTime() { - return lastTimestamp; + return time; } public boolean hasToRetry() { - return 20000 < System.currentTimeMillis() - lastTimestamp; + return 20000 < System.currentTimeMillis() - time; } public Message getMsg() { diff --git a/src/main/java/org/tron/common/overlay/server/P2pHandler.java b/src/main/java/org/tron/common/overlay/server/P2pHandler.java index e5dae36a51e..3346506396d 100644 --- a/src/main/java/org/tron/common/overlay/server/P2pHandler.java +++ b/src/main/java/org/tron/common/overlay/server/P2pHandler.java @@ -33,13 +33,10 @@ public class P2pHandler extends SimpleChannelInboundHandler { private volatile boolean hasPing = false; - private volatile long sendPingTime; - @Override - public void handlerAdded(ChannelHandlerContext ctx) throws Exception { + public void handlerAdded(ChannelHandlerContext ctx) { pingTask = pingTimer.scheduleAtFixedRate(() -> { if (!hasPing) { - sendPingTime = System.currentTimeMillis(); hasPing = msgQueue.sendMessage(PING_MESSAGE); } }, 10, 10, TimeUnit.SECONDS); @@ -73,7 +70,6 @@ public void channelRead0(final ChannelHandlerContext ctx, P2pMessage msg) { } hasPing = false; channel.getNodeStatistics().lastPongReplyTime.set(System.currentTimeMillis()); - channel.getPeerStats().pong(sendPingTime); break; case P2P_DISCONNECT: channel.getNodeStatistics() diff --git a/src/main/java/org/tron/common/overlay/server/PeerStatistics.java b/src/main/java/org/tron/common/overlay/server/PeerStatistics.java deleted file mode 100644 index 5b1128ff740..00000000000 --- a/src/main/java/org/tron/common/overlay/server/PeerStatistics.java +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Copyright (c) [2016] [ ] - * This file is part of the ethereumJ library. - * - * The ethereumJ library is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * The ethereumJ library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with the ethereumJ library. If not, see . - */ -package org.tron.common.overlay.server; - -/** - * @author Mikhail Kalinin - * @since 29.02.2016 - */ -public class PeerStatistics { - - private double avgLatency = 0; - private long pingCount = 0; - - public void pong(long pingStamp) { - long latency = System.currentTimeMillis() - pingStamp; - avgLatency = ((avgLatency * pingCount) + latency) / ++pingCount; - } - - public double getAvgLatency() { - return avgLatency; - } -} diff --git a/src/main/java/org/tron/common/overlay/server/SyncPool.java b/src/main/java/org/tron/common/overlay/server/SyncPool.java index f444f0862e8..afce5d008e0 100644 --- a/src/main/java/org/tron/common/overlay/server/SyncPool.java +++ b/src/main/java/org/tron/common/overlay/server/SyncPool.java @@ -133,32 +133,13 @@ private void fillUp() { } synchronized void logActivePeers() { - - logger.info("-------- active connect channel {}", activePeersCount.get()); - logger.info("-------- passive connect channel {}", passivePeersCount.get()); - logger.info("-------- all connect channel {}", channelManager.getActivePeers().size()); - for (Channel channel : channelManager.getActivePeers()) { - logger.info(channel.toString()); - } - - if (logger.isInfoEnabled()) { - StringBuilder sb = new StringBuilder("Peer stats:\n"); - sb.append("Active peers\n"); - sb.append("============\n"); - Set activeSet = new HashSet<>(); - for (PeerConnection peer : new ArrayList<>(activePeers)) { - sb.append(peer.log()).append('\n'); - activeSet.add(peer.getNode()); - } - sb.append("Other connected peers\n"); - sb.append("============\n"); - for (Channel peer : new ArrayList<>(channelManager.getActivePeers())) { - if (!activeSet.contains(peer.getNode())) { - sb.append(peer.getNode()).append('\n'); - } - } - logger.info(sb.toString()); + String str = String.format("\n\n============ Peer stats: all %d, active %d, passive %d\n\n", + channelManager.getActivePeers().size(), activePeersCount.get(), passivePeersCount.get()); + StringBuilder sb = new StringBuilder(str); + for (PeerConnection peer : new ArrayList<>(activePeers)) { + sb.append(peer.log()).append('\n'); } + logger.info(sb.toString()); } public List getActivePeers() { @@ -180,7 +161,8 @@ public synchronized void onConnect(Channel peer) { activePeersCount.incrementAndGet(); } activePeers.add(peerConnection); - activePeers.sort(Comparator.comparingDouble(c -> c.getPeerStats().getAvgLatency())); + activePeers. + sort(Comparator.comparingDouble(c -> c.getNodeStatistics().pingMessageLatency.getAvrg())); peerConnection.onConnect(); } } @@ -239,10 +221,6 @@ public boolean test(NodeHandler handler) { return false; } - if (handler.getNodeStatistics().getReputation() >= NodeStatistics.REPUTATION_PREDEFINED) { - return true; - } - InetAddress inetAddress = handler.getInetSocketAddress().getAddress(); if (channelManager.getRecentlyDisconnected().getIfPresent(inetAddress) != null) { return false; diff --git a/src/main/java/org/tron/common/overlay/server/TronChannelInitializer.java b/src/main/java/org/tron/common/overlay/server/TronChannelInitializer.java index bc6ad417d37..4ffefd92ae2 100644 --- a/src/main/java/org/tron/common/overlay/server/TronChannelInitializer.java +++ b/src/main/java/org/tron/common/overlay/server/TronChannelInitializer.java @@ -1,20 +1,3 @@ -/* - * Copyright (c) [2016] [ ] - * This file is part of the ethereumJ library. - * - * The ethereumJ library is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * The ethereumJ library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with the ethereumJ library. If not, see . - */ package org.tron.common.overlay.server; import io.netty.channel.ChannelFutureListener; @@ -29,10 +12,6 @@ import org.springframework.stereotype.Component; import org.tron.core.net.peer.PeerConnection; -/** - * @author Roman Mandeleil - * @since 01.11.2014 - */ @Slf4j(topic = "net") @Component @Scope("prototype") diff --git a/src/main/java/org/tron/core/Wallet.java b/src/main/java/org/tron/core/Wallet.java index 5c72ca06355..a48f4301924 100755 --- a/src/main/java/org/tron/core/Wallet.java +++ b/src/main/java/org/tron/core/Wallet.java @@ -93,7 +93,6 @@ import org.tron.core.capsule.TransactionInfoCapsule; import org.tron.core.capsule.TransactionResultCapsule; import org.tron.core.capsule.WitnessCapsule; -import org.tron.core.capsule.utils.TransactionUtil; import org.tron.core.config.Parameter.ChainConstant; import org.tron.core.config.args.Args; import org.tron.core.db.AccountIdIndexStore; @@ -103,6 +102,7 @@ import org.tron.core.db.EnergyProcessor; import org.tron.core.db.Manager; import org.tron.core.exception.AccountResourceInsufficientException; +import org.tron.core.exception.BadItemException; import org.tron.core.exception.ContractExeException; import org.tron.core.exception.ContractValidateException; import org.tron.core.exception.DupTransactionException; @@ -1229,7 +1229,7 @@ public TransactionInfo getTransactionInfoById(ByteString transactionId) { if (Objects.isNull(transactionId)) { return null; } - TransactionInfoCapsule transactionInfoCapsule = null; + TransactionInfoCapsule transactionInfoCapsule; try { transactionInfoCapsule = dbManager.getTransactionHistoryStore() .get(transactionId.toByteArray()); @@ -1239,7 +1239,14 @@ public TransactionInfo getTransactionInfoById(ByteString transactionId) { if (transactionInfoCapsule != null) { return transactionInfoCapsule.getInstance(); } - return null; + try { + transactionInfoCapsule = dbManager.getTransactionRetStore() + .getTransactionInfo(transactionId.toByteArray()); + } catch (BadItemException e) { + return null; + } + + return transactionInfoCapsule == null ? null : transactionInfoCapsule.getInstance(); } public Proposal getProposalById(ByteString proposalId) { diff --git a/src/main/java/org/tron/core/capsule/BlockCapsule.java b/src/main/java/org/tron/core/capsule/BlockCapsule.java index 25e3a134d4d..490e1a9fb34 100755 --- a/src/main/java/org/tron/core/capsule/BlockCapsule.java +++ b/src/main/java/org/tron/core/capsule/BlockCapsule.java @@ -25,6 +25,8 @@ import java.util.List; import java.util.Vector; import java.util.stream.Collectors; +import lombok.Getter; +import lombok.Setter; import lombok.extern.slf4j.Slf4j; import org.apache.commons.collections4.CollectionUtils; import org.tron.common.crypto.ECKey; @@ -44,6 +46,10 @@ @Slf4j(topic = "capsule") public class BlockCapsule implements ProtoCapsule { + @Getter + @Setter + private TransactionRetCapsule result; + public static class BlockId extends Sha256Hash { @Override diff --git a/src/main/java/org/tron/core/capsule/TransactionCapsule.java b/src/main/java/org/tron/core/capsule/TransactionCapsule.java index dd61bcbe877..6bb32fb8bff 100755 --- a/src/main/java/org/tron/core/capsule/TransactionCapsule.java +++ b/src/main/java/org/tron/core/capsule/TransactionCapsule.java @@ -925,7 +925,6 @@ public void setResult(Runtime runtime) { return; } this.setResultCode(contractResult.UNKNOWN); - return; } public void setResultCode(contractResult code) { diff --git a/src/main/java/org/tron/core/capsule/TransactionRetCapsule.java b/src/main/java/org/tron/core/capsule/TransactionRetCapsule.java new file mode 100644 index 00000000000..f2b41533384 --- /dev/null +++ b/src/main/java/org/tron/core/capsule/TransactionRetCapsule.java @@ -0,0 +1,53 @@ +package org.tron.core.capsule; + +import com.google.protobuf.InvalidProtocolBufferException; +import java.util.Objects; +import lombok.extern.slf4j.Slf4j; +import org.tron.core.exception.BadItemException; +import org.tron.protos.Protocol.TransactionInfo; +import org.tron.protos.Protocol.TransactionRet; + +@Slf4j(topic = "capsule") +public class TransactionRetCapsule implements ProtoCapsule { + private TransactionRet transactionRet; + + public TransactionRetCapsule(BlockCapsule blockCapsule) { + transactionRet = TransactionRet.newBuilder().build(); + if (Objects.isNull(blockCapsule)) { + return; + } + TransactionRet.Builder build = transactionRet.toBuilder() + .setBlockNumber(blockCapsule.getNum()).setBlockTimeStamp(blockCapsule.getTimeStamp()); + transactionRet = build.build(); + } + + // only for test + public TransactionRetCapsule() { + transactionRet = TransactionRet.newBuilder().build(); + } + + public TransactionRetCapsule(byte[] data) throws BadItemException { + try { + this.transactionRet = transactionRet.parseFrom(data); + } catch (InvalidProtocolBufferException e) { + throw new BadItemException("TransactionInfoCapsule proto data parse exception"); + } + } + + public void addTransactionInfo(TransactionInfo result) { + this.transactionRet = this.transactionRet.toBuilder().addTransactioninfo(result).build(); + } + + @Override + public byte[] getData() { + if (Objects.isNull(transactionRet)) { + return null; + } + return transactionRet.toByteArray(); + } + + @Override + public TransactionRet getInstance() { + return transactionRet; + } +} \ No newline at end of file diff --git a/src/main/java/org/tron/core/config/args/Args.java b/src/main/java/org/tron/core/config/args/Args.java index 25c87796bfc..c54a2f61746 100644 --- a/src/main/java/org/tron/core/config/args/Args.java +++ b/src/main/java/org/tron/core/config/args/Args.java @@ -135,11 +135,11 @@ public class Args { private String storageDbEngine = ""; @Parameter(names = { - "--storage-db-synchronous"}, description = "Storage db is synchronous or not.(true or flase)") + "--storage-db-synchronous"}, description = "Storage db is synchronous or not.(true or false)") private String storageDbSynchronous = ""; @Parameter(names = { - "--contract-parse-enable"}, description = "enable contract parses in java-tron or not.(true or flase)") + "--contract-parse-enable"}, description = "enable contract parses in java-tron or not.(true or false)") private String contractParseEnable = ""; @Parameter(names = {"--storage-index-directory"}, description = "Storage index directory") @@ -741,12 +741,6 @@ public static void setParam(final String[] args, final String confFileName) { config.hasPath("node.connection.timeout") ? config.getInt("node.connection.timeout") * 1000 : 0; - INSTANCE.activeNodes = getNodes(config, "node.active"); - - INSTANCE.passiveNodes = getNodes(config, "node.passive"); - - INSTANCE.fastForwardNodes = getNodes(config, "node.fastForward"); - INSTANCE.nodeChannelReadTimeout = config.hasPath("node.channel.read.timeout") ? config.getInt("node.channel.read.timeout") : 0; @@ -951,6 +945,12 @@ public static void setParam(final String[] args, final String confFileName) { .getInt("node.validContractProto.threads") : Runtime.getRuntime().availableProcessors(); + INSTANCE.activeNodes = getNodes(config, "node.active"); + + INSTANCE.passiveNodes = getNodes(config, "node.passive"); + + INSTANCE.fastForwardNodes = getNodes(config, "node.fastForward"); + initBackupProperty(config); if ("ROCKSDB".equals(Args.getInstance().getStorage().getDbEngine().toUpperCase())) { initRocksDbBackupProperty(config); @@ -1026,7 +1026,12 @@ private static List getNodes(final com.typesafe.config.Config config, Stri List list = config.getStringList(path); for (String configString : list) { Node n = Node.instanceOf(configString); - ret.add(n); + if (!(INSTANCE.nodeDiscoveryBindIp.equals(n.getHost()) || + INSTANCE.nodeExternalIp.equals(n.getHost()) || + "127.0.0.1".equals(n.getHost())) || + INSTANCE.nodeListenPort != n.getPort()) { + ret.add(n); + } } return ret; } @@ -1321,6 +1326,7 @@ private static void logConfig() { logger.info("Discover enable: {}", args.isNodeDiscoveryEnable()); logger.info("Active node size: {}", args.getActiveNodes().size()); logger.info("Passive node size: {}", args.getPassiveNodes().size()); + logger.info("FastForward node size: {}", args.getFastForwardNodes().size()); logger.info("Seed node size: {}", args.getSeedNode().getIpList().size()); logger.info("Max connection: {}", args.getNodeMaxActiveNodes()); logger.info("Max connection with same IP: {}", args.getNodeMaxActiveNodesWithSameIp()); diff --git a/src/main/java/org/tron/core/db/AccountStore.java b/src/main/java/org/tron/core/db/AccountStore.java index d3174f93afd..7740eb9be97 100644 --- a/src/main/java/org/tron/core/db/AccountStore.java +++ b/src/main/java/org/tron/core/db/AccountStore.java @@ -11,8 +11,8 @@ import org.springframework.stereotype.Component; import org.tron.core.Wallet; import org.tron.core.capsule.AccountCapsule; -import org.tron.core.db.fast.callback.FastSyncCallBack; -import org.tron.core.db.fast.storetrie.AccountStateStoreTrie; +import org.tron.core.db.accountstate.callback.AccountStateCallBack; +import org.tron.core.db.accountstate.storetrie.AccountStateStoreTrie; @Slf4j(topic = "DB") @Component @@ -21,7 +21,7 @@ public class AccountStore extends TronStoreWithRevoking { private static Map assertsAddress = new HashMap<>(); // key = name , value = address @Autowired - private FastSyncCallBack fastSyncCallBack; + private AccountStateCallBack accountStateCallBack; @Autowired private AccountStateStoreTrie accountStateStoreTrie; @@ -41,7 +41,7 @@ public AccountCapsule get(byte[] key) { @Override public void put(byte[] key, AccountCapsule item) { super.put(key, item); - fastSyncCallBack.accountCallBack(key, item); + accountStateCallBack.accountCallBack(key, item); } /** diff --git a/src/main/java/org/tron/core/db/Manager.java b/src/main/java/org/tron/core/db/Manager.java index 2413c1f6ca4..643a5febbae 100644 --- a/src/main/java/org/tron/core/db/Manager.java +++ b/src/main/java/org/tron/core/db/Manager.java @@ -31,8 +31,6 @@ import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.LinkedBlockingQueue; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.ScheduledFuture; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicLong; import java.util.stream.Collectors; @@ -70,6 +68,7 @@ import org.tron.core.capsule.ExchangeCapsule; import org.tron.core.capsule.TransactionCapsule; import org.tron.core.capsule.TransactionInfoCapsule; +import org.tron.core.capsule.TransactionRetCapsule; import org.tron.core.capsule.WitnessCapsule; import org.tron.core.capsule.utils.BlockUtil; import org.tron.core.config.Parameter.ChainConstant; @@ -77,8 +76,8 @@ import org.tron.core.config.args.GenesisBlock; import org.tron.core.db.KhaosDatabase.KhaosBlock; import org.tron.core.db.api.AssetUpdateHelper; -import org.tron.core.db.fast.TrieService; -import org.tron.core.db.fast.callback.FastSyncCallBack; +import org.tron.core.db.accountstate.TrieService; +import org.tron.core.db.accountstate.callback.AccountStateCallBack; import org.tron.core.db2.core.ISession; import org.tron.core.db2.core.ITronChainBase; import org.tron.core.db2.core.SnapshotManager; @@ -103,12 +102,15 @@ import org.tron.core.exception.VMIllegalException; import org.tron.core.exception.ValidateScheduleException; import org.tron.core.exception.ValidateSignatureException; +import org.tron.core.net.TronNetService; +import org.tron.core.net.message.BlockMessage; import org.tron.core.services.WitnessService; import org.tron.core.witness.ProposalController; import org.tron.core.witness.WitnessController; import org.tron.protos.Protocol.AccountType; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract; +import org.tron.protos.Protocol.TransactionInfo; @Slf4j(topic = "DB") @@ -136,6 +138,9 @@ public class Manager { @Getter private BlockIndexStore blockIndexStore; @Autowired + @Getter + private TransactionRetStore transactionRetStore; + @Autowired private AccountIdIndexStore accountIdIndexStore; @Autowired private AccountIndexStore accountIndexStore; @@ -165,6 +170,9 @@ public class Manager { @Getter private StorageRowStore storageRowStore; + @Setter + private TronNetService tronNetService; + // for network @Autowired private PeersStore peersStore; @@ -223,7 +231,7 @@ public class Manager { private ForkController forkController = ForkController.instance(); @Autowired - private FastSyncCallBack fastSyncCallBack; + private AccountStateCallBack accountStateCallBack; @Autowired private TrieService trieService; @@ -434,7 +442,7 @@ public void stopRepushTriggerThread() { @PostConstruct public void init() { Message.setManager(this); - fastSyncCallBack.setManager(this); + accountStateCallBack.setManager(this); trieService.setManager(this); revokingStore.disable(); revokingStore.check(); @@ -845,6 +853,10 @@ private void applyBlock(BlockCapsule block) throws ContractValidateException, processBlock(block); this.blockStore.put(block.getBlockId().getBytes(), block); this.blockIndexStore.put(block.getBlockId()); + if (block.getTransactions().size() != 0) { + this.transactionRetStore.put(ByteArray.fromLong(block.getNum()), block.getResult()); + } + updateFork(block); if (System.currentTimeMillis() - block.getTimeStamp() >= 60_000) { revokingStore.setMaxFlushCount(SnapshotManager.DEFAULT_MAX_FLUSH_COUNT); @@ -1191,12 +1203,12 @@ public boolean hasBlocks() { /** * Process transaction. */ - public boolean processTransaction(final TransactionCapsule trxCap, BlockCapsule blockCap) + public TransactionInfo processTransaction(final TransactionCapsule trxCap, BlockCapsule blockCap) throws ValidateSignatureException, ContractValidateException, ContractExeException, AccountResourceInsufficientException, TransactionExpirationException, TooBigTransactionException, TooBigTransactionResultException, DupTransactionException, TaposException, ReceiptCheckErrException, VMIllegalException { if (trxCap == null) { - return false; + return null; } validateTapos(trxCap); @@ -1257,8 +1269,6 @@ public boolean processTransaction(final TransactionCapsule trxCap, BlockCapsule TransactionInfoCapsule transactionInfo = TransactionInfoCapsule .buildInstance(trxCap, blockCap, trace); - transactionHistoryStore.put(trxCap.getTransactionId().getBytes(), transactionInfo); - // if event subscribe is enabled, post contract triggers to queue postContractTrigger(trace, false); Contract contract = trxCap.getInstance().getRawData().getContract(0); @@ -1266,7 +1276,7 @@ public boolean processTransaction(final TransactionCapsule trxCap, BlockCapsule ownerAddressSet.add(ByteArray.toHexString(TransactionCapsule.getOwner(contract))); } - return true; + return transactionInfo.getInstance(); } @@ -1320,13 +1330,15 @@ public synchronized BlockCapsule generateBlock( session.reset(); session.setValue(revokingStore.buildSession()); // - fastSyncCallBack.preExecute(blockCapsule); + accountStateCallBack.preExecute(blockCapsule); if (needCheckWitnessPermission && !witnessService. validateWitnessPermission(witnessCapsule.getAddress())) { logger.warn("Witness permission is wrong"); return null; } + TransactionRetCapsule transationRetCapsule = + new TransactionRetCapsule(blockCapsule); Set accountSet = new HashSet<>(); Iterator iterator = pendingTransactions.iterator(); @@ -1371,12 +1383,16 @@ public synchronized BlockCapsule generateBlock( } // apply transaction try (ISession tmpSeesion = revokingStore.buildSession()) { - fastSyncCallBack.preExeTrans(); - processTransaction(trx, blockCapsule); - fastSyncCallBack.exeTransFinish(); + accountStateCallBack.preExeTrans(); + TransactionInfo result = processTransaction(trx, blockCapsule); + accountStateCallBack.exeTransFinish(); tmpSeesion.merge(); // push into block blockCapsule.addTransaction(trx); + + if (Objects.nonNull(result)) { + transationRetCapsule.addTransactionInfo(result); + } if (fromPending) { iterator.remove(); } @@ -1415,7 +1431,7 @@ public synchronized BlockCapsule generateBlock( } } // end of while - fastSyncCallBack.executeGenerateFinish(); + accountStateCallBack.executeGenerateFinish(); session.reset(); if (postponedTrxCount > 0) { @@ -1428,6 +1444,11 @@ public synchronized BlockCapsule generateBlock( blockCapsule.setMerkleRoot(); blockCapsule.sign(privateKey); + blockCapsule.setResult(transationRetCapsule); + + if (tronNetService != null) { + tronNetService.fastForward(new BlockMessage(blockCapsule)); + } try { this.pushBlock(blockCapsule); @@ -1516,22 +1537,30 @@ public void processBlock(BlockCapsule block) Thread.currentThread().interrupt(); } } + + TransactionRetCapsule transationRetCapsule = + new TransactionRetCapsule(block); + try { - fastSyncCallBack.preExecute(block); + accountStateCallBack.preExecute(block); for (TransactionCapsule transactionCapsule : block.getTransactions()) { transactionCapsule.setBlockNum(block.getNum()); if (block.generatedByMyself) { transactionCapsule.setVerified(true); } - fastSyncCallBack.preExeTrans(); - processTransaction(transactionCapsule, block); - fastSyncCallBack.exeTransFinish(); + accountStateCallBack.preExeTrans(); + TransactionInfo result = processTransaction(transactionCapsule, block); + accountStateCallBack.exeTransFinish(); + if (Objects.nonNull(result)) { + transationRetCapsule.addTransactionInfo(result); + } } - fastSyncCallBack.executePushFinish(); + accountStateCallBack.executePushFinish(); } finally { - fastSyncCallBack.exceptionFinish(); + accountStateCallBack.exceptionFinish(); } + block.setResult(transationRetCapsule); boolean needMaint = needMaintenance(block.getTimeStamp()); if (needMaint) { if (block.getNum() == 1) { @@ -1759,6 +1788,7 @@ public void closeAllStore() { closeOneStore(delegatedResourceAccountIndexStore); closeOneStore(assetIssueV2Store); closeOneStore(exchangeV2Store); + closeOneStore(transactionRetStore); logger.info("******** end to close db ********"); } diff --git a/src/main/java/org/tron/core/db/TransactionRetStore.java b/src/main/java/org/tron/core/db/TransactionRetStore.java new file mode 100644 index 00000000000..a4230e7a36c --- /dev/null +++ b/src/main/java/org/tron/core/db/TransactionRetStore.java @@ -0,0 +1,59 @@ +package org.tron.core.db; + +import com.google.protobuf.ByteString; +import java.util.Objects; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.BooleanUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Component; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionInfoCapsule; +import org.tron.core.capsule.TransactionRetCapsule; +import org.tron.core.config.args.Args; +import org.tron.core.exception.BadItemException; +import org.tron.protos.Protocol.TransactionInfo; + +@Slf4j(topic = "DB") +@Component +public class TransactionRetStore extends TronStoreWithRevoking { + + @Autowired + private TransactionStore transactionStore; + + @Autowired + public TransactionRetStore(@Value("transactionRetStore") String dbName) { + super(dbName); + } + + @Override + public void put(byte[] key, TransactionRetCapsule item) { + if (BooleanUtils.toBoolean(Args.getInstance().getStorage().getTransactionHistoreSwitch())) { + super.put(key, item); + } + } + + public TransactionInfoCapsule getTransactionInfo(byte[] key) throws BadItemException { + long blockNumber = transactionStore.getBlockNumber(key); + if (blockNumber == -1) { + return null; + } + byte[] value = revokingDB.getUnchecked(ByteArray.fromLong(blockNumber)); + if (Objects.isNull(value)) { + return null; + } + + TransactionRetCapsule result = new TransactionRetCapsule(value); + if (Objects.isNull(result) || Objects.isNull(result.getInstance())) { + return null; + } + + for (TransactionInfo transactionResultInfo : result.getInstance().getTransactioninfoList()) { + if (transactionResultInfo.getId().equals(ByteString.copyFrom(key))) { + return new TransactionInfoCapsule(transactionResultInfo); + } + } + return null; + } + +} diff --git a/src/main/java/org/tron/core/db/TransactionStore.java b/src/main/java/org/tron/core/db/TransactionStore.java index 08d9abf4e3a..14931ecd4e7 100644 --- a/src/main/java/org/tron/core/db/TransactionStore.java +++ b/src/main/java/org/tron/core/db/TransactionStore.java @@ -67,6 +67,19 @@ private TransactionCapsule getTransactionFromKhaosDatabase(byte[] key, long high return null; } + public long getBlockNumber(byte[] key) throws BadItemException { + byte[] value = revokingDB.getUnchecked(key); + if (ArrayUtils.isEmpty(value)) { + return -1; + } + + if (value.length == 8) { + return ByteArray.toLong(value); + } + TransactionCapsule transactionCapsule = new TransactionCapsule(value); + return transactionCapsule.getBlockNum(); + } + @Override public TransactionCapsule get(byte[] key) throws BadItemException { byte[] value = revokingDB.getUnchecked(key); diff --git a/src/main/java/org/tron/core/db/fast/AccountStateEntity.java b/src/main/java/org/tron/core/db/accountstate/AccountStateEntity.java similarity index 96% rename from src/main/java/org/tron/core/db/fast/AccountStateEntity.java rename to src/main/java/org/tron/core/db/accountstate/AccountStateEntity.java index 6055c05b388..45d8adb4df1 100644 --- a/src/main/java/org/tron/core/db/fast/AccountStateEntity.java +++ b/src/main/java/org/tron/core/db/accountstate/AccountStateEntity.java @@ -1,4 +1,4 @@ -package org.tron.core.db.fast; +package org.tron.core.db.accountstate; import lombok.extern.slf4j.Slf4j; import org.tron.core.Wallet; diff --git a/src/main/java/org/tron/core/db/fast/TrieService.java b/src/main/java/org/tron/core/db/accountstate/TrieService.java similarity index 93% rename from src/main/java/org/tron/core/db/fast/TrieService.java rename to src/main/java/org/tron/core/db/accountstate/TrieService.java index bb4c3edc60e..0dd5827006a 100644 --- a/src/main/java/org/tron/core/db/fast/TrieService.java +++ b/src/main/java/org/tron/core/db/accountstate/TrieService.java @@ -1,4 +1,4 @@ -package org.tron.core.db.fast; +package org.tron.core.db.accountstate; import com.google.protobuf.ByteString; import com.google.protobuf.Internal; @@ -9,7 +9,7 @@ import org.tron.common.crypto.Hash; import org.tron.core.capsule.BlockCapsule; import org.tron.core.db.Manager; -import org.tron.core.db.fast.storetrie.AccountStateStoreTrie; +import org.tron.core.db.accountstate.storetrie.AccountStateStoreTrie; @Slf4j(topic = "AccountState") @Component diff --git a/src/main/java/org/tron/core/db/fast/callback/FastSyncCallBack.java b/src/main/java/org/tron/core/db/accountstate/callback/AccountStateCallBack.java similarity index 95% rename from src/main/java/org/tron/core/db/fast/callback/FastSyncCallBack.java rename to src/main/java/org/tron/core/db/accountstate/callback/AccountStateCallBack.java index 577f1b89f4a..fe0d44896a3 100644 --- a/src/main/java/org/tron/core/db/fast/callback/FastSyncCallBack.java +++ b/src/main/java/org/tron/core/db/accountstate/callback/AccountStateCallBack.java @@ -1,4 +1,4 @@ -package org.tron.core.db.fast.callback; +package org.tron.core.db.accountstate.callback; import com.google.protobuf.ByteString; import com.google.protobuf.Internal; @@ -16,8 +16,8 @@ import org.tron.core.capsule.BlockCapsule; import org.tron.core.capsule.utils.RLP; import org.tron.core.db.Manager; -import org.tron.core.db.fast.AccountStateEntity; -import org.tron.core.db.fast.storetrie.AccountStateStoreTrie; +import org.tron.core.db.accountstate.AccountStateEntity; +import org.tron.core.db.accountstate.storetrie.AccountStateStoreTrie; import org.tron.core.exception.BadBlockException; import org.tron.core.trie.TrieImpl; import org.tron.core.trie.TrieImpl.Node; @@ -25,7 +25,7 @@ @Slf4j(topic = "AccountState") @Component -public class FastSyncCallBack { +public class AccountStateCallBack { private BlockCapsule blockCapsule; private volatile boolean execute = false; diff --git a/src/main/java/org/tron/core/db/fast/storetrie/AccountStateStoreTrie.java b/src/main/java/org/tron/core/db/accountstate/storetrie/AccountStateStoreTrie.java similarity index 91% rename from src/main/java/org/tron/core/db/fast/storetrie/AccountStateStoreTrie.java rename to src/main/java/org/tron/core/db/accountstate/storetrie/AccountStateStoreTrie.java index 0c85c3ef34e..df3a3a157ee 100644 --- a/src/main/java/org/tron/core/db/fast/storetrie/AccountStateStoreTrie.java +++ b/src/main/java/org/tron/core/db/accountstate/storetrie/AccountStateStoreTrie.java @@ -1,4 +1,4 @@ -package org.tron.core.db.fast.storetrie; +package org.tron.core.db.accountstate.storetrie; import javax.annotation.PostConstruct; import lombok.extern.slf4j.Slf4j; @@ -9,8 +9,8 @@ import org.tron.core.capsule.BytesCapsule; import org.tron.core.capsule.utils.RLP; import org.tron.core.db.TronStoreWithRevoking; -import org.tron.core.db.fast.AccountStateEntity; -import org.tron.core.db.fast.TrieService; +import org.tron.core.db.accountstate.AccountStateEntity; +import org.tron.core.db.accountstate.TrieService; import org.tron.core.db2.common.DB; import org.tron.core.trie.TrieImpl; diff --git a/src/main/java/org/tron/core/net/TronNetDelegate.java b/src/main/java/org/tron/core/net/TronNetDelegate.java index 969c42d7123..680a53a47f3 100644 --- a/src/main/java/org/tron/core/net/TronNetDelegate.java +++ b/src/main/java/org/tron/core/net/TronNetDelegate.java @@ -2,22 +2,22 @@ import java.util.Collection; import java.util.LinkedList; -import java.util.List; import java.util.Queue; import java.util.concurrent.ConcurrentLinkedQueue; import lombok.Getter; import lombok.extern.slf4j.Slf4j; +import org.spongycastle.util.encoders.Hex; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.common.overlay.message.Message; +import org.tron.common.overlay.server.ChannelManager; import org.tron.common.overlay.server.SyncPool; import org.tron.common.utils.Sha256Hash; import org.tron.core.capsule.BlockCapsule; import org.tron.core.capsule.BlockCapsule.BlockId; import org.tron.core.capsule.TransactionCapsule; -import org.tron.core.capsule.WitnessCapsule; import org.tron.core.db.Manager; -import org.tron.core.db.WitnessStore; +import org.tron.core.db.WitnessScheduleStore; import org.tron.core.exception.AccountResourceInsufficientException; import org.tron.core.exception.BadBlockException; import org.tron.core.exception.BadItemException; @@ -53,11 +53,14 @@ public class TronNetDelegate { @Autowired private SyncPool syncPool; + @Autowired + private ChannelManager channelManager; + @Autowired private Manager dbManager; @Autowired - private WitnessStore witnessStore; + private WitnessScheduleStore witnessScheduleStore; @Getter private Object blockLock = new Object(); @@ -74,6 +77,10 @@ public boolean offer(BlockId blockId) { } }; + public void trustNode (PeerConnection peer) { + channelManager.getTrustNodes().put(peer.getInetAddress(), peer.getNode()); + } + public Collection getActivePeer() { return syncPool.getActivePeers(); } @@ -171,6 +178,12 @@ public void processBlock(BlockCapsule block) throws P2pException { synchronized (blockLock) { try { if (!freshBlockId.contains(block.getBlockId())) { + if (block.getNum() <= getHeadBlockId().getNum()) { + logger.warn("Receive a fork block {} witness {}, head {}", + block.getBlockId().getString(), + Hex.toHexString(block.getWitnessAddress().toByteArray()), + getHeadBlockId().getString()); + } dbManager.pushBlock(block); freshBlockId.add(block.getBlockId()); logger.info("Success process block {}.", block.getBlockId().getString()); @@ -218,18 +231,8 @@ public void pushTransaction(TransactionCapsule trx) throws P2pException { public boolean validBlock(BlockCapsule block) throws P2pException { try { - if (!block.validateSignature(dbManager)) { - return false; - } - boolean flag = false; - List witnesses = witnessStore.getAllWitnesses(); - for (WitnessCapsule witness : witnesses) { - if (witness.getAddress().equals(block.getWitnessAddress())) { - flag = true; - break; - } - } - return flag; + return witnessScheduleStore.getActiveWitnesses().contains(block.getWitnessAddress()) + && block.validateSignature(dbManager); } catch (ValidateSignatureException e) { throw new P2pException(TypeEnum.BAD_BLOCK, e); } diff --git a/src/main/java/org/tron/core/net/TronNetService.java b/src/main/java/org/tron/core/net/TronNetService.java index 0fa16eb7f50..bd30c726b65 100644 --- a/src/main/java/org/tron/core/net/TronNetService.java +++ b/src/main/java/org/tron/core/net/TronNetService.java @@ -5,8 +5,10 @@ import org.springframework.stereotype.Component; import org.tron.common.overlay.message.Message; import org.tron.common.overlay.server.ChannelManager; +import org.tron.core.db.Manager; import org.tron.core.exception.P2pException; import org.tron.core.exception.P2pException.TypeEnum; +import org.tron.core.net.message.BlockMessage; import org.tron.core.net.message.TronMessage; import org.tron.core.net.messagehandler.BlockMsgHandler; import org.tron.core.net.messagehandler.ChainInventoryMsgHandler; @@ -55,7 +57,11 @@ public class TronNetService { @Autowired private TransactionsMsgHandler transactionsMsgHandler; + @Autowired + private Manager manager; + public void start() { + manager.setTronNetService(this); channelManager.init(); advService.init(); syncService.init(); @@ -77,6 +83,10 @@ public void broadcast(Message msg) { advService.broadcast(msg); } + public void fastForward(BlockMessage msg) { + advService.fastForward(msg); + } + protected void onMessage(PeerConnection peer, TronMessage msg) { try { switch (msg.getType()) { @@ -107,7 +117,7 @@ protected void onMessage(PeerConnection peer, TronMessage msg) { } private void processException(PeerConnection peer, TronMessage msg, Exception ex) { - ReasonCode code = null; + ReasonCode code; if (ex instanceof P2pException) { TypeEnum type = ((P2pException) ex).getType(); diff --git a/src/main/java/org/tron/core/net/messagehandler/BlockMsgHandler.java b/src/main/java/org/tron/core/net/messagehandler/BlockMsgHandler.java index 943874047bc..cd9712a61ff 100644 --- a/src/main/java/org/tron/core/net/messagehandler/BlockMsgHandler.java +++ b/src/main/java/org/tron/core/net/messagehandler/BlockMsgHandler.java @@ -3,7 +3,9 @@ import static org.tron.core.config.Parameter.ChainConstant.BLOCK_PRODUCED_INTERVAL; import static org.tron.core.config.Parameter.ChainConstant.BLOCK_SIZE; +import com.google.protobuf.ByteString; import lombok.extern.slf4j.Slf4j; +import org.spongycastle.util.encoders.Hex; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.capsule.BlockCapsule; @@ -45,19 +47,30 @@ public class BlockMsgHandler implements TronMsgHandler { public void processMessage(PeerConnection peer, TronMessage msg) throws P2pException { BlockMessage blockMessage = (BlockMessage) msg; + BlockId blockId = blockMessage.getBlockId(); - check(peer, blockMessage); + if (!fastForward && !peer.isFastForwardPeer()) { + check(peer, blockMessage); + } - BlockId blockId = blockMessage.getBlockId(); - Item item = new Item(blockId, InventoryType.BLOCK); if (peer.getSyncBlockRequested().containsKey(blockId)) { peer.getSyncBlockRequested().remove(blockId); syncService.processBlock(peer, blockMessage); } else { - logger.info("Receive block {} from {}, cost {}ms", blockId.getString(), peer.getInetAddress(), - System.currentTimeMillis() - peer.getAdvInvRequest().get(item)); - peer.getAdvInvRequest().remove(item); + Long time = peer.getAdvInvRequest().remove(new Item(blockId, InventoryType.BLOCK)); + long now = System.currentTimeMillis(); + long interval = blockId.getNum() - tronNetDelegate.getHeadBlockId().getNum(); processBlock(peer, blockMessage.getBlockCapsule()); + logger.info( + "Receive block/interval {}/{} from {} fetch/delay {}/{}ms, txs/process {}/{}ms, witness: {}", + blockId.getNum(), + interval, + peer.getInetAddress(), + time == null ? 0 : now - time, + now - blockMessage.getBlockCapsule().getTimeStamp(), + ((BlockMessage) msg).getBlockCapsule().getTransactions().size(), + System.currentTimeMillis() - now, + Hex.toHexString(blockMessage.getBlockCapsule().getWitnessAddress().toByteArray())); } } @@ -81,14 +94,27 @@ private void processBlock(PeerConnection peer, BlockCapsule block) throws P2pExc BlockId blockId = block.getBlockId(); if (!tronNetDelegate.containBlock(block.getParentBlockId())) { logger.warn("Get unlink block {} from {}, head is {}.", blockId.getString(), - peer.getInetAddress(), tronNetDelegate - .getHeadBlockId().getString()); + peer.getInetAddress(), tronNetDelegate.getHeadBlockId().getString()); syncService.startSync(peer); return; } - if (fastForward && tronNetDelegate.validBlock(block)) { - advService.broadcast(new BlockMessage(block)); + Item item = new Item(blockId, InventoryType.BLOCK); + if (fastForward || peer.isFastForwardPeer()) { + peer.getAdvInvReceive().put(item, System.currentTimeMillis()); + advService.addInvToCache(item); + } + + if (fastForward) { + if (block.getNum() < tronNetDelegate.getHeadBlockId().getNum()) { + logger.warn("Receive a low block {}, head {}", + blockId.getString(), tronNetDelegate.getHeadBlockId().getString()); + return; + } + if (tronNetDelegate.validBlock(block)) { + advService.fastForward(new BlockMessage(block)); + tronNetDelegate.trustNode(peer); + } } tronNetDelegate.processBlock(block); diff --git a/src/main/java/org/tron/core/net/peer/PeerConnection.java b/src/main/java/org/tron/core/net/peer/PeerConnection.java index 353541c89f8..f1fb61baab4 100644 --- a/src/main/java/org/tron/core/net/peer/PeerConnection.java +++ b/src/main/java/org/tron/core/net/peer/PeerConnection.java @@ -18,6 +18,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Component; +import org.tron.common.overlay.discover.node.statistics.NodeStatistics.SimpleStatter; import org.tron.common.overlay.message.HelloMessage; import org.tron.common.overlay.message.Message; import org.tron.common.overlay.server.Channel; @@ -42,16 +43,12 @@ public class PeerConnection extends Channel { @Autowired private AdvService advService; - private int invCacheSize = 100_000; - - @Setter - @Getter - private BlockId signUpErrorBlockId; - @Setter @Getter private HelloMessage helloMessage; + private int invCacheSize = 100_000; + @Setter @Getter private Cache advInvReceive = CacheBuilder.newBuilder().maximumSize(invCacheSize) @@ -66,6 +63,9 @@ public class PeerConnection extends Channel { @Getter private Map advInvRequest = new ConcurrentHashMap<>(); + @Setter + private BlockId fastForwardBlock; + @Getter private BlockId blockBothHave = new BlockId(); @@ -75,7 +75,7 @@ public void setBlockBothHave(BlockId blockId) { } @Getter - private long blockBothHaveUpdateTime = System.currentTimeMillis(); + private volatile long blockBothHaveUpdateTime = System.currentTimeMillis(); @Setter @Getter @@ -83,7 +83,7 @@ public void setBlockBothHave(BlockId blockId) { @Setter @Getter - private long remainNum; + private volatile long remainNum; @Getter private Cache syncBlockIdCache = CacheBuilder.newBuilder() @@ -107,11 +107,11 @@ public void setBlockBothHave(BlockId blockId) { @Setter @Getter - private boolean needSyncFromPeer; + private volatile boolean needSyncFromPeer; @Setter @Getter - private boolean needSyncFromUs; + private volatile boolean needSyncFromUs; public boolean isIdle() { return advInvRequest.isEmpty() && syncBlockRequested.isEmpty() && syncChainRequested == null; @@ -172,7 +172,8 @@ public String log() { // nodeStatistics.toString()); //// return String.format( - "Peer %s: [ %18s, ping %6s ms]-----------\n" + "Peer %s [%8s]\n" + + "ping msg: count %d, max-average-min-last: %d %d %d %d\n" + "connect time: %ds\n" + "last know block num: %s\n" + "needSyncFromPeer:%b\n" @@ -183,11 +184,17 @@ public String log() { + "remainNum:%d\n" + "syncChainRequested:%d\n" + "blockInProcess:%d\n", - this.getNode().getHost() + ":" + this.getNode().getPort(), - this.getNode().getHexIdShort(), - (int) this.getPeerStats().getAvgLatency(), - (now - super.getStartTime()) / 1000, - blockBothHave.getNum(), + getNode().getHost() + ":" + getNode().getPort(), + getNode().getHexIdShort(), + + getNodeStatistics().pingMessageLatency.getCount(), + getNodeStatistics().pingMessageLatency.getMax(), + getNodeStatistics().pingMessageLatency.getAvrg(), + getNodeStatistics().pingMessageLatency.getMin(), + getNodeStatistics().pingMessageLatency.getLast(), + + (now - getStartTime()) / 1000, + fastForwardBlock != null ? fastForwardBlock.getNum() : blockBothHave.getNum(), isNeedSyncFromPeer(), isNeedSyncFromUs(), syncBlockToFetch.size(), diff --git a/src/main/java/org/tron/core/net/peer/PeerStatusCheck.java b/src/main/java/org/tron/core/net/peer/PeerStatusCheck.java index a07f6c39e94..c7cd04565ff 100644 --- a/src/main/java/org/tron/core/net/peer/PeerStatusCheck.java +++ b/src/main/java/org/tron/core/net/peer/PeerStatusCheck.java @@ -20,7 +20,7 @@ public class PeerStatusCheck { private ScheduledExecutorService peerStatusCheckExecutor = Executors .newSingleThreadScheduledExecutor(); - private int blockUpdateTimeout = 20_000; + private int blockUpdateTimeout = 30_000; public void init() { peerStatusCheckExecutor.scheduleWithFixedDelay(() -> { diff --git a/src/main/java/org/tron/core/net/service/AdvService.java b/src/main/java/org/tron/core/net/service/AdvService.java index 36e74cb77a4..3684946a833 100644 --- a/src/main/java/org/tron/core/net/service/AdvService.java +++ b/src/main/java/org/tron/core/net/service/AdvService.java @@ -95,9 +95,14 @@ public void close() { fetchExecutor.shutdown(); } + synchronized public void addInvToCache(Item item) { + invToFetchCache.put(item, System.currentTimeMillis()); + invToFetch.remove(item); + } + synchronized public boolean addInv(Item item) { - if (fastForward && !InventoryType.BLOCK.equals(item.getType())) { + if (fastForward && item.getType().equals(InventoryType.TRX)) { return false; } @@ -135,7 +140,7 @@ public Message getMessage(Item item) { public void broadcast(Message msg) { - if (fastForward && !(msg instanceof BlockMessage)) { + if (fastForward) { return; } @@ -160,8 +165,7 @@ public void broadcast(Message msg) { TransactionMessage trxMsg = (TransactionMessage) msg; item = new Item(trxMsg.getMessageId(), InventoryType.TRX); trxCount.add(); - trxCache.put(item, - new TransactionMessage(((TransactionMessage) msg).getTransactionCapsule().getInstance())); + trxCache.put(item, new TransactionMessage(trxMsg.getTransactionCapsule().getInstance())); } else { logger.error("Adv item is neither block nor trx, type: {}", msg.getType()); return; @@ -174,6 +178,26 @@ public void broadcast(Message msg) { } } + public void fastForward(BlockMessage msg) { + Item item = new Item(msg.getBlockId(), InventoryType.BLOCK); + List peers = tronNetDelegate.getActivePeer().stream() + .filter(peer -> !peer.isNeedSyncFromPeer() && !peer.isNeedSyncFromUs()) + .filter(peer -> peer.getAdvInvReceive().getIfPresent(item) == null + && peer.getAdvInvSpread().getIfPresent(item) == null) + .collect(Collectors.toList()); + + if (!fastForward) { + peers = peers.stream().filter(peer -> peer.isFastForwardPeer()).collect(Collectors.toList()); + } + + peers.forEach(peer -> { + peer.sendMessage(msg); + peer.getAdvInvSpread().put(item, System.currentTimeMillis()); + peer.setFastForwardBlock(msg.getBlockId()); + }); + } + + public void onDisconnect(PeerConnection peer) { if (!peer.getAdvInvRequest().isEmpty()) { peer.getAdvInvRequest().keySet().forEach(item -> { @@ -285,7 +309,7 @@ public int getSize(PeerConnection peer) { public void sendInv() { send.forEach((peer, ids) -> ids.forEach((key, value) -> { - if (key.equals(InventoryType.TRX) && peer.isFastForwardPeer()) { + if (peer.isFastForwardPeer() && key.equals(InventoryType.TRX)) { return; } if (key.equals(InventoryType.BLOCK)) { diff --git a/src/main/java/org/tron/core/net/service/SyncService.java b/src/main/java/org/tron/core/net/service/SyncService.java index 6168a2a808d..775e25943e9 100644 --- a/src/main/java/org/tron/core/net/service/SyncService.java +++ b/src/main/java/org/tron/core/net/service/SyncService.java @@ -230,26 +230,28 @@ private synchronized void handleSyncBlock() { isProcessed[0] = false; - blockWaitToProcess.forEach((msg, peerConnection) -> { - if (peerConnection.isDisconnect()) { - blockWaitToProcess.remove(msg); - invalid(msg.getBlockId()); - return; - } - final boolean[] isFound = {false}; - tronNetDelegate.getActivePeer().stream() - .filter(peer -> msg.getBlockId().equals(peer.getSyncBlockToFetch().peek())) - .forEach(peer -> { - peer.getSyncBlockToFetch().pop(); - peer.getSyncBlockInProcess().add(msg.getBlockId()); - isFound[0] = true; - }); - if (isFound[0]) { - blockWaitToProcess.remove(msg); - isProcessed[0] = true; - processSyncBlock(msg.getBlockCapsule()); - } - }); + synchronized (tronNetDelegate.getBlockLock()) { + blockWaitToProcess.forEach((msg, peerConnection) -> { + if (peerConnection.isDisconnect()) { + blockWaitToProcess.remove(msg); + invalid(msg.getBlockId()); + return; + } + final boolean[] isFound = {false}; + tronNetDelegate.getActivePeer().stream() + .filter(peer -> msg.getBlockId().equals(peer.getSyncBlockToFetch().peek())) + .forEach(peer -> { + peer.getSyncBlockToFetch().pop(); + peer.getSyncBlockInProcess().add(msg.getBlockId()); + isFound[0] = true; + }); + if (isFound[0]) { + blockWaitToProcess.remove(msg); + isProcessed[0] = true; + processSyncBlock(msg.getBlockCapsule()); + } + }); + } } } diff --git a/src/main/java/org/tron/core/services/NodeInfoService.java b/src/main/java/org/tron/core/services/NodeInfoService.java index 141ac56c17c..36103be5bec 100644 --- a/src/main/java/org/tron/core/services/NodeInfoService.java +++ b/src/main/java/org/tron/core/services/NodeInfoService.java @@ -127,7 +127,7 @@ private void setConnectInfo(NodeInfo nodeInfo) { PeerInfo peerInfo = new PeerInfo(); peerInfo.setHeadBlockWeBothHave(peerConnection.getBlockBothHave().getString()); peerInfo.setActive(peerConnection.isActive()); - peerInfo.setAvgLatency(peerConnection.getPeerStats().getAvgLatency()); + peerInfo.setAvgLatency(peerConnection.getNodeStatistics().pingMessageLatency.getAvrg()); peerInfo.setBlockInPorcSize(peerConnection.getSyncBlockInProcess().size()); peerInfo.setConnectTime(peerConnection.getStartTime()); peerInfo.setDisconnectTimes(peerConnection.getNodeStatistics().getDisconnectTimes()); diff --git a/src/main/java/org/tron/program/FullNode.java b/src/main/java/org/tron/program/FullNode.java index 25619c36980..81debdcac52 100644 --- a/src/main/java/org/tron/program/FullNode.java +++ b/src/main/java/org/tron/program/FullNode.java @@ -1,11 +1,9 @@ package org.tron.program; -import ch.qos.logback.classic.Level; import ch.qos.logback.classic.LoggerContext; import ch.qos.logback.classic.joran.JoranConfigurator; import java.io.File; import lombok.extern.slf4j.Slf4j; -import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.support.DefaultListableBeanFactory; import org.tron.common.application.Application; diff --git a/src/main/java/org/tron/program/Version.java b/src/main/java/org/tron/program/Version.java index 5a938441726..e80165ce9dd 100644 --- a/src/main/java/org/tron/program/Version.java +++ b/src/main/java/org/tron/program/Version.java @@ -1,9 +1,10 @@ package org.tron.program; public class Version { - private static final String version = "3.6.0"; - public static final String versionName = "Odyssey-v3.5.1-900-g7fe0ed20d"; - public static final String versionCode = "10813"; + + private static final String version = "3.6.1"; + public static final String versionName = "Odyssey-v3.5.1-890-gd39973cbb"; + public static final String versionCode = "10803"; public static String getVersion() { return version; diff --git a/src/main/protos/core/Tron.proto b/src/main/protos/core/Tron.proto index 5f6f4167aa5..9e16c098de1 100644 --- a/src/main/protos/core/Tron.proto +++ b/src/main/protos/core/Tron.proto @@ -369,6 +369,12 @@ message TransactionInfo { int64 exchange_id = 21; } +message TransactionRet { + int64 blockNumber = 1; + int64 blockTimeStamp = 2; + repeated TransactionInfo transactioninfo = 3; +} + message Transactions { repeated Transaction transactions = 1; } diff --git a/src/main/resources/config.conf b/src/main/resources/config.conf index ba3cfffe83b..2787c3e6238 100644 --- a/src/main/resources/config.conf +++ b/src/main/resources/config.conf @@ -149,7 +149,8 @@ node { ] fastForward = [ - "47.90.208.194:18888" + "47.90.208.194:18888", + "47.75.212.39:18888" ] http { diff --git a/src/test/java/org/tron/core/WalletTest.java b/src/test/java/org/tron/core/WalletTest.java index ef4beba632c..259856fc75c 100644 --- a/src/test/java/org/tron/core/WalletTest.java +++ b/src/test/java/org/tron/core/WalletTest.java @@ -47,6 +47,7 @@ import org.tron.core.capsule.ExchangeCapsule; import org.tron.core.capsule.ProposalCapsule; import org.tron.core.capsule.TransactionCapsule; +import org.tron.core.capsule.TransactionInfoCapsule; import org.tron.core.config.DefaultConfig; import org.tron.core.config.Parameter.ChainParameters; import org.tron.core.config.args.Args; @@ -64,6 +65,7 @@ import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract; import org.tron.protos.Protocol.Transaction.Contract.ContractType; +import org.tron.protos.Protocol.TransactionInfo; @Slf4j public class WalletTest { @@ -134,22 +136,27 @@ private static void initTransaction() { getBuildTransferContract(ACCOUNT_ADDRESS_ONE, ACCOUNT_ADDRESS_TWO), TRANSACTION_TIMESTAMP_ONE, BLOCK_NUM_ONE); addTransactionToStore(transaction1); + transaction2 = getBuildTransaction( getBuildTransferContract(ACCOUNT_ADDRESS_TWO, ACCOUNT_ADDRESS_THREE), TRANSACTION_TIMESTAMP_TWO, BLOCK_NUM_TWO); addTransactionToStore(transaction2); + transaction3 = getBuildTransaction( getBuildTransferContract(ACCOUNT_ADDRESS_THREE, ACCOUNT_ADDRESS_FOUR), TRANSACTION_TIMESTAMP_THREE, BLOCK_NUM_THREE); addTransactionToStore(transaction3); + transaction4 = getBuildTransaction( getBuildTransferContract(ACCOUNT_ADDRESS_FOUR, ACCOUNT_ADDRESS_FIVE), TRANSACTION_TIMESTAMP_FOUR, BLOCK_NUM_FOUR); addTransactionToStore(transaction4); + transaction5 = getBuildTransaction( getBuildTransferContract(ACCOUNT_ADDRESS_FIVE, ACCOUNT_ADDRESS_ONE), TRANSACTION_TIMESTAMP_FIVE, BLOCK_NUM_FIVE); addTransactionToStore(transaction5); + transaction6 = getBuildTransaction( getBuildTransferContract(ACCOUNT_ADDRESS_ONE, ACCOUNT_ADDRESS_SIX), TRANSACTION_TIMESTAMP_FIVE, BLOCK_NUM_FIVE); @@ -162,6 +169,14 @@ private static void addTransactionToStore(Transaction transaction) { .put(transactionCapsule.getTransactionId().getBytes(), transactionCapsule); } + private static void addTransactionInfoToStore(Transaction transaction) { + TransactionInfoCapsule transactionInfo = new TransactionInfoCapsule(); + byte[] trxId = transaction.getRawData().toByteArray(); + transactionInfo.setId(trxId); + manager.getTransactionHistoryStore().put(trxId, transactionInfo); + } + + private static Transaction getBuildTransaction( TransferContract transferContract, long transactionTimestamp, long refBlockNum) { return Transaction.newBuilder().setRawData( @@ -187,18 +202,27 @@ private static void initBlock() { block1 = getBuildBlock(BLOCK_TIMESTAMP_ONE, BLOCK_NUM_ONE, BLOCK_WITNESS_ONE, ACCOUNT_ADDRESS_ONE, transaction1, transaction2); addBlockToStore(block1); + addTransactionInfoToStore(transaction1); + block2 = getBuildBlock(BLOCK_TIMESTAMP_TWO, BLOCK_NUM_TWO, BLOCK_WITNESS_TWO, ACCOUNT_ADDRESS_TWO, transaction2, transaction3); addBlockToStore(block2); + addTransactionInfoToStore(transaction2); + block3 = getBuildBlock(BLOCK_TIMESTAMP_THREE, BLOCK_NUM_THREE, BLOCK_WITNESS_THREE, ACCOUNT_ADDRESS_THREE, transaction2, transaction4); addBlockToStore(block3); + addTransactionInfoToStore(transaction3); + block4 = getBuildBlock(BLOCK_TIMESTAMP_FOUR, BLOCK_NUM_FOUR, BLOCK_WITNESS_FOUR, ACCOUNT_ADDRESS_FOUR, transaction4, transaction5); addBlockToStore(block4); + addTransactionInfoToStore(transaction4); + block5 = getBuildBlock(BLOCK_TIMESTAMP_FIVE, BLOCK_NUM_FIVE, BLOCK_WITNESS_FIVE, ACCOUNT_ADDRESS_FIVE, transaction5, transaction3); addBlockToStore(block5); + addTransactionInfoToStore(transaction5); } private static void addBlockToStore(Block block) { @@ -336,6 +360,44 @@ public void getBlocksByLimit() { Assert.assertFalse("getBlocksByLimit8", blocksByLimit.getBlockList().contains(block5)); } + @Test + public void getTransactionInfoById() { + TransactionInfo transactionById1 = wallet.getTransactionInfoById( + ByteString + .copyFrom(transaction1.getRawData().toByteArray())); + Assert.assertEquals("gettransactioninfobyid", + ByteString.copyFrom(transactionById1.getId().toByteArray()), + ByteString.copyFrom(transaction1.getRawData().toByteArray())); + + TransactionInfo transactionById2 = wallet.getTransactionInfoById( + ByteString + .copyFrom(transaction2.getRawData().toByteArray())); + Assert.assertEquals("gettransactioninfobyid", + ByteString.copyFrom(transactionById2.getId().toByteArray()), + ByteString.copyFrom(transaction2.getRawData().toByteArray())); + + TransactionInfo transactionById3 = wallet.getTransactionInfoById( + ByteString + .copyFrom(transaction3.getRawData().toByteArray())); + Assert.assertEquals("gettransactioninfobyid", + ByteString.copyFrom(transactionById3.getId().toByteArray()), + ByteString.copyFrom(transaction3.getRawData().toByteArray())); + + TransactionInfo transactionById4 = wallet.getTransactionInfoById( + ByteString + .copyFrom(transaction4.getRawData().toByteArray())); + Assert.assertEquals("gettransactioninfobyid", + ByteString.copyFrom(transactionById4.getId().toByteArray()), + ByteString.copyFrom(transaction4.getRawData().toByteArray())); + + TransactionInfo transactionById5 = wallet.getTransactionInfoById( + ByteString + .copyFrom(transaction5.getRawData().toByteArray())); + Assert.assertEquals("gettransactioninfobyid", + ByteString.copyFrom(transactionById5.getId().toByteArray()), + ByteString.copyFrom(transaction5.getRawData().toByteArray())); + } + @Ignore @Test public void getTransactionById() { diff --git a/src/test/java/org/tron/core/db/TransactionRetStoreTest.java b/src/test/java/org/tron/core/db/TransactionRetStoreTest.java new file mode 100644 index 00000000000..baf36ddb5b9 --- /dev/null +++ b/src/test/java/org/tron/core/db/TransactionRetStoreTest.java @@ -0,0 +1,91 @@ +package org.tron.core.db; + +import java.io.File; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.tron.common.application.TronApplicationContext; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.FileUtil; +import org.tron.core.Constant; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.core.capsule.TransactionInfoCapsule; +import org.tron.core.capsule.TransactionRetCapsule; +import org.tron.core.config.DefaultConfig; +import org.tron.core.config.args.Args; +import org.tron.core.exception.BadItemException; +import org.tron.protos.Protocol.Transaction; + +public class TransactionRetStoreTest { + + private static String dbPath = "output_TransactionRetStore_test"; + private static String dbDirectory = "db_TransactionRetStore_test"; + private static String indexDirectory = "index_TransactionRetStore_test"; + private static TronApplicationContext context; + private static TransactionRetStore transactionRetStore; + private static Transaction transaction; + private static TransactionStore transactionStore; + private static final byte[] transactionId = TransactionStoreTest.randomBytes(32); + private static final byte[] blockNum = ByteArray.fromLong(1); + + static { + Args.setParam( + new String[]{ + "--output-directory", dbPath, + "--storage-db-directory", dbDirectory, + "--storage-index-directory", indexDirectory + }, + Constant.TEST_CONF + ); + context = new TronApplicationContext(DefaultConfig.class); + } + + @AfterClass + public static void destroy() { + Args.clearParam(); + context.destroy(); + FileUtil.deleteDir(new File(dbPath)); + } + + @BeforeClass + public static void init() { + transactionRetStore = context.getBean(TransactionRetStore.class); + transactionStore = context.getBean(TransactionStore.class); + TransactionInfoCapsule transactionInfoCapsule = new TransactionInfoCapsule(); + + transactionInfoCapsule.setId(transactionId); + transactionInfoCapsule.setFee(1000L); + transactionInfoCapsule.setBlockNumber(100L); + transactionInfoCapsule.setBlockTimeStamp(200L); + + TransactionRetCapsule transactionRetCapsule = new TransactionRetCapsule(); + transactionRetCapsule.addTransactionInfo(transactionInfoCapsule.getInstance()); + transactionRetStore.put(blockNum, transactionRetCapsule); + transaction = Transaction.newBuilder().build(); + TransactionCapsule transactionCapsule = new TransactionCapsule(transaction); + transactionCapsule.setBlockNum(1); + transactionStore.put(transactionId, transactionCapsule); + } + + @Test + public void get() throws BadItemException { + TransactionInfoCapsule resultCapsule = transactionRetStore.getTransactionInfo(transactionId); + Assert.assertNotNull("get transaction ret store", resultCapsule); + } + + @Test + public void put() { + TransactionInfoCapsule transactionInfoCapsule = new TransactionInfoCapsule(); + transactionInfoCapsule.setId(transactionId); + transactionInfoCapsule.setFee(1000L); + transactionInfoCapsule.setBlockNumber(100L); + transactionInfoCapsule.setBlockTimeStamp(200L); + + TransactionRetCapsule transactionRetCapsule = new TransactionRetCapsule(); + transactionRetCapsule.addTransactionInfo(transactionInfoCapsule.getInstance()); + Assert.assertNull("put transaction info error", transactionRetStore.getUnchecked(transactionInfoCapsule.getId())); + transactionRetStore.put(transactionInfoCapsule.getId(), transactionRetCapsule); + Assert.assertNotNull("get transaction info error", transactionRetStore.getUnchecked(transactionInfoCapsule.getId())); + } +} \ No newline at end of file diff --git a/src/test/java/stest/tron/wallet/account/WalletTestAccount013.java b/src/test/java/stest/tron/wallet/account/WalletTestAccount013.java index 1012b6de3f2..39129298c5f 100644 --- a/src/test/java/stest/tron/wallet/account/WalletTestAccount013.java +++ b/src/test/java/stest/tron/wallet/account/WalletTestAccount013.java @@ -385,7 +385,7 @@ public void test4DelegateResourceAboutTransferAsset() { } @Test(enabled = true) - public void test5DelegateResourceAboutTriggerContract() { + public void test5CanNotDelegateResourceToContract() { //Create Account6 ECKey ecKey6 = new ECKey(Utils.getRandom()); accountForDeployAddress = ecKey6.getAddress(); @@ -394,6 +394,7 @@ public void test5DelegateResourceAboutTriggerContract() { //sendcoin to Account6 Assert.assertTrue(PublicMethed.sendcoin(accountForDeployAddress, 10000000000L, fromAddress, testKey002, blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); //deploy contract under Account6 Integer consumeUserResourcePercent = 0; @@ -411,6 +412,7 @@ public void test5DelegateResourceAboutTriggerContract() { accountForDeployAddress, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); //Account4 DelegatedResource of Energy to Contract + //After 3.6 can not delegate resource to contract Assert.assertFalse(PublicMethed.freezeBalanceForReceiver( account4DelegatedResourceAddress, freezeAmount, freezeDuration, 1, ByteString.copyFrom(contractAddress), account4DelegatedResourceKey, blockingStubFull)); @@ -465,6 +467,7 @@ public void test5DelegateResourceAboutTriggerContract() { // //compare bandwidth of Account013 before and after trigger contract // Assert.assertTrue(account013CurrentBandwidthUsed // == account013CurrentBandwidthUsedAfterTrig - contractTriggerBandwidthUsed); + } /** diff --git a/src/test/java/stest/tron/wallet/common/client/utils/HttpMethed.java b/src/test/java/stest/tron/wallet/common/client/utils/HttpMethed.java index e998223a6c7..56c68c8f786 100644 --- a/src/test/java/stest/tron/wallet/common/client/utils/HttpMethed.java +++ b/src/test/java/stest/tron/wallet/common/client/utils/HttpMethed.java @@ -8,7 +8,6 @@ import java.nio.charset.Charset; import java.util.HashMap; import java.util.Map; - import lombok.extern.slf4j.Slf4j; import org.apache.http.HttpResponse; import org.apache.http.client.HttpClient; @@ -2338,4 +2337,56 @@ public static String str2hex(String str) { } return sb.toString().trim(); } + + + /** + * constructor. + */ + public static HttpResponse triggerConstantContract(String httpNode, byte[] ownerAddress, + String contractAddress, String functionSelector, String parameter) { + try { + final String requestUrl = "http://" + httpNode + "/wallet/triggerconstantcontract"; + JsonObject userBaseObj2 = new JsonObject(); + userBaseObj2.addProperty("owner_address", ByteArray.toHexString(ownerAddress)); + userBaseObj2.addProperty("contract_address", contractAddress); + userBaseObj2.addProperty("function_selector", functionSelector); + userBaseObj2.addProperty("parameter", parameter); + response = createConnect(requestUrl, userBaseObj2); + return response; + } catch (Exception e) { + e.printStackTrace(); + httppost.releaseConnection(); + return null; + } + } + + + /** + * constructor. + */ + public static HttpResponse clearABiGetTxid(String httpNode, byte[] ownerAddress, + String contractAddress, String fromKey) { + try { + final String requestUrl = "http://" + httpNode + "/wallet/clearabi"; + JsonObject userBaseObj2 = new JsonObject(); + userBaseObj2.addProperty("owner_address", ByteArray.toHexString(ownerAddress)); + userBaseObj2.addProperty("contract_address", contractAddress); + response = createConnect(requestUrl, userBaseObj2); + transactionString = EntityUtils.toString(response.getEntity()); + logger.info(transactionString); + + transactionSignString = gettransactionsign(httpNode, transactionString, fromKey); + + logger.info(transactionSignString); + response = broadcastTransaction(httpNode, transactionSignString); + + + } catch (Exception e) { + e.printStackTrace(); + httppost.releaseConnection(); + return null; + } + return response; + } + } diff --git a/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java b/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java index 1a6b8fac0b8..b117d9e3c20 100644 --- a/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java +++ b/src/test/java/stest/tron/wallet/common/client/utils/PublicMethed.java @@ -2,6 +2,7 @@ import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; +import com.google.common.primitives.Longs; import com.google.gson.JsonArray; import com.google.gson.JsonElement; import com.google.gson.JsonParser; @@ -19,7 +20,6 @@ import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.Objects; import java.util.Optional; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -47,7 +47,7 @@ import org.tron.common.crypto.ECKey.ECDSASignature; import org.tron.common.crypto.Hash; import org.tron.common.utils.ByteArray; -import org.tron.common.utils.Utils; +import org.tron.common.utils.ByteUtil; import org.tron.core.Wallet; import org.tron.keystore.WalletFile; import org.tron.protos.Contract; @@ -58,7 +58,6 @@ import org.tron.protos.Protocol; import org.tron.protos.Protocol.Account; import org.tron.protos.Protocol.Block; -//import org.tron.protos.Protocol.DeferredTransaction; import org.tron.protos.Protocol.DelegatedResourceAccountIndex; import org.tron.protos.Protocol.Exchange; import org.tron.protos.Protocol.Key; @@ -71,6 +70,8 @@ import stest.tron.wallet.common.client.Parameter.CommonConstant; import stest.tron.wallet.common.client.WalletClient; +//import org.tron.protos.Protocol.DeferredTransaction; + public class PublicMethed { @@ -1675,16 +1676,16 @@ public static boolean waitProduceNextBlock(WalletGrpc.WalletBlockingStub Integer wait = 0; logger.info("Block num is " + Long.toString(currentBlock .getBlockHeader().getRawData().getNumber())); - while (nextNum <= currentNum + 1 && wait <= 15) { + while (nextNum <= currentNum + 1 && wait <= 45) { try { - Thread.sleep(3000); + Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } logger.info("Wait to produce next block"); nextBlock = blockingStubFull.getNowBlock(GrpcAPI.EmptyMessage.newBuilder().build()); nextNum = nextBlock.getBlockHeader().getRawData().getNumber(); - if (wait == 15) { + if (wait == 45) { logger.info("These 45 second didn't produce a block,please check."); return false; } @@ -3058,7 +3059,6 @@ public static String triggerContract(byte[] contractAddress, String method, Stri /** * constructor. */ - public static String triggerContract(byte[] contractAddress, String method, String argsStr, Boolean isHex, long callValue, long feeLimit, String tokenId, long tokenValue, byte[] ownerAddress, @@ -3153,6 +3153,104 @@ public static String triggerContract(byte[] contractAddress, String method, Stri } } + /** + * constructor. + */ + + public static String triggerParamListContract(byte[] contractAddress, String method, + List params, + Boolean isHex, long callValue, long feeLimit, String tokenId, long tokenValue, + byte[] ownerAddress, + String priKey, WalletGrpc.WalletBlockingStub blockingStubFull) { + + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + ECKey temKey = null; + try { + BigInteger priK = new BigInteger(priKey, 16); + temKey = ECKey.fromPrivate(priK); + } catch (Exception ex) { + ex.printStackTrace(); + } + final ECKey ecKey = temKey; + + byte[] owner = ownerAddress; + byte[] input = Hex.decode(AbiUtil.parseMethod(method, params)); + + Contract.TriggerSmartContract.Builder builder = Contract.TriggerSmartContract.newBuilder(); + builder.setOwnerAddress(ByteString.copyFrom(owner)); + builder.setContractAddress(ByteString.copyFrom(contractAddress)); + builder.setData(ByteString.copyFrom(input)); + builder.setCallValue(callValue); + builder.setTokenId(Long.parseLong(tokenId)); + builder.setCallTokenValue(tokenValue); + Contract.TriggerSmartContract triggerContract = builder.build(); + + TransactionExtention transactionExtention = blockingStubFull.triggerContract(triggerContract); + if (transactionExtention == null || !transactionExtention.getResult().getResult()) { + System.out.println("RPC create call trx failed!"); + System.out.println("Code = " + transactionExtention.getResult().getCode()); + System.out + .println("Message = " + transactionExtention.getResult().getMessage().toStringUtf8()); + return null; + } + Transaction transaction = transactionExtention.getTransaction(); + if (transaction.getRetCount() != 0 + && transactionExtention.getConstantResult(0) != null + && transactionExtention.getResult() != null) { + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + return null; + } + + final TransactionExtention.Builder texBuilder = TransactionExtention.newBuilder(); + Transaction.Builder transBuilder = Transaction.newBuilder(); + Transaction.raw.Builder rawBuilder = transactionExtention.getTransaction().getRawData() + .toBuilder(); + rawBuilder.setFeeLimit(feeLimit); + transBuilder.setRawData(rawBuilder); + for (int i = 0; i < transactionExtention.getTransaction().getSignatureCount(); i++) { + ByteString s = transactionExtention.getTransaction().getSignature(i); + transBuilder.setSignature(i, s); + } + for (int i = 0; i < transactionExtention.getTransaction().getRetCount(); i++) { + Result r = transactionExtention.getTransaction().getRet(i); + transBuilder.setRet(i, r); + } + texBuilder.setTransaction(transBuilder); + texBuilder.setResult(transactionExtention.getResult()); + texBuilder.setTxid(transactionExtention.getTxid()); + transactionExtention = texBuilder.build(); + if (transactionExtention == null) { + return null; + } + Return ret = transactionExtention.getResult(); + if (!ret.getResult()) { + System.out.println("Code = " + ret.getCode()); + System.out.println("Message = " + ret.getMessage().toStringUtf8()); + return null; + } + transaction = transactionExtention.getTransaction(); + if (transaction == null || transaction.getRawData().getContractCount() == 0) { + System.out.println("Transaction is empty"); + return null; + } + transaction = signTransaction(ecKey, transaction); + System.out.println( + "trigger txid = " + ByteArray.toHexString(Sha256Hash.hash(transaction.getRawData() + .toByteArray()))); + GrpcAPI.Return response = broadcastTransaction(transaction, blockingStubFull); + if (response.getResult() == false) { + return null; + } else { + return ByteArray.toHexString(Sha256Hash.hash(transaction.getRawData().toByteArray())); + } + + + } + /** * constructor. */ @@ -4387,4 +4485,336 @@ public static HashMap getBycodeAbiForLibrary(String solFile, return retMap; } + /** + * constructor. + */ + public static String triggerConstantContract(byte[] contractAddress, String method, + String argsStr, + Boolean isHex, long callValue, long feeLimit, String tokenId, long tokenValue, + byte[] ownerAddress, + String priKey, WalletGrpc.WalletBlockingStub blockingStubFull) { + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + ECKey temKey = null; + try { + BigInteger priK = new BigInteger(priKey, 16); + temKey = ECKey.fromPrivate(priK); + } catch (Exception ex) { + ex.printStackTrace(); + } + final ECKey ecKey = temKey; + if (argsStr.equalsIgnoreCase("#")) { + logger.info("argsstr is #"); + argsStr = ""; + } + + byte[] owner = ownerAddress; + byte[] input = Hex.decode(AbiUtil.parseMethod(method, argsStr, isHex)); + + Contract.TriggerSmartContract.Builder builder = Contract.TriggerSmartContract.newBuilder(); + builder.setOwnerAddress(ByteString.copyFrom(owner)); + builder.setContractAddress(ByteString.copyFrom(contractAddress)); + builder.setData(ByteString.copyFrom(input)); + builder.setCallValue(callValue); + builder.setTokenId(Long.parseLong(tokenId)); + builder.setCallTokenValue(tokenValue); + Contract.TriggerSmartContract triggerContract = builder.build(); + + TransactionExtention transactionExtention = blockingStubFull + .triggerConstantContract(triggerContract); + if (transactionExtention == null || !transactionExtention.getResult().getResult()) { + System.out.println("RPC create call trx failed!"); + System.out.println("Code = " + transactionExtention.getResult().getCode()); + System.out + .println("Message = " + transactionExtention.getResult().getMessage().toStringUtf8()); + return null; + } + Transaction transaction = transactionExtention.getTransaction(); + if (transaction.getRetCount() != 0 + && transactionExtention.getConstantResult(0) != null + && transactionExtention.getResult() != null) { + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + return null; + } + + final TransactionExtention.Builder texBuilder = TransactionExtention.newBuilder(); + Transaction.Builder transBuilder = Transaction.newBuilder(); + Transaction.raw.Builder rawBuilder = transactionExtention.getTransaction().getRawData() + .toBuilder(); + rawBuilder.setFeeLimit(feeLimit); + transBuilder.setRawData(rawBuilder); + for (int i = 0; i < transactionExtention.getTransaction().getSignatureCount(); i++) { + ByteString s = transactionExtention.getTransaction().getSignature(i); + transBuilder.setSignature(i, s); + } + for (int i = 0; i < transactionExtention.getTransaction().getRetCount(); i++) { + Result r = transactionExtention.getTransaction().getRet(i); + transBuilder.setRet(i, r); + } + texBuilder.setTransaction(transBuilder); + texBuilder.setResult(transactionExtention.getResult()); + texBuilder.setTxid(transactionExtention.getTxid()); + transactionExtention = texBuilder.build(); + if (transactionExtention == null) { + return null; + } + Return ret = transactionExtention.getResult(); + if (!ret.getResult()) { + System.out.println("Code = " + ret.getCode()); + System.out.println("Message = " + ret.getMessage().toStringUtf8()); + return null; + } + transaction = transactionExtention.getTransaction(); + if (transaction == null || transaction.getRawData().getContractCount() == 0) { + System.out.println("Transaction is empty"); + return null; + } + transaction = signTransaction(ecKey, transaction); + System.out.println( + "trigger txid = " + ByteArray.toHexString(Sha256Hash.hash(transaction.getRawData() + .toByteArray()))); + GrpcAPI.Return response = broadcastTransaction(transaction, blockingStubFull); + if (response.getResult() == false) { + return null; + } else { + return ByteArray.toHexString(Sha256Hash.hash(transaction.getRawData().toByteArray())); + } + } + + /** + * constructor. + */ + public static String clearContractAbi(byte[] contractAddress, + byte[] ownerAddress, + String priKey, WalletGrpc.WalletBlockingStub blockingStubFull) { + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + ECKey temKey = null; + try { + BigInteger priK = new BigInteger(priKey, 16); + temKey = ECKey.fromPrivate(priK); + } catch (Exception ex) { + ex.printStackTrace(); + } + final ECKey ecKey = temKey; + + byte[] owner = ownerAddress; + + Contract.ClearABIContract.Builder builder = Contract.ClearABIContract + .newBuilder(); + builder.setOwnerAddress(ByteString.copyFrom(owner)); + builder.setContractAddress(ByteString.copyFrom(contractAddress)); + + Contract.ClearABIContract clearAbiContract = builder.build(); + + TransactionExtention transactionExtention = blockingStubFull + .clearContractABI(clearAbiContract); + if (transactionExtention == null || !transactionExtention.getResult().getResult()) { + System.out.println("RPC create call trx failed!"); + System.out.println("Code = " + transactionExtention.getResult().getCode()); + System.out + .println("Message = " + transactionExtention.getResult().getMessage().toStringUtf8()); + return null; + } + Transaction transaction = transactionExtention.getTransaction(); + if (transaction.getRetCount() != 0 + && transactionExtention.getConstantResult(0) != null + && transactionExtention.getResult() != null) { + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + return null; + } + + final TransactionExtention.Builder texBuilder = TransactionExtention.newBuilder(); + Transaction.Builder transBuilder = Transaction.newBuilder(); + Transaction.raw.Builder rawBuilder = transactionExtention.getTransaction().getRawData() + .toBuilder(); + transBuilder.setRawData(rawBuilder); + for (int i = 0; i < transactionExtention.getTransaction().getSignatureCount(); i++) { + ByteString s = transactionExtention.getTransaction().getSignature(i); + transBuilder.setSignature(i, s); + } + for (int i = 0; i < transactionExtention.getTransaction().getRetCount(); i++) { + Result r = transactionExtention.getTransaction().getRet(i); + transBuilder.setRet(i, r); + } + texBuilder.setTransaction(transBuilder); + texBuilder.setResult(transactionExtention.getResult()); + texBuilder.setTxid(transactionExtention.getTxid()); + transactionExtention = texBuilder.build(); + if (transactionExtention == null) { + return null; + } + Return ret = transactionExtention.getResult(); + if (!ret.getResult()) { + System.out.println("Code = " + ret.getCode()); + System.out.println("Message = " + ret.getMessage().toStringUtf8()); + return null; + } + transaction = transactionExtention.getTransaction(); + if (transaction == null || transaction.getRawData().getContractCount() == 0) { + System.out.println("Transaction is empty"); + return null; + } + transaction = signTransaction(ecKey, transaction); + System.out.println( + "trigger txid = " + ByteArray.toHexString(Sha256Hash.hash(transaction.getRawData() + .toByteArray()))); + GrpcAPI.Return response = broadcastTransaction(transaction, blockingStubFull); + if (response.getResult() == false) { + return null; + } else { + return ByteArray.toHexString(Sha256Hash.hash(transaction.getRawData().toByteArray())); + } + } + + /** + * constructor. + */ + public static TransactionExtention clearContractAbiForExtention(byte[] contractAddress, + byte[] ownerAddress, + String priKey, WalletGrpc.WalletBlockingStub blockingStubFull) { + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + ECKey temKey = null; + try { + BigInteger priK = new BigInteger(priKey, 16); + temKey = ECKey.fromPrivate(priK); + } catch (Exception ex) { + ex.printStackTrace(); + } + final ECKey ecKey = temKey; + + byte[] owner = ownerAddress; + + Contract.ClearABIContract.Builder builder = Contract.ClearABIContract + .newBuilder(); + builder.setOwnerAddress(ByteString.copyFrom(owner)); + builder.setContractAddress(ByteString.copyFrom(contractAddress)); + + Contract.ClearABIContract clearAbiContract = builder.build(); + + TransactionExtention transactionExtention = blockingStubFull + .clearContractABI(clearAbiContract); + return transactionExtention; + + } + + /** + * constructor. + */ + public static TransactionExtention triggerConstantContractForExtention(byte[] contractAddress, + String method, + String argsStr, + Boolean isHex, long callValue, long feeLimit, String tokenId, long tokenValue, + byte[] ownerAddress, + String priKey, WalletGrpc.WalletBlockingStub blockingStubFull) { + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + ECKey temKey = null; + try { + BigInteger priK = new BigInteger(priKey, 16); + temKey = ECKey.fromPrivate(priK); + } catch (Exception ex) { + ex.printStackTrace(); + } + final ECKey ecKey = temKey; + if (argsStr.equalsIgnoreCase("#")) { + logger.info("argsstr is #"); + argsStr = ""; + } + + byte[] owner = ownerAddress; + byte[] input = Hex.decode(AbiUtil.parseMethod(method, argsStr, isHex)); + + Contract.TriggerSmartContract.Builder builder = Contract.TriggerSmartContract.newBuilder(); + builder.setOwnerAddress(ByteString.copyFrom(owner)); + builder.setContractAddress(ByteString.copyFrom(contractAddress)); + builder.setData(ByteString.copyFrom(input)); + builder.setCallValue(callValue); + builder.setTokenId(Long.parseLong(tokenId)); + builder.setCallTokenValue(tokenValue); + Contract.TriggerSmartContract triggerContract = builder.build(); + + TransactionExtention transactionExtention = blockingStubFull + .triggerConstantContract(triggerContract); + return transactionExtention; + + } + + /** + * constructor. + */ + + public static TransactionExtention triggerContractForExtention(byte[] contractAddress, + String method, String argsStr, + Boolean isHex, long callValue, long feeLimit, String tokenId, long tokenValue, + byte[] ownerAddress, + String priKey, WalletGrpc.WalletBlockingStub blockingStubFull) { + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + ECKey temKey = null; + try { + BigInteger priK = new BigInteger(priKey, 16); + temKey = ECKey.fromPrivate(priK); + } catch (Exception ex) { + ex.printStackTrace(); + } + final ECKey ecKey = temKey; + if (argsStr.equalsIgnoreCase("#")) { + logger.info("argsstr is #"); + argsStr = ""; + } + + byte[] owner = ownerAddress; + byte[] input = Hex.decode(AbiUtil.parseMethod(method, argsStr, isHex)); + + Contract.TriggerSmartContract.Builder builder = Contract.TriggerSmartContract.newBuilder(); + builder.setOwnerAddress(ByteString.copyFrom(owner)); + builder.setContractAddress(ByteString.copyFrom(contractAddress)); + builder.setData(ByteString.copyFrom(input)); + builder.setCallValue(callValue); + builder.setTokenId(Long.parseLong(tokenId)); + builder.setCallTokenValue(tokenValue); + Contract.TriggerSmartContract triggerContract = builder.build(); + + TransactionExtention transactionExtention = blockingStubFull.triggerContract(triggerContract); + return transactionExtention; + + } + + /** + * constructor. + */ + public static String create2(String[] parameters) { + if (parameters == null || parameters.length != 3) { + logger.error("create2 needs 3 parameter:\ncreate2 address code salt"); + return null; + } + + byte[] address = WalletClient.decodeFromBase58Check(parameters[0]); + if (!WalletClient.addressValid(address)) { + logger.error("length of address must be 21 bytes."); + return null; + } + + byte[] code = Hex.decode(parameters[1]); + byte[] temp = Longs.toByteArray(Long.parseLong(parameters[2])); + if (temp.length != 8) { + logger.error("Invalid salt!"); + return null; + } + byte[] salt = new byte[32]; + System.arraycopy(temp, 0, salt, 24, 8); + + byte[] mergedData = ByteUtil.merge(address, salt, Hash.sha3(code)); + String create2Address = Base58.encode58Check(Hash.sha3omit12(mergedData)); + + logger.info("create2 Address: " + create2Address); + + return create2Address; + } + } \ No newline at end of file diff --git a/src/test/java/stest/tron/wallet/common/client/utils/PublicMethedForMutiSign.java b/src/test/java/stest/tron/wallet/common/client/utils/PublicMethedForMutiSign.java index e82dc0420ea..cae1e9db857 100644 --- a/src/test/java/stest/tron/wallet/common/client/utils/PublicMethedForMutiSign.java +++ b/src/test/java/stest/tron/wallet/common/client/utils/PublicMethedForMutiSign.java @@ -4510,4 +4510,94 @@ public static Boolean exchangeCreate1(byte[] firstTokenId, long firstTokenBalanc return broadcastTransaction(transaction, blockingStubFull); } + + + public static boolean clearContractAbi(byte[] contractAddress, + byte[] ownerAddress, + String priKey, WalletGrpc.WalletBlockingStub blockingStubFull, int permissionId, + String[] permissionKeyString) { + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + ECKey temKey = null; + try { + BigInteger priK = new BigInteger(priKey, 16); + temKey = ECKey.fromPrivate(priK); + } catch (Exception ex) { + ex.printStackTrace(); + } + final ECKey ecKey = temKey; + + byte[] owner = ownerAddress; + + Contract.ClearABIContract.Builder builder = Contract.ClearABIContract + .newBuilder(); + builder.setOwnerAddress(ByteString.copyFrom(owner)); + builder.setContractAddress(ByteString.copyFrom(contractAddress)); + + Contract.ClearABIContract clearABIContract = builder.build(); + + TransactionExtention transactionExtention = blockingStubFull + .clearContractABI(clearABIContract); + if (transactionExtention == null || !transactionExtention.getResult().getResult()) { + System.out.println("RPC create call trx failed!"); + System.out.println("Code = " + transactionExtention.getResult().getCode()); + System.out + .println("Message = " + transactionExtention.getResult().getMessage().toStringUtf8()); + return false; + } + Transaction transaction = transactionExtention.getTransaction(); + if (transaction.getRetCount() != 0 + && transactionExtention.getConstantResult(0) != null + && transactionExtention.getResult() != null) { + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + return false; + } + + final TransactionExtention.Builder texBuilder = TransactionExtention.newBuilder(); + Transaction.Builder transBuilder = Transaction.newBuilder(); + Transaction.raw.Builder rawBuilder = transactionExtention.getTransaction().getRawData() + .toBuilder(); + transBuilder.setRawData(rawBuilder); + for (int i = 0; i < transactionExtention.getTransaction().getSignatureCount(); i++) { + ByteString s = transactionExtention.getTransaction().getSignature(i); + transBuilder.setSignature(i, s); + } + for (int i = 0; i < transactionExtention.getTransaction().getRetCount(); i++) { + Result r = transactionExtention.getTransaction().getRet(i); + transBuilder.setRet(i, r); + } + texBuilder.setTransaction(transBuilder); + texBuilder.setResult(transactionExtention.getResult()); + texBuilder.setTxid(transactionExtention.getTxid()); + transactionExtention = texBuilder.build(); + if (transactionExtention == null) { + return false; + } + Return ret = transactionExtention.getResult(); + if (!ret.getResult()) { + System.out.println("Code = " + ret.getCode()); + System.out.println("Message = " + ret.getMessage().toStringUtf8()); + return false; + } + transaction = transactionExtention.getTransaction(); + if (transaction == null || transaction.getRawData().getContractCount() == 0) { + System.out.println("Transaction is empty"); + return false; + } + try { + transaction = setPermissionId(transaction, permissionId); + } catch (CancelException e) { + e.printStackTrace(); + } + transaction = signTransaction(transaction, blockingStubFull, permissionKeyString); + System.out.println( + "trigger txid = " + ByteArray.toHexString(Sha256Hash.hash(transaction.getRawData() + .toByteArray()))); + return broadcastTransaction(transaction, blockingStubFull); + + } + } diff --git a/src/test/java/stest/tron/wallet/contract/linkage/ContractLinkage002.java b/src/test/java/stest/tron/wallet/contract/linkage/ContractLinkage002.java index 060ef78118d..bd69755e8ba 100644 --- a/src/test/java/stest/tron/wallet/contract/linkage/ContractLinkage002.java +++ b/src/test/java/stest/tron/wallet/contract/linkage/ContractLinkage002.java @@ -1,8 +1,11 @@ package stest.tron.wallet.contract.linkage; +import static org.tron.protos.Protocol.Transaction.Result.contractResult.SUCCESS_VALUE; + import io.grpc.ManagedChannel; import io.grpc.ManagedChannelBuilder; import java.util.HashMap; +import java.util.Optional; import java.util.concurrent.TimeUnit; import lombok.extern.slf4j.Slf4j; import org.junit.Assert; @@ -18,6 +21,9 @@ import org.tron.core.Wallet; import org.tron.protos.Protocol.Account; import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import org.tron.protos.Protocol.Transaction.Result.contractResult; +import org.tron.protos.Protocol.TransactionInfo; import stest.tron.wallet.common.client.Configuration; import stest.tron.wallet.common.client.Parameter.CommonConstant; import stest.tron.wallet.common.client.utils.PublicMethed; @@ -68,10 +74,24 @@ public void beforeClass() { @Test(enabled = true) public void updateSetting() { - Assert.assertTrue(PublicMethed.sendcoin(linkage002Address, 200000000000L, fromAddress, - testKey002, blockingStubFull)); + String sendcoin = PublicMethed + .sendcoinGetTransactionId(linkage002Address, 200000000000L, fromAddress, + testKey002, blockingStubFull); Account info; PublicMethed.waitProduceNextBlock(blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById0 = null; + infoById0 = PublicMethed.getTransactionInfoById(sendcoin, blockingStubFull); + logger.info("infoById0 " + infoById0.get()); + Assert.assertEquals(ByteArray.toHexString(infoById0.get().getContractResult(0).toByteArray()), + ""); + Assert.assertEquals(infoById0.get().getResult().getNumber(), 0); + Optional ById = PublicMethed.getTransactionById(sendcoin, blockingStubFull); + Assert.assertEquals(ById.get().getRet(0).getContractRet().getNumber(), + SUCCESS_VALUE); + Assert.assertEquals(ById.get().getRet(0).getContractRetValue(), SUCCESS_VALUE); + Assert.assertEquals(ById.get().getRet(0).getContractRet(), contractResult.SUCCESS); + Assert.assertTrue(PublicMethed.freezeBalanceGetEnergy(linkage002Address, 50000000L, 3, 1, linkage002Key, blockingStubFull)); AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(linkage002Address, diff --git a/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario004.java b/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario004.java index 9584d73cd5b..2ac708412ee 100644 --- a/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario004.java +++ b/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario004.java @@ -81,14 +81,15 @@ public void deployErc20TronToken() { String code = retMap.get("byteCode").toString(); String abi = retMap.get("abI").toString(); - byte[] contractAddress; String txid = PublicMethed .deployContractAndGetTransactionInfoById(contractName, abi, code, "", maxFeeLimit, 0L, 100, null, contract004Key, contract004Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); Optional infoById = PublicMethed .getTransactionInfoById(txid, blockingStubFull); logger.info("Txid is " + txid); logger.info("Deploy energytotal is " + infoById.get().getReceipt().getEnergyUsageTotal()); + byte[] contractAddress; contractAddress = infoById.get().getContractAddress().toByteArray(); SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); diff --git a/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario005.java b/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario005.java index 958dc12fc60..31d1541d20d 100644 --- a/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario005.java +++ b/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario005.java @@ -84,14 +84,15 @@ public void deployIcoContract() { String code = retMap.get("byteCode").toString(); String abi = retMap.get("abI").toString(); - byte[] contractAddress = null; String txid = PublicMethed .deployContractAndGetTransactionInfoById(contractName, abi, code, "", maxFeeLimit, 0L, 100, null, contract005Key, contract005Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); Optional infoById = PublicMethed .getTransactionInfoById(txid, blockingStubFull); logger.info("Txid is " + txid); logger.info("Deploy energytotal is " + infoById.get().getReceipt().getEnergyUsageTotal()); + byte[] contractAddress = null; contractAddress = infoById.get().getContractAddress().toByteArray(); SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); diff --git a/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario006.java b/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario006.java index 47ac2572711..178390b015c 100644 --- a/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario006.java +++ b/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario006.java @@ -95,6 +95,7 @@ public void deployFomo3D() { String txid = PublicMethed .deployContractAndGetTransactionInfoById(contractName, abi, code, "", maxFeeLimit, 0L, 100, null, contract006Key, contract006Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); Optional infoById = PublicMethed .getTransactionInfoById(txid, blockingStubFull); contractAddress = infoById.get().getContractAddress().toByteArray(); diff --git a/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario012.java b/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario012.java index 4e496853b48..1b12c881a30 100644 --- a/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario012.java +++ b/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario012.java @@ -99,6 +99,7 @@ public void test1DeployTransactionCoin() { String txid = PublicMethed .deployContractAndGetTransactionInfoById(contractName, abi, code, "", maxFeeLimit, 0L, 100, null, contract012Key, contract012Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); logger.info("infobyid : --- " + infoById); Assert.assertTrue(infoById.get().getResultValue() == 0); diff --git a/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario013.java b/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario013.java index 4e27f167548..57eed764388 100644 --- a/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario013.java +++ b/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario013.java @@ -85,6 +85,7 @@ public void deployTronTrxAndSunContract() { txid = PublicMethed.deployContractAndGetTransactionInfoById(contractName, abi, code, "", maxFeeLimit, 0L, 100, null, contract013Key, contract013Address, blockingStubFull); logger.info(txid); + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); logger.info("energytotal is " + infoById.get().getReceipt().getEnergyUsageTotal()); Assert.assertTrue(infoById.get().getResultValue() == 0); @@ -112,6 +113,7 @@ public void triggerTronTrxAndSunContract() { String txid = PublicMethed .deployContractAndGetTransactionInfoById(contractName, abi, code, "", maxFeeLimit, 0L, 100, null, contract013Key, contract013Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); Assert.assertTrue(infoById.get().getResultValue() == 0); logger.info("energytotal is " + infoById.get().getReceipt().getEnergyUsageTotal()); @@ -122,6 +124,7 @@ public void triggerTronTrxAndSunContract() { "time()", "#", false, 0, 100000000L, contract013Address, contract013Key, blockingStubFull); logger.info(txid); + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); logger.info("result is " + infoById.get().getResultValue()); logger.info("energytotal is " + infoById.get().getReceipt().getEnergyUsageTotal()); diff --git a/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario014.java b/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario014.java new file mode 100644 index 00000000000..fc586aab93b --- /dev/null +++ b/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario014.java @@ -0,0 +1,171 @@ +package stest.tron.wallet.contract.scenario; + +import static org.tron.protos.Protocol.Transaction.Result.contractResult.SUCCESS_VALUE; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import org.tron.protos.Protocol.Transaction.Result.contractResult; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ContractScenario014 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "Clear a contract with ABI created by itself") + public void testClearAbi() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/ClearAbi001.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String txid = PublicMethed + .clearContractAbi(contractAddress, contractExcAddress, contractExcKey, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Assert.assertEquals(0,infoById.get().getResultValue()); + Assert.assertEquals("", + ByteArray.toHexString(infoById.get().getResMessage().toByteArray())); + + Optional byId = PublicMethed.getTransactionById(txid, blockingStubFull); + Assert.assertEquals(byId.get().getRet(0).getContractRet().getNumber(), + SUCCESS_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRetValue(), SUCCESS_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRet(), contractResult.SUCCESS); + + smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario015.java b/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario015.java new file mode 100644 index 00000000000..6c3f66de9a1 --- /dev/null +++ b/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario015.java @@ -0,0 +1,155 @@ +package stest.tron.wallet.contract.scenario; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.Transaction; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ContractScenario015 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "TriggerConstantContract a constant function ") + public void testTriggerConstantContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/ClearAbi001.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddress, + "testPayable()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + logger.info("message:" + transaction.getRet(0).getRet()); + logger.info(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + logger.info("Result:" + Hex.toHexString(result)); + logger.info("getCode" + transactionExtention.getResult().getCode().getNumber()); + Assert.assertEquals("SUCESS",transaction.getRet(0).getRet().toString()); + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario016.java b/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario016.java new file mode 100644 index 00000000000..914a6230915 --- /dev/null +++ b/src/test/java/stest/tron/wallet/contract/scenario/ContractScenario016.java @@ -0,0 +1,206 @@ +package stest.tron.wallet.contract.scenario; + +import static org.tron.protos.Protocol.Transaction.Result.contractResult.BAD_JUMP_DESTINATION_VALUE; +import static org.tron.protos.Protocol.Transaction.Result.contractResult.OUT_OF_ENERGY_VALUE; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import org.tron.protos.Protocol.Transaction.Result.contractResult; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ContractScenario016 { + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String compilerVersion = Configuration.getByPath("testng.conf") + .getString("defaultParameter.solidityCompilerVersion"); + + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] grammarAddress = ecKey1.getAddress(); + String testKeyForGrammarAddress = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(testKeyForGrammarAddress); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + } + + @Test(enabled = true, description = "ContractResult is BAD_JUMP_DESTINATION") + public void test1Grammar001() { + Assert.assertTrue(PublicMethed + .sendcoin(grammarAddress, 100000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String contractName = "Test"; + + String code = "608060405234801561001057600080fd5b50d3801561001d57600080fd5b50d2801561002a57600" + + "080fd5b5061011f8061003a6000396000f30060806040526004361060485763ffffffff7c01000000000000" + + "000000000000000000000000000000000000000000006000350416634ef5a0088114604d5780639093b95b1" + + "4608c575b600080fd5b348015605857600080fd5b50d38015606457600080fd5b50d28015607057600080fd" + + "5b50607a60043560b8565b60408051918252519081900360200190f35b348015609757600080fd5b50d3801" + + "560a357600080fd5b50d2801560af57600080fd5b5060b660ee565b005b6000606082604051908082528060" + + "20026020018201604052801560e5578160200160208202803883390190505b50905050919050565b6001805" + + "600a165627a7a7230582092ba162087e13f41c6d6c00ba493edc5a5a6250a3840ece5f99aa38b66366a7000" + + "29"; + String abi = "[{\"constant\":false,\"inputs\":[{\"name\":\"x\",\"type\":\"uint256\"}],\"name\"" + + ":\"testOutOfMem\",\"outputs\":[{\"name\":\"r\",\"type\":\"bytes32\"}],\"payable\":false" + + ",\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs" + + "\":[],\"name\":\"testBadJumpDestination\",\"outputs\":[],\"payable\":false,\"stateMutab" + + "ility\":\"nonpayable\",\"type\":\"function\"}]"; + + byte[] contractAddress = PublicMethed.deployContract(contractName, abi, code, + "", maxFeeLimit, + 0L, 100, null, testKeyForGrammarAddress, grammarAddress, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + org.testng.Assert.assertTrue(smartContract.getAbi().toString() != null); + String txid = null; + Optional infoById = null; + txid = PublicMethed.triggerContract(contractAddress, + "testBadJumpDestination()", "#", false, + 0, maxFeeLimit, grammarAddress, testKeyForGrammarAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("Txid is " + txid); + logger.info("Trigger energytotal is " + infoById.get().getReceipt().getEnergyUsageTotal()); + + Optional byId = PublicMethed.getTransactionById(txid, blockingStubFull); + logger.info("getRet：" + byId.get().getRet(0)); + logger.info("getNumber：" + byId.get().getRet(0).getContractRet().getNumber()); + logger.info("getContractRetValue：" + byId.get().getRet(0).getContractRetValue()); + logger.info("getContractRet：" + byId.get().getRet(0).getContractRet()); + logger.info("ById：" + byId); + + logger.info("infoById：" + infoById); + + Assert.assertEquals(byId.get().getRet(0).getContractRetValue(), BAD_JUMP_DESTINATION_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRet(), contractResult.BAD_JUMP_DESTINATION); + + Assert + .assertEquals(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()), ""); + Assert + .assertEquals(contractResult.BAD_JUMP_DESTINATION, infoById.get().getReceipt().getResult()); + + Assert.assertEquals(byId.get().getRet(0).getRet().getNumber(), 0); + Assert.assertEquals(byId.get().getRet(0).getRetValue(), 0); + + + } + + + @Test(enabled = true, description = "ContractResult is OUT_OF_ENERGY") + public void test2Grammar002() { + + String filePath = "src/test/resources/soliditycode/contractUnknownException.sol"; + String contractName = "testC"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + String txid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", maxFeeLimit, + 20L, 100, null, testKeyForGrammarAddress, + grammarAddress, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("Txid is " + txid); + logger.info("Trigger energytotal is " + infoById.get().getReceipt().getEnergyUsageTotal()); + + Optional byId = PublicMethed.getTransactionById(txid, blockingStubFull); + logger.info("getRet：" + byId.get().getRet(0)); + logger.info("getNumber：" + byId.get().getRet(0).getContractRet().getNumber()); + logger.info("getContractRetValue：" + byId.get().getRet(0).getContractRetValue()); + logger.info("getContractRet：" + byId.get().getRet(0).getContractRet()); + logger.info("ById：" + byId); + + logger.info("infoById：" + infoById); + + Assert.assertEquals(byId.get().getRet(0).getContractRetValue(), OUT_OF_ENERGY_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRet(), contractResult.OUT_OF_ENERGY); + + Assert + .assertEquals(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()), ""); + Assert + .assertEquals(contractResult.OUT_OF_ENERGY, infoById.get().getReceipt().getResult()); + + Assert.assertEquals(byId.get().getRet(0).getRet().getNumber(), 0); + Assert.assertEquals(byId.get().getRet(0).getRetValue(), 0); + + } + + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/exceptionfee/AssertException.java b/src/test/java/stest/tron/wallet/dailybuild/exceptionfee/AssertException.java index 0483818e30e..4aadedd6cc0 100644 --- a/src/test/java/stest/tron/wallet/dailybuild/exceptionfee/AssertException.java +++ b/src/test/java/stest/tron/wallet/dailybuild/exceptionfee/AssertException.java @@ -19,6 +19,8 @@ import org.tron.common.utils.Utils; import org.tron.core.Wallet; import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.Transaction; +import org.tron.protos.Protocol.Transaction.Result.contractResult; import org.tron.protos.Protocol.TransactionInfo; import stest.tron.wallet.common.client.Configuration; import stest.tron.wallet.common.client.Parameter.CommonConstant; @@ -129,6 +131,22 @@ public void test1DivideInt() { PublicMethed.waitProduceNextBlock(blockingStubFull1); Optional infoById = null; infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infoById：" + infoById); + Optional ById = PublicMethed.getTransactionById(txid, blockingStubFull); + logger.info("getRet：" + ById.get().getRet(0)); + logger.info("getNumber：" + ById.get().getRet(0).getContractRet().getNumber()); + logger.info("getContractRetValue：" + ById.get().getRet(0).getContractRetValue()); + logger.info("getContractRet：" + ById.get().getRet(0).getContractRet()); + + Assert.assertEquals(ById.get().getRet(0).getContractRet().getNumber(), + contractResult.ILLEGAL_OPERATION_VALUE); + Assert.assertEquals(ById.get().getRet(0).getContractRetValue(), 8); + Assert.assertEquals(ById.get().getRet(0).getContractRet(), contractResult.ILLEGAL_OPERATION); + + Assert + .assertEquals(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()), ""); + Assert.assertEquals(contractResult.ILLEGAL_OPERATION, infoById.get().getReceipt().getResult()); + Long fee = infoById.get().getFee(); Long netUsed = infoById.get().getReceipt().getNetUsage(); Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); diff --git a/src/test/java/stest/tron/wallet/dailybuild/grammar/ContractGrammar001.java b/src/test/java/stest/tron/wallet/dailybuild/grammar/ContractGrammar001.java index 5454a596020..6a5d097f5a7 100644 --- a/src/test/java/stest/tron/wallet/dailybuild/grammar/ContractGrammar001.java +++ b/src/test/java/stest/tron/wallet/dailybuild/grammar/ContractGrammar001.java @@ -17,6 +17,8 @@ import org.tron.common.utils.ByteArray; import org.tron.common.utils.Utils; import org.tron.core.Wallet; +import org.tron.protos.Protocol.Transaction; +import org.tron.protos.Protocol.Transaction.Result.contractResult; import org.tron.protos.Protocol.TransactionInfo; import stest.tron.wallet.common.client.Configuration; import stest.tron.wallet.common.client.Parameter.CommonConstant; @@ -119,7 +121,29 @@ public void test1Grammar001() { "select(bool,uint256)", num2, false, 0, maxFeeLimit, grammarAddress, testKeyForGrammarAddress, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infoById：" + infoById); + Optional ById = PublicMethed.getTransactionById(txid, blockingStubFull); + logger.info("getRet：" + ById.get().getRet(0)); + logger.info("getNumber：" + ById.get().getRet(0).getContractRet().getNumber()); + logger.info("getContractRetValue：" + ById.get().getRet(0).getContractRetValue()); + logger.info("getContractRet：" + ById.get().getRet(0).getContractRet()); + + Assert.assertEquals(ById.get().getRet(0).getContractRet().getNumber(), + contractResult.SUCCESS_VALUE); + Assert.assertEquals(ById.get().getRet(0).getContractRetValue(), 1); + Assert.assertEquals(ById.get().getRet(0).getContractRet(), contractResult.SUCCESS); + + Assert + .assertEquals(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()), + "0000000000000000000000000000000000000000000000000000000000000064"); + Assert.assertEquals(contractResult.SUCCESS, infoById.get().getReceipt().getResult()); + + logger.info("ById：" + ById); + Assert.assertEquals(ById.get().getRet(0).getRet().getNumber(), 0); + Assert.assertEquals(ById.get().getRet(0).getRetValue(), 0); + Long returnnumber2 = ByteArray.toLong(ByteArray.fromHexString( ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); diff --git a/src/test/java/stest/tron/wallet/dailybuild/grammar/ContractGrammar004.java b/src/test/java/stest/tron/wallet/dailybuild/grammar/ContractGrammar004.java new file mode 100644 index 00000000000..461163b0afe --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/grammar/ContractGrammar004.java @@ -0,0 +1,663 @@ +package stest.tron.wallet.dailybuild.grammar; + +import static org.tron.protos.Protocol.Transaction.Result.contractResult.BAD_JUMP_DESTINATION_VALUE; +import static org.tron.protos.Protocol.Transaction.Result.contractResult.ILLEGAL_OPERATION_VALUE; +import static org.tron.protos.Protocol.Transaction.Result.contractResult.OUT_OF_ENERGY_VALUE; +import static org.tron.protos.Protocol.Transaction.Result.contractResult.OUT_OF_MEMORY_VALUE; +import static org.tron.protos.Protocol.Transaction.Result.contractResult.OUT_OF_TIME_VALUE; +import static org.tron.protos.Protocol.Transaction.Result.contractResult.REVERT_VALUE; +import static org.tron.protos.Protocol.Transaction.Result.contractResult.STACK_TOO_LARGE_VALUE; +import static org.tron.protos.Protocol.Transaction.Result.contractResult.STACK_TOO_SMALL_VALUE; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import org.tron.protos.Protocol.Transaction.Result.contractResult; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ContractGrammar004 { + + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String compilerVersion = Configuration.getByPath("testng.conf") + .getString("defaultParameter.solidityCompilerVersion"); + + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] grammarAddress = ecKey1.getAddress(); + String testKeyForGrammarAddress = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(testKeyForGrammarAddress); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + } + + @Test(enabled = true, description = "ContractResult is OUT_OF_TIME") + public void test1Grammar001() { + Assert.assertTrue(PublicMethed + .sendcoin(grammarAddress, 100000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + String filePath = "./src/test/resources/soliditycode/walletTestMutiSign004.sol"; + String contractName = "timeoutTest"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + byte[] contractAddress = PublicMethed.deployContract(contractName, abi, code, + "", maxFeeLimit, + 0L, 100, null, testKeyForGrammarAddress, grammarAddress, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + org.testng.Assert.assertTrue(smartContract.getAbi().toString() != null); + String txid = null; + Optional infoById = null; + String initParmes = "\"" + "100000" + "\""; + txid = PublicMethed.triggerContract(contractAddress, + "testUseCpu(uint256)", initParmes, false, + 0, maxFeeLimit, grammarAddress, testKeyForGrammarAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("Txid is " + txid); + logger.info("Trigger energytotal is " + infoById.get().getReceipt().getEnergyUsageTotal()); + + Optional byId = PublicMethed.getTransactionById(txid, blockingStubFull); + logger.info("getRet：" + byId.get().getRet(0)); + logger.info("getNumber：" + byId.get().getRet(0).getContractRet().getNumber()); + logger.info("getContractRetValue：" + byId.get().getRet(0).getContractRetValue()); + logger.info("getContractRet：" + byId.get().getRet(0).getContractRet()); + logger.info("ById：" + byId); + + Assert.assertEquals(byId.get().getRet(0).getContractRetValue(), OUT_OF_TIME_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRet(), contractResult.OUT_OF_TIME); + + Assert + .assertEquals(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()), ""); + Assert.assertEquals(contractResult.OUT_OF_TIME, infoById.get().getReceipt().getResult()); + + Assert.assertEquals(byId.get().getRet(0).getRet().getNumber(), 0); + Assert.assertEquals(byId.get().getRet(0).getRetValue(), 0); + + + } + + + @Test(enabled = true, description = "ContractResult is OUT_OF_MEMORY") + public void test2Grammar002() { + String filePath = "./src/test/resources/soliditycode/testOutOfMem.sol"; + String contractName = "Test"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + byte[] contractAddress = PublicMethed.deployContract(contractName, abi, code, + "", maxFeeLimit, + 0L, 100, null, testKeyForGrammarAddress, grammarAddress, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + org.testng.Assert.assertTrue(smartContract.getAbi().toString() != null); + String txid = null; + Optional infoById = null; + String initParmes = "\"" + "31457280" + "\""; + txid = PublicMethed.triggerContract(contractAddress, + "testOutOfMem(uint256)", initParmes, false, + 0, maxFeeLimit, grammarAddress, testKeyForGrammarAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("Txid is " + txid); + logger.info("Trigger energytotal is " + infoById.get().getReceipt().getEnergyUsageTotal()); + + Optional byId = PublicMethed.getTransactionById(txid, blockingStubFull); + logger.info("getRet：" + byId.get().getRet(0)); + logger.info("getNumber：" + byId.get().getRet(0).getContractRet().getNumber()); + logger.info("getContractRetValue：" + byId.get().getRet(0).getContractRetValue()); + logger.info("getContractRet：" + byId.get().getRet(0).getContractRet()); + logger.info("ById：" + byId); + + logger.info("infoById：" + infoById); + + Assert.assertEquals(byId.get().getRet(0).getContractRetValue(), OUT_OF_MEMORY_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRet(), contractResult.OUT_OF_MEMORY); + + Assert + .assertEquals(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()), ""); + Assert.assertEquals(contractResult.OUT_OF_MEMORY, infoById.get().getReceipt().getResult()); + + Assert.assertEquals(byId.get().getRet(0).getRet().getNumber(), 0); + Assert.assertEquals(byId.get().getRet(0).getRetValue(), 0); + + + } + + + @Test(enabled = true, description = "ContractResult is BAD_JUMP_DESTINATION") + public void test3Grammar003() { + String contractName = "Test"; + + String code = "608060405234801561001057600080fd5b50d3801561001d57600080fd5b50d2801561002a57600" + + "080fd5b5061011f8061003a6000396000f30060806040526004361060485763ffffffff7c01000000000000" + + "000000000000000000000000000000000000000000006000350416634ef5a0088114604d5780639093b95b1" + + "4608c575b600080fd5b348015605857600080fd5b50d38015606457600080fd5b50d28015607057600080fd" + + "5b50607a60043560b8565b60408051918252519081900360200190f35b348015609757600080fd5b50d3801" + + "560a357600080fd5b50d2801560af57600080fd5b5060b660ee565b005b6000606082604051908082528060" + + "20026020018201604052801560e5578160200160208202803883390190505b50905050919050565b6001805" + + "600a165627a7a7230582092ba162087e13f41c6d6c00ba493edc5a5a6250a3840ece5f99aa38b66366a7000" + + "29"; + String abi = "[{\"constant\":false,\"inputs\":[{\"name\":\"x\",\"type\":\"uint256\"}],\"name\"" + + ":\"testOutOfMem\",\"outputs\":[{\"name\":\"r\",\"type\":\"bytes32\"}],\"payable\":false" + + ",\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs" + + "\":[],\"name\":\"testBadJumpDestination\",\"outputs\":[],\"payable\":false,\"stateMutab" + + "ility\":\"nonpayable\",\"type\":\"function\"}]"; + + byte[] contractAddress = PublicMethed.deployContract(contractName, abi, code, + "", maxFeeLimit, + 0L, 100, null, testKeyForGrammarAddress, grammarAddress, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + org.testng.Assert.assertTrue(smartContract.getAbi().toString() != null); + String txid = null; + Optional infoById = null; + txid = PublicMethed.triggerContract(contractAddress, + "testBadJumpDestination()", "#", false, + 0, maxFeeLimit, grammarAddress, testKeyForGrammarAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("Txid is " + txid); + logger.info("Trigger energytotal is " + infoById.get().getReceipt().getEnergyUsageTotal()); + + Optional byId = PublicMethed.getTransactionById(txid, blockingStubFull); + logger.info("getRet：" + byId.get().getRet(0)); + logger.info("getNumber：" + byId.get().getRet(0).getContractRet().getNumber()); + logger.info("getContractRetValue：" + byId.get().getRet(0).getContractRetValue()); + logger.info("getContractRet：" + byId.get().getRet(0).getContractRet()); + logger.info("ById：" + byId); + + logger.info("infoById：" + infoById); + + Assert.assertEquals(byId.get().getRet(0).getContractRetValue(), BAD_JUMP_DESTINATION_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRet(), contractResult.BAD_JUMP_DESTINATION); + + Assert + .assertEquals(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()), ""); + Assert + .assertEquals(contractResult.BAD_JUMP_DESTINATION, infoById.get().getReceipt().getResult()); + + Assert.assertEquals(byId.get().getRet(0).getRet().getNumber(), 0); + Assert.assertEquals(byId.get().getRet(0).getRetValue(), 0); + + + } + + + @Test(enabled = true, description = "ContractResult is OUT_OF_ENERGY") + public void test4Grammar004() { + + String filePath = "src/test/resources/soliditycode/contractUnknownException.sol"; + String contractName = "testC"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + String txid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", maxFeeLimit, + 20L, 100, null, testKeyForGrammarAddress, + grammarAddress, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("Txid is " + txid); + logger.info("Trigger energytotal is " + infoById.get().getReceipt().getEnergyUsageTotal()); + + Optional byId = PublicMethed.getTransactionById(txid, blockingStubFull); + logger.info("getRet：" + byId.get().getRet(0)); + logger.info("getNumber：" + byId.get().getRet(0).getContractRet().getNumber()); + logger.info("getContractRetValue：" + byId.get().getRet(0).getContractRetValue()); + logger.info("getContractRet：" + byId.get().getRet(0).getContractRet()); + logger.info("ById：" + byId); + + logger.info("infoById：" + infoById); + + Assert.assertEquals(byId.get().getRet(0).getContractRetValue(), OUT_OF_ENERGY_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRet(), contractResult.OUT_OF_ENERGY); + + Assert + .assertEquals(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()), ""); + Assert + .assertEquals(contractResult.OUT_OF_ENERGY, infoById.get().getReceipt().getResult()); + + Assert.assertEquals(byId.get().getRet(0).getRet().getNumber(), 0); + Assert.assertEquals(byId.get().getRet(0).getRetValue(), 0); + + } + + + @Test(enabled = true, description = "ContractResult is ILLEGAL_OPERATION") + public void test5Grammar005() { + + + String filePath = "src/test/resources/soliditycode/assertExceptiontest1DivideInt.sol"; + String contractName = "divideIHaveArgsReturnStorage"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, testKeyForGrammarAddress, + grammarAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + String txid = ""; + String num = "4" + "," + "0"; + + txid = PublicMethed.triggerContract(contractAddress, + "divideIHaveArgsReturn(int256,int256)", num, false, + 0, maxFeeLimit, grammarAddress, testKeyForGrammarAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infoById：" + infoById); + Optional byId = PublicMethed.getTransactionById(txid, blockingStubFull); + logger.info("getRet：" + byId.get().getRet(0)); + logger.info("getNumber：" + byId.get().getRet(0).getContractRet().getNumber()); + logger.info("getContractRetValue：" + byId.get().getRet(0).getContractRetValue()); + logger.info("getContractRet：" + byId.get().getRet(0).getContractRet()); + + Assert.assertEquals(byId.get().getRet(0).getContractRet().getNumber(), + ILLEGAL_OPERATION_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRetValue(), ILLEGAL_OPERATION_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRet(), contractResult.ILLEGAL_OPERATION); + + Assert + .assertEquals(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()), ""); + Assert.assertEquals(contractResult.ILLEGAL_OPERATION, infoById.get().getReceipt().getResult()); + + } + + + @Test(enabled = true, description = "ContractResult is REVERT") + public void test6Grammar006() { + + String filePath = + "src/test/resources/soliditycode/requireExceptiontest1TestRequireContract.sol"; + String contractName = "TestThrowsContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, testKeyForGrammarAddress, + grammarAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + final String txid = PublicMethed.triggerContract(contractAddress, + "testRequire()", "#", false, + 0, maxFeeLimit, grammarAddress, testKeyForGrammarAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infoById：" + infoById); + Optional byId = PublicMethed.getTransactionById(txid, blockingStubFull); + logger.info("getRet：" + byId.get().getRet(0)); + logger.info("getNumber：" + byId.get().getRet(0).getContractRet().getNumber()); + logger.info("getContractRetValue：" + byId.get().getRet(0).getContractRetValue()); + logger.info("getContractRet：" + byId.get().getRet(0).getContractRet()); + + Assert.assertEquals(byId.get().getRet(0).getContractRet().getNumber(), + REVERT_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRetValue(), REVERT_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRet(), contractResult.REVERT); + + Assert + .assertEquals(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()), ""); + Assert.assertEquals(contractResult.REVERT, infoById.get().getReceipt().getResult()); + + } + + @Test(enabled = true, description = "ContractResult is SUCCESS") + public void test7Grammar007() { + + String filePath = "src/test/resources/soliditycode/assertExceptiontest1DivideInt.sol"; + String contractName = "divideIHaveArgsReturnStorage"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, testKeyForGrammarAddress, + grammarAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + String txid = ""; + String num = "4" + "," + "2"; + + txid = PublicMethed.triggerContract(contractAddress, + "divideIHaveArgsReturn(int256,int256)", num, false, + 0, maxFeeLimit, grammarAddress, testKeyForGrammarAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infoById：" + infoById); + Optional byId = PublicMethed.getTransactionById(txid, blockingStubFull); + logger.info("getRet：" + byId.get().getRet(0)); + logger.info("getNumber：" + byId.get().getRet(0).getContractRet().getNumber()); + logger.info("getContractRetValue：" + byId.get().getRet(0).getContractRetValue()); + logger.info("getContractRet：" + byId.get().getRet(0).getContractRet()); + + Assert.assertEquals(byId.get().getRet(0).getContractRet().getNumber(), + contractResult.SUCCESS_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRetValue(), contractResult.SUCCESS_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRet(), contractResult.SUCCESS); + + Assert.assertEquals(contractResult.SUCCESS, infoById.get().getReceipt().getResult()); + + Assert + .assertEquals(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()), + "0000000000000000000000000000000000000000000000000000000000000002"); + + } + + + @Test(enabled = true, description = "ContractResult is TRANSFER_FAILED") + public void test8Grammar008() { + String filePath = "src/test/resources/soliditycode/TransferFailed001.sol"; + String contractName = "EnergyOfTransferFailedTest"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, testKeyForGrammarAddress, + grammarAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Assert.assertTrue(PublicMethed + .sendcoin(contractAddress, 1000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(grammarAddress, + blockingStubFull); + info = PublicMethed.queryAccount(testKeyForGrammarAddress, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] nonexistentAddress = ecKey2.getAddress(); + String txid = ""; + String num = "1" + ",\"" + Base58.encode58Check(nonexistentAddress) + "\""; + + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTrxNonexistentTarget(uint256,address)", num, false, + 0, maxFeeLimit, grammarAddress, testKeyForGrammarAddress, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infobyid : --- " + infoById); + + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(testKeyForGrammarAddress, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(grammarAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 1); + Assert.assertEquals(contractResult.TRANSFER_FAILED, infoById.get().getReceipt().getResult()); + Assert.assertEquals( + "transfer trx failed: Validate InternalTransfer error, no ToAccount." + + " And not allowed to create account in smart contract.", + ByteArray.toStr(infoById.get().getResMessage().toByteArray())); + + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Assert.assertNotEquals(10000000, energyUsageTotal); + + + } + + + @Test(enabled = true, description = "ContractResult is STACK_TOO_SMALL") + public void test9Grammar009() { + + String contractName = "TestThrowsContract"; + String abi = "[{\"constant\":false,\"inputs\":[],\"name\":\"testStackTooSmall\",\"outputs\":[]" + + ",\"payable\":false,\"type\":\"function\",\"stateMutability\":\"nonpayable\"}]"; + String code = "60606040523415600b57fe5b5b60608060196000396000f300606060405263ffffffff60e060020" + + "a6000350416632f3a24cc81146020575bfe5b3415602757fe5b602d602f565b005b50505b5600a165627a7a" + + "723058208184f2ff2627a8a490bfd1233a891f2f4605375d0fec375e237ffc188cdd7ec70029"; + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, testKeyForGrammarAddress, + grammarAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + final String txid = PublicMethed.triggerContract(contractAddress, + "testStackTooSmall()", "#", false, + 0, maxFeeLimit, grammarAddress, testKeyForGrammarAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infoById：" + infoById); + Optional byId = PublicMethed.getTransactionById(txid, blockingStubFull); + logger.info("getRet：" + byId.get().getRet(0)); + logger.info("getNumber：" + byId.get().getRet(0).getContractRet().getNumber()); + logger.info("getContractRetValue：" + byId.get().getRet(0).getContractRetValue()); + logger.info("getContractRet：" + byId.get().getRet(0).getContractRet()); + + Assert.assertEquals(byId.get().getRet(0).getContractRet().getNumber(), + STACK_TOO_SMALL_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRetValue(), STACK_TOO_SMALL_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRet(), contractResult.STACK_TOO_SMALL); + + Assert + .assertEquals(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()), ""); + Assert.assertEquals(contractResult.STACK_TOO_SMALL, infoById.get().getReceipt().getResult()); + + } + + @Test(enabled = true, description = "ContractResult is STACK_TOO_LARGE") + public void test9Grammar010() { + + String contractName = "TestThrowsContract"; + String abi = "[{\"constant\":false,\"inputs\":[],\"name\":\"testStackTooLarge\",\"outputs\":[]" + + ",\"payable\":false,\"type\":\"function\",\"stateMutability\":\"nonpayable\"}]"; + String code = "6060604052341561000c57fe5b5b610b658061001c6000396000f300606060405263ffffffff60e" + + "060020a600035041663f7d9c5c68114610021575bfe5b341561002957fe5b610031610033565b005b600060" + + "0160026003600460056006600760086009600a600b600c600d600e600f60106011601260136014601560166" + + "01760186019601a601b601c601d601e601f6020602160226023602460256026602760286029602a602b602c" + + "602d602e602f6030603160326033603460356036603760386039603a603b603c603d603e603f60406041604" + + "26043604460456046604760486049604a604b604c604d604e604f6050605160526053605460556056605760" + + "586059605a605b605c605d605e605f6060606160626063606460656066606760686069606a606b606c606d6" + + "06e606f6070607160726073607460756076607760786079607a607b607c607d607e607f6080608160826083" + + "608460856086608760886089608a608b608c608d608e608f609060916092609360946095609660976098609" + + "9609a609b609c609d609e609f60a060a160a260a360a460a560a660a760a860a960aa60ab60ac60ad60ae60" + + "af60b060b160b260b360b460b560b660b760b860b960ba60bb60bc60bd60be60bf60c060c160c260c360c46" + + "0c560c660c760c860c960ca60cb60cc60cd60ce60cf60d060d160d260d360d460d560d660d760d860d960da" + + "60db60dc60dd60de60df60e060e160e260e360e460e560e660e760e860e960ea60eb60ec60ed60ee60ef60f" + + "060f160f260f360f460f560f660f760f860f960fa60fb60fc60fd60fe60ff61010061010161010261010361" + + "010461010561010661010761010861010961010a61010b61010c61010d61010e61010f61011061011161011" + + "261011361011461011561011661011761011861011961011a61011b61011c61011d61011e61011f61012061" + + "012161012261012361012461012561012661012761012861012961012a61012b61012c61012d61012e61012" + + "f61013061013161013261013361013461013561013661013761013861013961013a61013b61013c61013d61" + + "013e61013f61014061014161014261014361014461014561014661014761014861014961014a61014b61014" + + "c61014d61014e61014f61015061015161015261015361015461015561015661015761015861015961015a61" + + "015b61015c61015d61015e61015f61016061016161016261016361016461016561016661016761016861016" + + "961016a61016b61016c61016d61016e61016f61017061017161017261017361017461017561017661017761" + + "017861017961017a61017b61017c61017d61017e61017f61018061018161018261018361018461018561018" + + "661018761018861018961018a61018b61018c61018d61018e61018f61019061019161019261019361019461" + + "019561019661019761019861019961019a61019b61019c61019d61019e61019f6101a06101a16101a26101a" + + "36101a46101a56101a66101a76101a86101a96101aa6101ab6101ac6101ad6101ae6101af6101b06101b161" + + "01b26101b36101b46101b56101b66101b76101b86101b96101ba6101bb6101bc6101bd6101be6101bf6101c" + + "06101c16101c26101c36101c46101c56101c66101c76101c86101c96101ca6101cb6101cc6101cd6101ce61" + + "01cf6101d06101d16101d26101d36101d46101d56101d66101d76101d86101d96101da6101db6101dc6101d" + + "d6101de6101df6101e06101e16101e26101e36101e46101e56101e66101e76101e86101e96101ea6101eb61" + + "01ec6101ed6101ee6101ef6101f06101f16101f26101f36101f46101f56101f66101f76101f86101f96101f" + + "a6101fb6101fc6101fd6101fe6101ff61020061020161020261020361020461020561020661020761020861" + + "020961020a61020b61020c61020d61020e61020f61021061021161021261021361021461021561021661021" + + "761021861021961021a61021b61021c61021d61021e61021f61022061022161022261022361022461022561" + + "022661022761022861022961022a61022b61022c61022d61022e61022f61023061023161023261023361023" + + "461023561023661023761023861023961023a61023b61023c61023d61023e61023f61024061024161024261" + + "024361024461024561024661024761024861024961024a61024b61024c61024d61024e61024f61025061025" + + "161025261025361025461025561025661025761025861025961025a61025b61025c61025d61025e61025f61" + + "026061026161026261026361026461026561026661026761026861026961026a61026b61026c61026d61026" + + "e61026f61027061027161027261027361027461027561027661027761027861027961027a61027b61027c61" + + "027d61027e61027f61028061028161028261028361028461028561028661028761028861028961028a61028" + + "b61028c61028d61028e61028f61029061029161029261029361029461029561029661029761029861029961" + + "029a61029b61029c61029d61029e61029f6102a06102a16102a26102a36102a46102a56102a66102a76102a" + + "86102a96102aa6102ab6102ac6102ad6102ae6102af6102b06102b16102b26102b36102b46102b56102b661" + + "02b76102b86102b96102ba6102bb6102bc6102bd6102be6102bf6102c06102c16102c26102c36102c46102c" + + "56102c66102c76102c86102c96102ca6102cb6102cc6102cd6102ce6102cf6102d06102d16102d26102d361" + + "02d46102d56102d66102d76102d86102d96102da6102db6102dc6102dd6102de6102df6102e06102e16102e" + + "26102e36102e46102e56102e66102e76102e86102e96102ea6102eb6102ec6102ed6102ee6102ef6102f061" + + "02f16102f26102f36102f46102f56102f66102f76102f86102f96102fa6102fb6102fc6102fd6102fe6102f" + + "f61030061030161030261030361030461030561030661030761030861030961030a61030b61030c61030d61" + + "030e61030f61031061031161031261031361031461031561031661031761031861031961031a61031b61031" + + "c61031d61031e61031f61032061032161032261032361032461032561032661032761032861032961032a61" + + "032b61032c61032d61032e61032f61033061033161033261033361033461033561033661033761033861033" + + "961033a61033b61033c61033d61033e61033f61034061034161034261034361034461034561034661034761" + + "034861034961034a61034b61034c61034d61034e61034f61035061035161035261035361035461035561035" + + "661035761035861035961035a61035b61035c61035d61035e61035f61036061036161036261036361036461" + + "036561036661036761036861036961036a61036b61036c61036d61036e61036f61037061037161037261037" + + "361037461037561037661037761037861037961037a61037b61037c61037d61037e61037f61038061038161" + + "038261038361038461038561038661038761038861038961038a61038b61038c61038d61038e61038f61039" + + "061039161039261039361039461039561039661039761039861039961039a61039b61039c61039d61039e61" + + "039f6103a06103a16103a26103a36103a46103a56103a66103a76103a86103a96103aa6103ab6103ac6103a" + + "d6103ae6103af6103b06103b16103b26103b36103b46103b56103b66103b76103b86103b96103ba6103bb61" + + "03bc6103bd6103be6103bf6103c06103c16103c26103c36103c46103c56103c66103c76103c86103c96103c" + + "a6103cb6103cc6103cd6103ce6103cf6103d06103d16103d26103d36103d46103d56103d66103d76103d861" + + "03d96103da6103db6103dc6103dd6103de6103df6103e06103e16103e26103e36103e46103e56103e66103e" + + "76103e86103e96103ea6103eb6103ec6103ed6103ee6103ef6103f06103f16103f26103f36103f46103f561" + + "03f66103f76103f86103f96103fa6103fb6103fc6103fd6103fe6103ff6104005b5600a165627a7a7230582" + + "0998f09cc267db91352a3d0a4ab60ea08fc306fa8bc6dd78dc324a06109dcf0420029"; + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, testKeyForGrammarAddress, + grammarAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + final String txid = PublicMethed.triggerContract(contractAddress, + "testStackTooLarge()", "#", false, + 0, maxFeeLimit, grammarAddress, testKeyForGrammarAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infoById：" + infoById); + Optional byId = PublicMethed.getTransactionById(txid, blockingStubFull); + logger.info("getRet：" + byId.get().getRet(0)); + logger.info("getNumber：" + byId.get().getRet(0).getContractRet().getNumber()); + logger.info("getContractRetValue：" + byId.get().getRet(0).getContractRetValue()); + logger.info("getContractRet：" + byId.get().getRet(0).getContractRet()); + + Assert.assertEquals(byId.get().getRet(0).getContractRet().getNumber(), + STACK_TOO_LARGE_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRetValue(), STACK_TOO_LARGE_VALUE); + Assert.assertEquals(byId.get().getRet(0).getContractRet(), contractResult.STACK_TOO_LARGE); + + Assert + .assertEquals(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()), ""); + Assert.assertEquals(contractResult.STACK_TOO_LARGE, infoById.get().getReceipt().getResult()); + + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/http/HttpTestClearAbiContract001.java b/src/test/java/stest/tron/wallet/dailybuild/http/HttpTestClearAbiContract001.java new file mode 100644 index 00000000000..15deddf3160 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/http/HttpTestClearAbiContract001.java @@ -0,0 +1,167 @@ +package stest.tron.wallet.dailybuild.http; + +import static org.hamcrest.core.StringContains.containsString; + +import com.alibaba.fastjson.JSONObject; +import java.util.HashMap; +import lombok.extern.slf4j.Slf4j; +import org.apache.http.HttpResponse; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.Test; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.utils.HttpMethed; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class HttpTestClearAbiContract001 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key1"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + private JSONObject responseContent; + private HttpResponse response; + private String httpnode = Configuration.getByPath("testng.conf").getStringList("httpnode.ip.list") + .get(0); + + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] assetOwnerAddress = ecKey2.getAddress(); + String assetOwnerKey = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + String contractAddress; + String abi; + Long amount = 2048000000L; + + String description = Configuration.getByPath("testng.conf") + .getString("defaultParameter.assetDescription"); + String url = Configuration.getByPath("testng.conf") + .getString("defaultParameter.assetUrl"); + private static final long now = System.currentTimeMillis(); + private static String name = "testAssetIssue002_" + Long.toString(now); + private static final long totalSupply = now; + private static String assetIssueId; + private static String contractName; + + + /** + * constructor. + */ + @Test(enabled = true, description = "Deploy smart contract by http") + public void test1DeployContract() { + PublicMethed.printAddress(assetOwnerKey); + HttpMethed.waitToProduceOneBlock(httpnode); + response = HttpMethed.sendCoin(httpnode, fromAddress, assetOwnerAddress, amount, testKey002); + Assert.assertTrue(HttpMethed.verificationResult(response)); + HttpMethed.waitToProduceOneBlock(httpnode); + + response = HttpMethed.getAccount(httpnode, assetOwnerAddress); + responseContent = HttpMethed.parseResponseContent(response); + HttpMethed.printJsonContent(responseContent); + + String filePath = "src/test/resources/soliditycode/TriggerConstant003.sol"; + contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + abi = retMap.get("abI").toString(); + logger.info("abi:" + abi); + logger.info("code:" + code); + + String txid = HttpMethed.deployContractGetTxid(httpnode, contractName, abi, code, 1000000L, + 1000000000L, 100, 11111111111111L, + 0L, 0, 0L, assetOwnerAddress, assetOwnerKey); + + HttpMethed.waitToProduceOneBlock(httpnode); + logger.info(txid); + response = HttpMethed.getTransactionById(httpnode, txid); + responseContent = HttpMethed.parseResponseContent(response); + HttpMethed.printJsonContent(responseContent); + Assert.assertTrue(!responseContent.getString("contract_address").isEmpty()); + contractAddress = responseContent.getString("contract_address"); + + response = HttpMethed.getTransactionInfoById(httpnode, txid); + responseContent = HttpMethed.parseResponseContent(response); + String receiptString = responseContent.getString("receipt"); + Assert + .assertEquals(HttpMethed.parseStringContent(receiptString).getString("result"), "SUCCESS"); + } + + /** + * constructor. + */ + @Test(enabled = true, description = "Get contract by http") + public void test2GetContract() { + response = HttpMethed.getContract(httpnode, contractAddress); + responseContent = HttpMethed.parseResponseContent(response); + HttpMethed.printJsonContent(responseContent); + Assert.assertEquals(responseContent.getString("consume_user_resource_percent"), "100"); + Assert.assertEquals(responseContent.getString("contract_address"), contractAddress); + Assert.assertEquals(responseContent.getString("origin_address"), + ByteArray.toHexString(assetOwnerAddress)); + Assert + .assertThat(responseContent.getString("abi"), + containsString("testView")); + + Assert.assertEquals(responseContent.getString("origin_energy_limit"), "11111111111111"); + Assert.assertEquals(responseContent.getString("name"), contractName); + } + + /** + * constructor. + */ + @Test(enabled = true, description = "Trigger contract by http") + public void test3TriggerConstantContract() { + + HttpResponse httpResponse = HttpMethed + .triggerConstantContract(httpnode, assetOwnerAddress, contractAddress, + "testView()", + ""); + + responseContent = HttpMethed.parseResponseContent(httpResponse); + HttpMethed.printJsonContent(responseContent); + Assert.assertEquals(responseContent.getString("result"), "{\"result\":true}"); + Assert.assertEquals(responseContent.getString("constant_result"), + "[\"0000000000000000000000000000000000000000000000000000000000000001\"]"); + } + + /** + * constructor. + */ + @Test(enabled = true, description = "Trigger contract by http") + public void test4ClearAbiContract() { + + HttpResponse httpResponse = HttpMethed + .clearABiGetTxid(httpnode, assetOwnerAddress, contractAddress, assetOwnerKey); + + responseContent = HttpMethed.parseResponseContent(httpResponse); + HttpMethed.printJsonContent(responseContent); + Assert.assertEquals(responseContent.getString("result"), "true"); + + } + + /** + * constructor. + */ + @Test(enabled = true, description = "Get contract by http") + public void test5GetContract() { + response = HttpMethed.getContract(httpnode, contractAddress); + responseContent = HttpMethed.parseResponseContent(response); + HttpMethed.printJsonContent(responseContent); + Assert.assertEquals(responseContent.getString("consume_user_resource_percent"), "100"); + Assert.assertEquals(responseContent.getString("contract_address"), contractAddress); + Assert.assertEquals(responseContent.getString("origin_address"), + ByteArray.toHexString(assetOwnerAddress)); + Assert.assertEquals(responseContent.getString("abi"), "{}"); + Assert.assertEquals(responseContent.getString("origin_energy_limit"), "11111111111111"); + Assert.assertEquals(responseContent.getString("name"), contractName); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + HttpMethed.disConnect(); + } +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/http/HttpTestConstantContract001.java b/src/test/java/stest/tron/wallet/dailybuild/http/HttpTestConstantContract001.java index 2ecfefe4e9d..c33c5e5b670 100644 --- a/src/test/java/stest/tron/wallet/dailybuild/http/HttpTestConstantContract001.java +++ b/src/test/java/stest/tron/wallet/dailybuild/http/HttpTestConstantContract001.java @@ -117,4 +117,4 @@ public void test3TriggerConstantContract() { public void shutdown() throws InterruptedException { HttpMethed.disConnect(); } -} +} \ No newline at end of file diff --git a/src/test/java/stest/tron/wallet/dailybuild/http/HttpTestSendCoin001.java b/src/test/java/stest/tron/wallet/dailybuild/http/HttpTestSendCoin001.java index 2238f7f749e..d5831d2aef4 100644 --- a/src/test/java/stest/tron/wallet/dailybuild/http/HttpTestSendCoin001.java +++ b/src/test/java/stest/tron/wallet/dailybuild/http/HttpTestSendCoin001.java @@ -4,16 +4,12 @@ import com.alibaba.fastjson.JSONObject; import lombok.extern.slf4j.Slf4j; import org.apache.http.HttpResponse; - import org.junit.Assert; - import org.testng.annotations.AfterClass; import org.testng.annotations.Test; - import org.tron.common.crypto.ECKey; import org.tron.common.utils.ByteArray; import org.tron.common.utils.Utils; - import stest.tron.wallet.common.client.Configuration; import stest.tron.wallet.common.client.utils.HttpMethed; import stest.tron.wallet.common.client.utils.PublicMethed; @@ -60,8 +56,8 @@ public void test2GetTransactionByIdFromSolidity() { HttpMethed.printJsonContent(responseContent); String retString = responseContent.getString("ret"); JSONArray array = JSONArray.parseArray(retString); - Assert.assertTrue(HttpMethed.parseStringContent(array.get(0).toString()).getString( - "contractRet") == null); + Assert.assertEquals(HttpMethed.parseStringContent(array.get(0).toString()).getString( + "contractRet"), "SUCCESS"); Assert.assertTrue(responseContent.size() > 4); } @@ -94,8 +90,8 @@ public void test4GetTransactionsFromThisFromSolidity() { responseContent.getString("transaction")).get(0).toString()); String retString = transactionObject.getString("ret"); JSONArray array = JSONArray.parseArray(retString); - Assert.assertTrue(HttpMethed.parseStringContent(array.get(0).toString()) - .getString("contractRet") == null); + Assert.assertEquals(HttpMethed.parseStringContent(array.get(0).toString()) + .getString("contractRet"), "SUCCESS"); Assert.assertTrue(responseContent.size() == 1); } @@ -113,8 +109,8 @@ public void test5GetTransactionsToThisFromSolidity() { JSONArray.parseArray(responseContent.getString("transaction")).get(0).toString()); String retString = transactionObject.getString("ret"); JSONArray array = JSONArray.parseArray(retString); - Assert.assertTrue(HttpMethed.parseStringContent(array.get(0).toString()).getString( - "contractRet") == null); + Assert.assertEquals(HttpMethed.parseStringContent(array.get(0).toString()).getString( + "contractRet"), "SUCCESS"); Assert.assertTrue(responseContent.size() == 1); } diff --git a/src/test/java/stest/tron/wallet/dailybuild/manual/ContractScenario011.java b/src/test/java/stest/tron/wallet/dailybuild/manual/ContractScenario011.java index d2e592db67e..438d270fb68 100644 --- a/src/test/java/stest/tron/wallet/dailybuild/manual/ContractScenario011.java +++ b/src/test/java/stest/tron/wallet/dailybuild/manual/ContractScenario011.java @@ -168,6 +168,7 @@ public void deploySaleClockAuction() { .deployContractWithConstantParame(contractName, abi, code, "constructor(address,uint256)", data, "", maxFeeLimit, 0L, consumeUserResourcePercent, null, deployKey, deployAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); Optional info = PublicMethed .getTransactionInfoById(deplTxid, blockingStubFull); Assert.assertTrue(info.get().getResultValue() == 0); diff --git a/src/test/java/stest/tron/wallet/dailybuild/manual/ContractScenario014.java b/src/test/java/stest/tron/wallet/dailybuild/manual/ContractScenario014.java index 0d76db4dcf3..456fdf57b46 100644 --- a/src/test/java/stest/tron/wallet/dailybuild/manual/ContractScenario014.java +++ b/src/test/java/stest/tron/wallet/dailybuild/manual/ContractScenario014.java @@ -115,6 +115,7 @@ public void testTripleTrigger() { txid = PublicMethed.deployContractWithConstantParame(contractName, abi1, code1, "constructor(address)", parame, "", maxFeeLimit, 0L, 100, null, contract014Key, contract014Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); Assert.assertTrue(infoById.get().getResultValue() == 0); contractAddress2 = infoById.get().getContractAddress().toByteArray(); diff --git a/src/test/java/stest/tron/wallet/dailybuild/operationupdate/WalletTestMutiSign018.java b/src/test/java/stest/tron/wallet/dailybuild/operationupdate/WalletTestMutiSign018.java new file mode 100644 index 00000000000..3cb68cb9928 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/operationupdate/WalletTestMutiSign018.java @@ -0,0 +1,321 @@ +package stest.tron.wallet.dailybuild.operationupdate; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.testng.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Block; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; +import stest.tron.wallet.common.client.utils.PublicMethedForMutiSign; + +@Slf4j +public class WalletTestMutiSign018 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key1"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private long multiSignFee = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.multiSignFee"); + private long updateAccountPermissionFee = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.updateAccountPermissionFee"); + private final String operations = Configuration.getByPath("testng.conf") + .getString("defaultParameter.operations"); + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + ArrayList txidList = new ArrayList(); + + Optional infoById = null; + Long beforeTime; + Long afterTime; + Long beforeBlockNum; + Long afterBlockNum; + Block currentBlock; + Long currentBlockNum; + String[] permissionKeyString = new String[2]; + String[] ownerKeyString = new String[2]; + String accountPermissionJson = ""; + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] manager1Address = ecKey1.getAddress(); + String manager1Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] manager2Address = ecKey2.getAddress(); + String manager2Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + ECKey ecKey3 = new ECKey(Utils.getRandom()); + byte[] ownerAddress = ecKey3.getAddress(); + String ownerKey = ByteArray.toHexString(ecKey3.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = false) + public void beforeClass() { + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + } + + @Test(enabled = false, threadPoolSize = 1, invocationCount = 1) + public void test1MutiSignForClearContractAbi() { + ecKey1 = new ECKey(Utils.getRandom()); + manager1Address = ecKey1.getAddress(); + manager1Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + ecKey2 = new ECKey(Utils.getRandom()); + manager2Address = ecKey2.getAddress(); + manager2Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + ecKey3 = new ECKey(Utils.getRandom()); + ownerAddress = ecKey3.getAddress(); + ownerKey = ByteArray.toHexString(ecKey3.getPrivKeyBytes()); + PublicMethed.printAddress(ownerKey); + + long needcoin = updateAccountPermissionFee + multiSignFee * 4; + + Assert.assertTrue( + PublicMethed.sendcoin(ownerAddress, needcoin + 100000000L, fromAddress, testKey002, + blockingStubFull)); + Assert.assertTrue(PublicMethed + .freezeBalanceForReceiver(fromAddress, 1000000000, 0, 0, ByteString.copyFrom(ownerAddress), + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed + .freezeBalanceForReceiver(fromAddress, 1000000000, 0, 1, ByteString.copyFrom(ownerAddress), + testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Long balanceBefore = PublicMethed.queryAccount(ownerAddress, blockingStubFull) + .getBalance(); + logger.info("balanceBefore: " + balanceBefore); + + permissionKeyString[0] = manager1Key; + permissionKeyString[1] = manager2Key; + PublicMethed.waitProduceNextBlock(blockingStubFull); + ownerKeyString[0] = ownerKey; + ownerKeyString[1] = manager1Key; + accountPermissionJson = + "{\"owner_permission\":{\"type\":0,\"permission_name\":\"owner\",\"threshold\":2,\"keys\":[" + + "{\"address\":\"" + PublicMethed.getAddressString(manager1Key) + "\",\"weight\":1}," + + "{\"address\":\"" + PublicMethed.getAddressString(ownerKey) + + "\",\"weight\":1}]}," + + "\"active_permissions\":[{\"type\":2,\"permission_name\":\"active0\",\"threshold\":2," + + "\"operations\":\"" + operations + "\"," + + "\"keys\":[" + + "{\"address\":\"" + PublicMethed.getAddressString(manager1Key) + "\",\"weight\":1}," + + "{\"address\":\"" + PublicMethed.getAddressString(manager2Key) + "\",\"weight\":1}" + + "]}]}"; + logger.info(accountPermissionJson); + PublicMethedForMutiSign.accountPermissionUpdate(accountPermissionJson, ownerAddress, ownerKey, + blockingStubFull, ownerKeyString); + + Long maxFeeLimit = 1000000000L; + String filePath = "src/test/resources/soliditycode/TriggerConstant004.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + byte[] contractAddress = PublicMethedForMutiSign.deployContract1(contractName, abi, code, + "", maxFeeLimit, + 0L, 100, null, ownerKey, ownerAddress, blockingStubFull, 2, permissionKeyString); + logger.info("address:" + Base58.encode58Check(contractAddress)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString() != null); + Assert.assertTrue(PublicMethedForMutiSign + .clearContractAbi(contractAddress, ownerAddress, ownerKey, + blockingStubFull, 2, permissionKeyString)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Assert.assertTrue( + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, ownerAddress, blockingStubFull)); + Assert.assertTrue( + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, ownerAddress, blockingStubFull)); + } + + @Test(enabled = false, threadPoolSize = 1, invocationCount = 1) + public void test2MutiSignForClearContractAbiForDefault() { + ecKey1 = new ECKey(Utils.getRandom()); + manager1Address = ecKey1.getAddress(); + manager1Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + ecKey2 = new ECKey(Utils.getRandom()); + manager2Address = ecKey2.getAddress(); + manager2Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + ecKey3 = new ECKey(Utils.getRandom()); + ownerAddress = ecKey3.getAddress(); + ownerKey = ByteArray.toHexString(ecKey3.getPrivKeyBytes()); + PublicMethed.printAddress(ownerKey); + + long needcoin = updateAccountPermissionFee + multiSignFee * 4; + + Assert.assertTrue( + PublicMethed.sendcoin(ownerAddress, needcoin + 100000000L, fromAddress, testKey002, + blockingStubFull)); + Assert.assertTrue(PublicMethed + .freezeBalanceForReceiver(fromAddress, 1000000000, 0, 0, ByteString.copyFrom(ownerAddress), + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed + .freezeBalanceForReceiver(fromAddress, 1000000000, 0, 1, ByteString.copyFrom(ownerAddress), + testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Long balanceBefore = PublicMethed.queryAccount(ownerAddress, blockingStubFull) + .getBalance(); + logger.info("balanceBefore: " + balanceBefore); + + permissionKeyString[0] = manager1Key; + permissionKeyString[1] = manager2Key; + PublicMethed.waitProduceNextBlock(blockingStubFull); + ownerKeyString[0] = ownerKey; + ownerKeyString[1] = manager1Key; + String operationsDefault = "7fff1fc0034e0100000000000000000000000000000000000000000000000000"; + accountPermissionJson = + "{\"owner_permission\":{\"type\":0,\"permission_name\":\"owner\",\"threshold\":2,\"keys\":[" + + "{\"address\":\"" + PublicMethed.getAddressString(manager1Key) + "\",\"weight\":1}," + + "{\"address\":\"" + PublicMethed.getAddressString(ownerKey) + + "\",\"weight\":1}]}," + + "\"active_permissions\":[{\"type\":2,\"permission_name\":\"active0\",\"threshold\":2," + + "\"operations\":\"" + operationsDefault + "\"," + + "\"keys\":[" + + "{\"address\":\"" + PublicMethed.getAddressString(manager1Key) + "\",\"weight\":1}," + + "{\"address\":\"" + PublicMethed.getAddressString(manager2Key) + "\",\"weight\":1}" + + "]}]}"; + logger.info(accountPermissionJson); + PublicMethedForMutiSign.accountPermissionUpdate(accountPermissionJson, ownerAddress, ownerKey, + blockingStubFull, ownerKeyString); + + Long maxFeeLimit = 1000000000L; + String filePath = "src/test/resources/soliditycode/TriggerConstant004.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + byte[] contractAddress = PublicMethedForMutiSign.deployContract1(contractName, abi, code, + "", maxFeeLimit, + 0L, 100, null, ownerKey, ownerAddress, blockingStubFull, 2, permissionKeyString); + logger.info("address:" + Base58.encode58Check(contractAddress)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString() != null); + Assert.assertTrue(PublicMethedForMutiSign + .clearContractAbi(contractAddress, ownerAddress, ownerKey, + blockingStubFull, 2, permissionKeyString)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Assert.assertTrue( + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, ownerAddress, blockingStubFull)); + Assert.assertTrue( + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, ownerAddress, blockingStubFull)); + } + + + @Test(enabled = false, threadPoolSize = 1, invocationCount = 1) + public void test3MutiSignForClearContractAbiForDefault() { + ecKey3 = new ECKey(Utils.getRandom()); + ownerAddress = ecKey3.getAddress(); + ownerKey = ByteArray.toHexString(ecKey3.getPrivKeyBytes()); + PublicMethed.printAddress(ownerKey); + + long needcoin = updateAccountPermissionFee + multiSignFee * 4; + + Assert.assertTrue( + PublicMethed.sendcoin(ownerAddress, needcoin + 100000000L, fromAddress, testKey002, + blockingStubFull)); + Assert.assertTrue(PublicMethed + .freezeBalanceForReceiver(fromAddress, 1000000000, 0, 0, ByteString.copyFrom(ownerAddress), + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed + .freezeBalanceForReceiver(fromAddress, 1000000000, 0, 1, ByteString.copyFrom(ownerAddress), + testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Long balanceBefore = PublicMethed.queryAccount(ownerAddress, blockingStubFull) + .getBalance(); + logger.info("balanceBefore: " + balanceBefore); + + String[] activeDefaultKeyString = new String[1]; + + activeDefaultKeyString[0] = ownerKey; + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Long maxFeeLimit = 1000000000L; + String filePath = "src/test/resources/soliditycode/TriggerConstant004.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + byte[] contractAddress = PublicMethedForMutiSign.deployContract1(contractName, abi, code, + "", maxFeeLimit, + 0L, 100, null, ownerKey, ownerAddress, blockingStubFull, 2, activeDefaultKeyString); + logger.info("address:" + Base58.encode58Check(contractAddress)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString() != null); + Assert.assertTrue(PublicMethedForMutiSign + .clearContractAbi(contractAddress, ownerAddress, ownerKey, + blockingStubFull, 2, activeDefaultKeyString)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Assert.assertTrue( + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, ownerAddress, blockingStubFull)); + Assert.assertTrue( + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, ownerAddress, blockingStubFull)); + } + + /** + * constructor. + */ + + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} \ No newline at end of file diff --git a/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken014.java b/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken014.java index d2909dc6b07..2b99381852e 100644 --- a/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken014.java +++ b/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken014.java @@ -355,6 +355,7 @@ public void test03TriggerContract() { 1000000000L, assetAccountId.toStringUtf8(), 2, user001Address, user001Key, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); Assert.assertTrue(infoById.get().getResultValue() != 0); @@ -407,6 +408,7 @@ public void test03TriggerContract() { 1000000000L, assetAccountId.toStringUtf8(), 2, user001Address, user001Key, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed.getTransactionInfoById(triggerTxid, blockingStubFull); Assert.assertTrue(infoById.get().getResultValue() != 0); Assert.assertEquals(FAILED, infoById.get().getResult()); @@ -454,7 +456,7 @@ public void test03TriggerContract() { "transferTokenTest(address,uint256,trcToken)", param, false, 0, 1000000000L, assetAccountId.toStringUtf8(), 2, user001Address, user001Key, blockingStubFull); - + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); Assert.assertTrue(infoById.get().getResultValue() != 0); @@ -478,7 +480,7 @@ public void test03TriggerContract() { "transferTokenTest(address,uint256,trcToken)", param, false, 0, 1000000000L, assetAccountId.toStringUtf8(), 2, user001Address, user001Key, blockingStubFull); - + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); Assert.assertTrue(infoById.get().getResultValue() != 0); @@ -502,7 +504,7 @@ public void test03TriggerContract() { "transferTokenTest(address,uint256,trcToken)", param, false, 0, 1000000000L, assetAccountId.toStringUtf8(), 2, user001Address, user001Key, blockingStubFull); - + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); Assert.assertTrue(infoById.get().getResultValue() != 0); @@ -527,7 +529,7 @@ public void test03TriggerContract() { "transferTokenTest(address,uint256,trcToken)", param, false, callValue, 1000000000L, assetAccountId.toStringUtf8(), 2, user001Address, user001Key, blockingStubFull); - + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); Assert.assertTrue(infoById.get().getResultValue() != 0); @@ -549,7 +551,7 @@ public void test03TriggerContract() { "transferTokenTest(address,uint256,trcToken)", param, false, callValue, 1000000000L, assetAccountId.toStringUtf8(), 2, user001Address, user001Key, blockingStubFull); - + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); Assert.assertTrue(infoById.get().getResultValue() != 0); diff --git a/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken064.java b/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken064.java index f3c169adc47..095fd394072 100644 --- a/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken064.java +++ b/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken064.java @@ -98,7 +98,6 @@ public void test01DeployTransferTokenContract() { ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); - PublicMethed.waitProduceNextBlock(blockingStubFull); long start = System.currentTimeMillis() + 2000; long end = System.currentTimeMillis() + 1000000000; @@ -320,6 +319,7 @@ public void test03TriggerContract() { 1000000000L, assetAccountId.toStringUtf8(), 2, user001Address, user001Key, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); Assert.assertTrue(infoById.get().getResultValue() != 0); @@ -340,6 +340,7 @@ public void test03TriggerContract() { 1000000000L, assetAccountId.toStringUtf8(), 2, user001Address, user001Key, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); @@ -359,7 +360,7 @@ public void test03TriggerContract() { "transferTokenTest(address,uint256,trcToken)", param, false, callValue, 1000000000L, assetAccountId.toStringUtf8(), 2, user001Address, user001Key, blockingStubFull); - + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); @@ -379,7 +380,7 @@ public void test03TriggerContract() { "transferTokenTest(address,uint256,trcToken)", param, false, callValue, 1000000000L, assetAccountId.toStringUtf8(), 2, user001Address, user001Key, blockingStubFull); - + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); @@ -399,7 +400,7 @@ public void test03TriggerContract() { "transferTokenTest(address,uint256,trcToken)", param, false, callValue, 1000000000L, assetAccountId.toStringUtf8(), 2, user001Address, user001Key, blockingStubFull); - + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); @@ -416,7 +417,7 @@ public void test03TriggerContract() { "transferTokenTestValueMaxLong(address)", param, false, callValue, 1000000000L, assetAccountId.toStringUtf8(), 2, user001Address, user001Key, blockingStubFull); - + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); Assert.assertTrue(infoById.get().getResultValue() != 0); @@ -432,6 +433,7 @@ public void test03TriggerContract() { "transferTokenTestValueMaxLong(address)", param, false, callValue, 1000000000L, assetAccountId.toStringUtf8(), 2, user001Address, user001Key, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); diff --git a/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken075.java b/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken075.java index 75343e7687e..4a9a9d4ce0b 100644 --- a/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken075.java +++ b/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken075.java @@ -88,7 +88,6 @@ public void testTokenBalanceContract() { Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); - PublicMethed.waitProduceNextBlock(blockingStubFull); long start = System.currentTimeMillis() + 2000; long end = System.currentTimeMillis() + 1000000000; @@ -200,7 +199,6 @@ public void testTokenBalanceContract() { Assert.assertEquals("REVERT opcode executed", infoById.get().getResMessage().toStringUtf8()); - PublicMethed.waitProduceNextBlock(blockingStubFull); tokenId = Long.toString(0); triggerTxid = PublicMethed.triggerContract(transferTokenContractAddress, @@ -217,7 +215,6 @@ public void testTokenBalanceContract() { Assert.assertEquals("REVERT opcode executed", infoById.get().getResMessage().toStringUtf8()); - PublicMethed.waitProduceNextBlock(blockingStubFull); tokenId = Long.toString(-1); @@ -225,7 +222,7 @@ public void testTokenBalanceContract() { "getToken(trcToken)", tokenId, false, 0, 1000000000L, "0", 0, dev001Address, dev001Key, blockingStubFull); - + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); logger.info("Trigger energytotal is " + infoById.get().getReceipt().getEnergyUsageTotal()); @@ -235,13 +232,14 @@ public void testTokenBalanceContract() { Assert.assertEquals("REVERT opcode executed", infoById.get().getResMessage().toStringUtf8()); - PublicMethed.waitProduceNextBlock(blockingStubFull); tokenId = Long.toString(Long.MIN_VALUE); triggerTxid = PublicMethed.triggerContract(transferTokenContractAddress, "getToken(trcToken)", tokenId, false, 0, 1000000000L, "0", 0, dev001Address, dev001Key, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); logger.info("Trigger energytotal is " + infoById.get().getReceipt().getEnergyUsageTotal()); @@ -251,12 +249,12 @@ public void testTokenBalanceContract() { Assert.assertEquals("REVERT opcode executed", infoById.get().getResMessage().toStringUtf8()); - PublicMethed.waitProduceNextBlock(blockingStubFull); triggerTxid = PublicMethed.triggerContract(transferTokenContractAddress, "getTokenLongMin()", "#", false, 0, 1000000000L, "0", 0, dev001Address, dev001Key, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(triggerTxid, blockingStubFull); @@ -267,7 +265,6 @@ public void testTokenBalanceContract() { Assert.assertEquals("REVERT opcode executed", infoById.get().getResMessage().toStringUtf8()); - PublicMethed.waitProduceNextBlock(blockingStubFull); triggerTxid = PublicMethed.triggerContract(transferTokenContractAddress, "getTokenLongMax()", "#", false, 0, diff --git a/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken076.java b/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken076.java index 4d216784749..1735f9b604c 100644 --- a/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken076.java +++ b/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken076.java @@ -80,7 +80,6 @@ public void testDeployTransferTokenContract() { .sendcoin(grammarAddress, 100000000000L, testNetAccountAddress, testNetAccountKey, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); String filePath = "./src/test/resources/soliditycode/contractTrcToken076.sol"; String contractName = "Test"; @@ -92,25 +91,23 @@ public void testDeployTransferTokenContract() { .deployContractAndGetTransactionInfoById(contractName, abi, code, "", maxFeeLimit, 0L, 100, null, testKeyForGrammarAddress, grammarAddress, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); Optional infoById = PublicMethed .getTransactionInfoById(txid, blockingStubFull); logger.info("Deploy energytotal is " + infoById.get().getReceipt().getEnergyUsageTotal()); contractAddress = infoById.get().getContractAddress().toByteArray(); - PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); PublicMethed.triggerContract(contractAddress, "test()", "#", false, 0, maxFeeLimit, grammarAddress, testKeyForGrammarAddress, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); txid = PublicMethed.triggerContract(contractAddress, "getResult1()", "#", false, 0, maxFeeLimit, grammarAddress, testKeyForGrammarAddress, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); logger.info("Deploy energytotal is " + infoById.get().getReceipt().getEnergyUsageTotal()); @@ -125,7 +122,6 @@ public void testDeployTransferTokenContract() { "getResult2()", "#", false, 0, maxFeeLimit, grammarAddress, testKeyForGrammarAddress, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); logger.info("Deploy energytotal is " + infoById.get().getReceipt().getEnergyUsageTotal()); diff --git a/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken077.java b/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken077.java index e4adf390894..57e6411a8cc 100644 --- a/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken077.java +++ b/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken077.java @@ -113,37 +113,40 @@ public void testAddress002() { .sendcoin(grammarAddress, 100000000000L, testNetAccountAddress, testNetAccountKey, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); - String filePath = "./src/test/resources/soliditycode/contractTrcToken077.sol"; String contractName = "trcToken077"; - HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); - String code = retMap.get("byteCode").toString(); - String abi = retMap.get("abI").toString(); + String code = "608060405234801561001057600080fd5b50d3801561001d57600080fd5b50d2801561002a57600" + + "080fd5b5060b0806100396000396000f3fe6080604052348015600f57600080fd5b50d38015601b57600080" + + "fd5b50d28015602757600080fd5b5060043610605c577c01000000000000000000000000000000000000000" + + "0000000000000000060003504636241c1d881146061575b600080fd5b60676079565b604080519182525190" + + "81900360200190f35b60405130908190529056fea165627a7a723058207b9b52e71420f2fa4cb55ffd55641" + + "355ec84e09d6d4545c629dde7cc01d74a100029"; + String abi = "[{\"constant\":false,\"inputs\":[],\"name\":\"addressTest\",\"outputs\":[{\"name" + + "\":\"addressValue\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"nonp" + + "ayable\",\"type\":\"function\"}]"; String deploytxid = PublicMethed .deployContractAndGetTransactionInfoById(contractName, abi, code, "", maxFeeLimit, 0L, 100, null, testKeyForGrammarAddress, grammarAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); Optional deployById = PublicMethed .getTransactionInfoById(deploytxid, blockingStubFull); contractAddress = deployById.get().getContractAddress().toByteArray(); logger.info("infoById:" + deployById); - PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); String txid = ""; txid = PublicMethed.triggerContract(contractAddress, "addressTest()", "#", false, 0, maxFeeLimit, grammarAddress, testKeyForGrammarAddress, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); Optional infoById = null; infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); logger.info("infoById:" + infoById); + Assert.assertNotNull(infoById); byte[] a = infoById.get().getContractResult(0).toByteArray(); byte[] b = subByte(a, 11, 1); byte[] c = subByte(a, 0, 11); diff --git a/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken078.java b/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken078.java index c6d2be29a0c..4a5bfa91ada 100644 --- a/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken078.java +++ b/src/test/java/stest/tron/wallet/dailybuild/trctoken/ContractTrcToken078.java @@ -88,9 +88,6 @@ public void testOriginCall001() { .sendcoin(internalTxsAddress, 100000000000L, testNetAccountAddress, testNetAccountKey, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed - .freezeBalanceGetEnergy(internalTxsAddress, 10000000000L, 0L, 1, priKey, blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); String filePath = "./src/test/resources/soliditycode/contractTrcToken078.sol"; String contractName = "callerContract"; @@ -104,7 +101,6 @@ public void testOriginCall001() { 1000000L, 100, null, testKeyForinternalTxsAddress, internalTxsAddress, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); Optional infoById = PublicMethed .getTransactionInfoById(txid, blockingStubFull); logger.info("infoById : " + infoById); @@ -121,15 +117,13 @@ public void testOriginCall001() { .deployContractAndGetTransactionInfoById(contractName1, abi1, code1, "", maxFeeLimit, 1000000L, 100, null, testKeyForinternalTxsAddress, internalTxsAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(txid, blockingStubFull); logger.info("infoById : " + infoById); byte[] contractAddress1; contractAddress1 = infoById.get().getContractAddress().toByteArray(); - PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); String filePath2 = "./src/test/resources/soliditycode/contractTrcToken078.sol"; String contractName2 = "c"; @@ -143,8 +137,6 @@ public void testOriginCall001() { 1000000L, 100, null, testKeyForinternalTxsAddress, internalTxsAddress, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(txid, blockingStubFull); @@ -159,8 +151,7 @@ public void testOriginCall001() { "sendToB2(address,address)", initParmes, false, 0, maxFeeLimit, internalTxsAddress, testKeyForinternalTxsAddress, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById2 = null; infoById2 = PublicMethed.getTransactionInfoById(txid2, blockingStubFull); logger.info("Trigger InfobyId: " + infoById2); @@ -180,7 +171,6 @@ public void testOriginDelegatecall001() { .sendcoin(internalTxsAddress, 100000000000L, testNetAccountAddress, testNetAccountKey, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); String filePath = "./src/test/resources/soliditycode/contractTrcToken078.sol"; String contractName = "callerContract"; @@ -193,14 +183,12 @@ public void testOriginDelegatecall001() { .deployContractAndGetTransactionInfoById(contractName, abi, code, "", maxFeeLimit, 1000000L, 100, null, testKeyForinternalTxsAddress, internalTxsAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); Optional infoById = PublicMethed .getTransactionInfoById(txid, blockingStubFull); logger.info("infoById : " + infoById); contractAddress = infoById.get().getContractAddress().toByteArray(); - PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); String filePath1 = "./src/test/resources/soliditycode/contractTrcToken078.sol"; String contractName1 = "calledContract"; HashMap retMap1 = PublicMethed.getBycodeAbi(filePath1, contractName1); @@ -212,8 +200,6 @@ public void testOriginDelegatecall001() { 1000000L, 100, null, testKeyForinternalTxsAddress, internalTxsAddress, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(txid, blockingStubFull); logger.info("infoById : " + infoById); @@ -231,8 +217,6 @@ public void testOriginDelegatecall001() { 1000000L, 100, null, testKeyForinternalTxsAddress, internalTxsAddress, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(txid, blockingStubFull); logger.info("infoById : " + infoById); @@ -246,8 +230,6 @@ public void testOriginDelegatecall001() { "sendToB(address,address)", initParmes, false, 0, maxFeeLimit, internalTxsAddress, testKeyForinternalTxsAddress, blockingStubFull); PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); - PublicMethed.waitProduceNextBlock(blockingStubFull); Optional infoById2 = null; infoById2 = PublicMethed.getTransactionInfoById(txid2, blockingStubFull); logger.info("infoById : " + infoById2); diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi001.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi001.java new file mode 100644 index 00000000000..5ea098d7ab5 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi001.java @@ -0,0 +1,311 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.clearabi; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ClearAbi001 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress1 = ecKey2.getAddress(); + String contractExcKey1 = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress1, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + } + + @Test(enabled = true, description = "Clear a contract created by other account") + public void testClearAbi001() { + String filePath = "src/test/resources/soliditycode/ClearAbi001.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + TransactionExtention transactionExtention = PublicMethed + .clearContractAbiForExtention(contractAddress, contractExcAddress1, contractExcKey1, + blockingStubFull); + Assert + .assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_VALIDATE_ERROR")); + Assert + .assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("is not the owner of the contract")); + + smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + + + } + + + @Test(enabled = true, description = "Clear a contract with ABI created by itself") + public void testClearAbi002() { + + String contractName = "testConstantContract"; + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String txid = PublicMethed + .clearContractAbi(contractAddress, contractExcAddress, contractExcKey, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Assert.assertTrue(infoById.get().getResultValue() == 0); + + String txid1 = PublicMethed + .clearContractAbi(contractAddress, contractExcAddress, contractExcKey, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById1 = null; + infoById1 = PublicMethed.getTransactionInfoById(txid1, blockingStubFull); + Assert.assertTrue(infoById1.get().getResultValue() == 0); + + smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + } + + + @Test(enabled = true, description = "Clear a contract without ABI") + public void testClearAbi003() { + + String contractName = "testConstantContract"; + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String txid = PublicMethed + .clearContractAbi(contractAddress, contractExcAddress, contractExcKey, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Assert.assertTrue(infoById.get().getResultValue() == 0); + + smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + + + } + + @Test(enabled = true, description = "Clear a account address") + public void testClearAbi004() { + TransactionExtention transactionExtention = PublicMethed + .clearContractAbiForExtention(contractExcAddress, contractExcAddress, contractExcKey, + blockingStubFull); + Assert + .assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_VALIDATE_ERROR")); + Assert + .assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("contract validate error : Contract not exists")); + } + + + @Test(enabled = true, description = "Clear a uninitialized account") + public void testClearAbi005() { + + ECKey ecKeyN = new ECKey(Utils.getRandom()); + byte[] contractExcAddressN = ecKeyN.getAddress(); + String contractExcKeyN = ByteArray.toHexString(ecKeyN.getPrivKeyBytes()); + + TransactionExtention transactionExtention = PublicMethed + .clearContractAbiForExtention(contractExcAddressN, contractExcAddress, contractExcKey, + blockingStubFull); + Assert.assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_VALIDATE_ERROR")); + Assert.assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("contract validate error : Contract not exists")); + + } + + @Test(enabled = true, description = "Clear a not meet the rules address") + public void testClearAbi006() { + byte[] fakeAddress = "412B5D".getBytes(); + TransactionExtention transactionExtention = PublicMethed + .clearContractAbiForExtention(fakeAddress, contractExcAddress, contractExcKey, + blockingStubFull); + Assert + .assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_VALIDATE_ERROR")); + Assert + .assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("contract validate error : Contract not exists")); + byte[] fakeAddress1 = "412B5D3405B2D26767C9C09886D53DEAFF6EB718AC111".getBytes(); + + TransactionExtention transactionExtention1 = PublicMethed + .clearContractAbiForExtention(fakeAddress1, contractExcAddress, contractExcKey, + blockingStubFull); + Assert + .assertThat(transactionExtention1.getResult().getCode().toString(), + containsString("CONTRACT_VALIDATE_ERROR")); + Assert + .assertThat(transactionExtention1.getResult().getMessage().toStringUtf8(), + containsString("contract validate error : Contract not exists")); + + + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi002.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi002.java new file mode 100644 index 00000000000..90c661d8994 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi002.java @@ -0,0 +1,160 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.clearabi; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ClearAbi002 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "Clear a contract with ABI created by itself") + public void testClearAbi() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/ClearAbi001.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String txid = PublicMethed + .clearContractAbi(contractAddress, contractExcAddress, contractExcKey, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(infoById.get().getResultValue() == 0); + + smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi003.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi003.java new file mode 100644 index 00000000000..88557f48b8a --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi003.java @@ -0,0 +1,159 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.clearabi; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ClearAbi003 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "Clear a contract without ABI") + public void testClearAbi() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/ClearAbi001.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, "[]", code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String txid = PublicMethed + .clearContractAbi(contractAddress, contractExcAddress, contractExcKey, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Assert.assertTrue(infoById.get().getResultValue() == 0); + + smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi004.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi004.java new file mode 100644 index 00000000000..f0a064753be --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi004.java @@ -0,0 +1,126 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.clearabi; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ClearAbi004 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "Clear a account address") + public void testClearAbi() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + TransactionExtention transactionExtention = PublicMethed + .clearContractAbiForExtention(contractExcAddress, contractExcAddress, contractExcKey, + blockingStubFull); + Assert + .assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_VALIDATE_ERROR")); + Assert + .assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("contract validate error : Contract not exists")); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi005.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi005.java new file mode 100644 index 00000000000..5036eeb6cfd --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi005.java @@ -0,0 +1,208 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.clearabi; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ClearAbi005 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "Clear a contract created by create2 (without ABI)") + public void testClearAbi() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/ClearAbi005.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String contractName1 = "TestConstract"; + HashMap retMap1 = PublicMethed.getBycodeAbi(filePath, contractName1); + String code1 = retMap1.get("byteCode").toString(); + String abi1 = retMap1.get("abI").toString(); + String txid = ""; + String num = "\"" + code1 + "\"" + "," + 1; + txid = PublicMethed + .triggerContract(contractAddress, + "deploy(bytes,uint256)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + byte[] returnAddressBytes = infoById.get().getInternalTransactions(0).getTransferToAddress() + .toByteArray(); + String returnAddress = Base58.encode58Check(returnAddressBytes); + logger.info("returnAddress:" + returnAddress); + SmartContract smartContract = PublicMethed.getContract(returnAddressBytes, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + TransactionExtention transactionExtention = PublicMethed + .clearContractAbiForExtention(returnAddressBytes, contractExcAddress, contractExcKey, + blockingStubFull); + Assert + .assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_VALIDATE_ERROR")); + Assert + .assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("is not the owner of the contract")); + + smartContract = PublicMethed.getContract(returnAddressBytes, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + } + + + /** + * testClearAbitestClearAbi constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi006.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi006.java new file mode 100644 index 00000000000..7928fdd8269 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi006.java @@ -0,0 +1,124 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.clearabi; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ClearAbi006 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress1 = ecKey2.getAddress(); + String contractExcKey1 = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "Clear a uninitialized account") + public void testClearAbi() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + TransactionExtention transactionExtention = PublicMethed + .clearContractAbiForExtention(contractExcAddress1, contractExcAddress, contractExcKey, + blockingStubFull); + Assert.assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_VALIDATE_ERROR")); + Assert.assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("contract validate error : Contract not exists")); + + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi007.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi007.java new file mode 100644 index 00000000000..a44383429a0 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi007.java @@ -0,0 +1,139 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.clearabi; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ClearAbi007 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress1 = ecKey2.getAddress(); + String contractExcKey1 = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "Clear a not meet the rules address") + public void testClearAbi() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + byte[] fakeAddress = "412B5D".getBytes(); + TransactionExtention transactionExtention = PublicMethed + .clearContractAbiForExtention(fakeAddress, contractExcAddress, contractExcKey, + blockingStubFull); + Assert + .assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_VALIDATE_ERROR")); + Assert + .assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("contract validate error : Contract not exists")); + byte[] fakeAddress1 = "412B5D3405B2D26767C9C09886D53DEAFF6EB718AC111".getBytes(); + + TransactionExtention transactionExtention1 = PublicMethed + .clearContractAbiForExtention(fakeAddress1, contractExcAddress, contractExcKey, + blockingStubFull); + Assert + .assertThat(transactionExtention1.getResult().getCode().toString(), + containsString("CONTRACT_VALIDATE_ERROR")); + Assert + .assertThat(transactionExtention1.getResult().getMessage().toStringUtf8(), + containsString("contract validate error : Contract not exists")); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi008.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi008.java new file mode 100644 index 00000000000..0b4d16f24f2 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/clearabi/ClearAbi008.java @@ -0,0 +1,173 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.clearabi; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ClearAbi008 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "Clear a contract with ABI created by itself，" + + "clear a contract by itself again") + public void testClearAbi() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/ClearAbi001.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String txid = PublicMethed + .clearContractAbi(contractAddress, contractExcAddress, contractExcKey, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Assert.assertTrue(infoById.get().getResultValue() == 0); + + smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + + String txid1 = PublicMethed + .clearContractAbi(contractAddress, contractExcAddress, contractExcKey, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById1 = null; + infoById1 = PublicMethed.getTransactionInfoById(txid1, blockingStubFull); + Assert.assertTrue(infoById1.get().getResultValue() == 0); + + smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test001.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test001.java new file mode 100644 index 00000000000..c02ca74691b --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test001.java @@ -0,0 +1,561 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test001 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private byte[] factoryContractAddress = null; + private byte[] factoryContractAddress2 = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = true, description = "Deploy factory contract generated by new solidity") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 10000_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 10000_000_000L, fromAddress, + testKey002, blockingStubFull)); + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = true, description = "Trigger create2 command with test bytecode using factory") + public void test02TriggerCreate2ToDeployTestContract() { + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + + // different contract address with different bytecode, same salt and address + Assert.assertNotEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(testContractAddress)); + } + + @Test(enabled = true, description = "Trigger create2 command with factory bytecode") + public void test02TriggerCreate2ToDeployFactory2Contract() { + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + factoryContractAddress2 = WalletClient.decodeFromBase58Check(addressFinal); + + SmartContract smartContract = PublicMethed + .getContract(factoryContractAddress2, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = true, description = "Trigger create2 command with test bytecode using factory2") + public void test03TriggerCreate2ToDeployTestContract2() { + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress2, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + Assert.assertEquals(1, infoById.get().getResultValue()); + Assert + .assertThat(infoById.get().getResMessage().toStringUtf8(), + containsString("Not enough energy for 'SWAP1' operation executing")); + } + + @Test(enabled = true, description = "Trigger create2 command without meta data hash in bytecode") + public void test04TriggerCreate2ToDeployTestContract() { + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String testContractCode = "608060405234801561001057600080fd5b50d3801561001d57600080fd5b50d2801" + + "561002a57600080fd5b5060c9806100396000396000f3fe6080604052348015600f57600080fd5b50d38015" + + "601b57600080fd5b50d28015602757600080fd5b50600436106066577c01000000000000000000000000000" + + "00000000000000000000000000000600035046368e5c0668114606b578063e5aa3d58146083575b600080fd" + + "5b60716089565b60408051918252519081900360200190f35b60716097565b6000805460010190819055905" + + "65b6000548156fe"; + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + + String msgSender = Base58.encode58Check(ByteArray.fromHexString(retList.get(2))); + Assert.assertNotEquals(msgSender, Base58.encode58Check(user001Address)); + } + + @Test(enabled = true, description = "Trigger create2 command with 0 extended bytecode") + public void test05TriggerCreate2ToDeployTestContract() { + Long callValue = Long.valueOf(0); + + String testContractCode = "608060405234801561001057600080fd5b50d3801561001d57600080fd5b50d2801" + + "561002a57600080fd5b5060c9806100396000396000f3fe6080604052348015600f57600080fd5b50d38015" + + "601b57600080fd5b50d28015602757600080fd5b50600436106066577c01000000000000000000000000000" + + "00000000000000000000000000000600035046368e5c0668114606b578063e5aa3d58146083575b600080fd" + + "5b60716089565b60408051918252519081900360200190f35b60716097565b6000805460010190819055905" + + "65b6000548156fe0000000000000000000000000000000000000000000000000000000000000000000000"; + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + + } + + @Test(enabled = true, description = "Trigger Test contact") + public void test04TriggerTestContract() { + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + final String triggerTxid = PublicMethed.triggerContract(testContractAddress, + "plusOne()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + Long ret = ByteArray.toLong(ByteArray.fromHexString(retList.get(0))); + + logger.info("ret: " + ret); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("transaction failed with message: " + infoById.get().getResMessage()); + } + + SmartContract smartContract = PublicMethed.getContract(infoById.get().getContractAddress() + .toByteArray(), blockingStubFull); + + long consumeUserPercent = smartContract.getConsumeUserResourcePercent(); + logger.info("ConsumeURPercent: " + consumeUserPercent); + + + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test002.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test002.java new file mode 100644 index 00000000000..c65c7c0b403 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test002.java @@ -0,0 +1,324 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test002 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = false, description = "Deploy factory contract") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + //PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + + @Test(enabled = false, description = "Trigger create2 command without meta data hash in bytecode") + public void test02TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + Long callValue = Long.valueOf(0); + + String testContractCode = "608060405234801561001057600080fd5b50d3801561001d57600080fd5b50d2801" + + "561002a57600080fd5b5060c9806100396000396000f3fe6080604052348015600f57600080fd5b50d38015" + + "601b57600080fd5b50d28015602757600080fd5b50600436106066577c01000000000000000000000000000" + + "00000000000000000000000000000600035046368e5c0668114606b578063e5aa3d58146083575b600080fd" + + "5b60716089565b60408051918252519081900360200190f35b60716097565b6000805460010190819055905" + + "65b6000548156fe"; + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + + String msgSender = Base58.encode58Check(ByteArray.fromHexString(retList.get(2))); + Assert.assertNotEquals(msgSender, Base58.encode58Check(user001Address)); + } + + + @Test(enabled = false, description = "Trigger Test contract") + public void test03TriggerTestContract() { + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + final String triggerTxid = PublicMethed.triggerContract(testContractAddress, + "plusOne()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + Long ret = ByteArray.toLong(ByteArray.fromHexString(retList.get(0))); + + logger.info("ret: " + ret); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("transaction failed with message: " + infoById.get().getResMessage()); + } + + SmartContract smartContract = PublicMethed.getContract(infoById.get().getContractAddress() + .toByteArray(), blockingStubFull); + + long consumeUserPercent = smartContract.getConsumeUserResourcePercent(); + logger.info("ConsumeURPercent: " + consumeUserPercent); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test003.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test003.java new file mode 100644 index 00000000000..6dd83d4f52f --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test003.java @@ -0,0 +1,489 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import static org.hamcrest.core.StringContains.containsString; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test003 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = true, description = "Deploy factory contract") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = true, description = "Trigger create2 command with invalid bytecode") + public void test02TriggerCreate2WithInvalidBytecode() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String testContractCode = "608060405234801561001057600080fd5b50d3801561001d57600080fd5b50d2801" + + "561002a57600080fd5b5060c9806100396000396000f5fe6080604052348015600f57600080fd5b50d38015" + + "601b57600080fd5b50d28015602757600080fd5b50600436106066577c01000000000000000000000000000" + + "00000000000000000000000000000600035046368e5c0668114606b578063e5aa3d58146083575b600080fd" + + "5b60716089565b60408051918252519081900360200190f35b60716097565b6000805460010190819055905" + + "65b6000548156fea165627a7a72305820f3e3c0646a8c8d521fe819f10a592327469f611f0d9e8206697f7f" + + "3436ff3c7d0029"; + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + Assert.assertEquals(1, infoById.get().getResultValue()); + Assert + .assertThat(infoById.get().getResMessage().toStringUtf8(), + containsString("Not enough energy for 'SWAP1' operation executing")); + } + + @Test(enabled = true, description = "Trigger create2 command with empty bytecode") + public void test03TriggerCreate2WithEmptyBytecode() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String testContractCode = ""; + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + Assert.assertEquals(1, infoById.get().getResultValue()); + Assert + .assertThat(infoById.get().getResMessage().toStringUtf8(), + containsString("REVERT opcode executed")); + } + + @Test(enabled = true, description = "Trigger create2 command with \"6080\" bytecode") + public void test04TriggerCreate2WithShortBytecode() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String testContractCode = "6080"; + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + Assert.assertEquals(1, infoById.get().getResultValue()); + Assert + .assertThat(infoById.get().getResMessage().toStringUtf8(), + containsString("REVERT opcode executed")); + } + + @Test(enabled = true, description = "Trigger create2 command with \"00000000000\" bytecode") + public void test05TriggerCreate2WithZeroBytecode() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String testContractCode = "000000000000000000000000000000"; + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + Assert.assertEquals(1, infoById.get().getResultValue()); + Assert + .assertThat(infoById.get().getResMessage().toStringUtf8(), + containsString("REVERT opcode executed")); + } + + @Test(enabled = true, description = "Trigger create2 command with NULL bytecode") + public void test06TriggerCreate2WithNullBytecode() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String testContractCode = null; + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + boolean ret = false; + + try { + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + } catch (org.spongycastle.util.encoders.DecoderException e) { + logger.info("Expected org.spongycastle.util.encoders.DecoderException!"); + ret = true; + } + Assert.assertTrue(ret); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test004.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test004.java new file mode 100644 index 00000000000..1b6760f3669 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test004.java @@ -0,0 +1,471 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import static org.hamcrest.core.StringContains.containsString; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test004 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] factoryContractAddress2 = null; + private byte[] testContractAddress = null; + private byte[] testContractAddress2 = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = false, description = "Deploy factory contract") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + /*AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore));*/ + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + /*accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter));*/ + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = false, description = "Trigger create2 command with factory bytecode") + public void test02TriggerCreate2ToDeployFactory2Contract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 150000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + /*AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore));*/ + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + /*accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter));*/ + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + factoryContractAddress2 = WalletClient.decodeFromBase58Check(addressFinal); + + SmartContract smartContract = PublicMethed + .getContract(factoryContractAddress2, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + + @Test(enabled = false, description = "Trigger create2 command with test bytecode using factory") + public void test03TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 80000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + /*AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore));*/ + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + /*accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter));*/ + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + + // different contract address with different bytecode, same salt and address + Assert.assertNotEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(testContractAddress)); + } + + @Test(enabled = false, description = "Trigger create2 command with test bytecode using factory2") + public void test04TriggerCreate2ToDeployTestContract2() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 80000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + /*AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore));*/ + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress2, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + /*accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter));*/ + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + Assert.assertEquals(1, infoById.get().getResultValue()); + Assert + .assertThat(infoById.get().getResMessage().toStringUtf8(), + containsString("Not enough energy for 'SWAP1' operation executing")); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test005.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test005.java new file mode 100644 index 00000000000..2c3069120cc --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test005.java @@ -0,0 +1,358 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test005 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = false, description = "Deploy factory contract") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + + @Test(enabled = false, description = "Trigger create2 command with 0 extended bytecode") + public void test02TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String testContractCode = "608060405234801561001057600080fd5b50d3801561001d57600080fd5b50d2801" + + "561002a57600080fd5b5060c9806100396000396000f3fe6080604052348015600f57600080fd5b50d38015" + + "601b57600080fd5b50d28015602757600080fd5b50600436106066577c01000000000000000000000000000" + + "00000000000000000000000000000600035046368e5c0668114606b578063e5aa3d58146083575b600080fd" + + "5b60716089565b60408051918252519081900360200190f35b60716097565b6000805460010190819055905" + + "65b6000548156fe0000000000000000000000000000000000000000000000000000000000000000000000"; + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = false, description = "Trigger test contract") + public void test03TriggerTestContract() { + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + final String triggerTxid = PublicMethed.triggerContract(testContractAddress, + "plusOne()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + Long ret = ByteArray.toLong(ByteArray.fromHexString(retList.get(0))); + + logger.info("ret: " + ret); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("transaction failed with message: " + infoById.get().getResMessage()); + } + + SmartContract smartContract = PublicMethed.getContract(infoById.get().getContractAddress() + .toByteArray(), blockingStubFull); + + long consumeUserPercent = smartContract.getConsumeUserResourcePercent(); + logger.info("ConsumeURPercent: " + consumeUserPercent); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test006.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test006.java new file mode 100644 index 00000000000..c892288ad24 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test006.java @@ -0,0 +1,1013 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test006 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = true, description = "Deploy factory contract") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = true, description = "Trigger create2 with salt empty") + public void test02TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + String param = "\"" + testContractCode + "\"," + null; + boolean ret = false; + try { + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + } catch (NullPointerException e) { + logger.info("Expected NullPointerException!"); + ret = true; + } + Assert.assertTrue(ret); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + @Test(enabled = true, description = "Trigger create2 with salt 0") + public void test03TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + Long salt = 0L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + Assert.assertEquals(salt, actualSalt); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = true, description = "Trigger create2 with salt -1") + public void test04TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + Long salt = -1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + Assert.assertEquals(salt, actualSalt); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = true, description = "Trigger create2 with salt 100") + public void test05TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + Long salt = 100L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + Assert.assertEquals(salt, actualSalt); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = true, description = "Trigger create2 with salt f * 64") + public void test06TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + String saltHexString = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"; + logger.info("saltHexString: " + saltHexString); + + String param = "\"" + testContractCode + "\",\"" + saltHexString + "\""; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,bytes32)", param, false, callValue, + 1000000000L, "0", 0, dev001Address, dev001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + // The first + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("addressHex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("addressFinal: " + addressFinal); + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + String actualSalt = retList.get(1); + logger.info("actualSalt: " + actualSalt); + + byte[] tmpSenderAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(2)), 12, tmpSenderAddress, 0, 20); + String senderAddressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("senderAddressHex: " + senderAddressHex); + String senderAddressFinal = Base58.encode58Check(ByteArray.fromHexString(senderAddressHex)); + logger.info("senderAddressFinal: " + senderAddressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + Assert.assertEquals(saltHexString, actualSalt); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = true, description = "Trigger create2 with salt efffe") + public void test07TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + final String saltHexString = "EFFFE"; + final String expectedSalt = "0EFFFE0000000000000000000000000000000000000000000000000000000000"; + + logger.info("saltHexString: " + saltHexString); + + String param = "\"" + testContractCode + "\",\"" + saltHexString + "\""; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,bytes32)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + // The first + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("addressHex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("addressFinal: " + addressFinal); + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + String actualSalt = retList.get(1); + logger.info("actualSalt: " + actualSalt); + + byte[] tmpSenderAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(2)), 12, tmpSenderAddress, 0, 20); + String senderAddressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("senderAddressHex: " + senderAddressHex); + String senderAddressFinal = Base58.encode58Check(ByteArray.fromHexString(senderAddressHex)); + logger.info("senderAddressFinal: " + senderAddressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + Assert.assertEquals(expectedSalt, actualSalt); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = true, description = "Trigger create2 with salt affffa") + public void test08TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + final String saltHexString = "AFFFFA"; + final String expectedSalt = "AFFFFA0000000000000000000000000000000000000000000000000000000000"; + logger.info("saltHexString: " + saltHexString); + + String param = "\"" + testContractCode + "\",\"" + saltHexString + "\""; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,bytes32)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + // The first + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("addressHex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("addressFinal: " + addressFinal); + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + String actualSalt = retList.get(1); + logger.info("actualSalt: " + actualSalt); + + byte[] tmpSenderAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(2)), 12, tmpSenderAddress, 0, 20); + String senderAddressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("senderAddressHex: " + senderAddressHex); + String senderAddressFinal = Base58.encode58Check(ByteArray.fromHexString(senderAddressHex)); + logger.info("senderAddressFinal: " + senderAddressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + Assert.assertEquals(expectedSalt, actualSalt); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + @Test(enabled = true, description = "Trigger test contract") + public void test09TriggerTestContract() { + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + final String triggerTxid = PublicMethed.triggerContract(testContractAddress, + "plusOne()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + Long ret = ByteArray.toLong(ByteArray.fromHexString(retList.get(0))); + + logger.info("ret: " + ret); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("transaction failed with message: " + infoById.get().getResMessage()); + } + + SmartContract smartContract = PublicMethed.getContract(infoById.get().getContractAddress() + .toByteArray(), blockingStubFull); + + long consumeUserPercent = smartContract.getConsumeUserResourcePercent(); + logger.info("ConsumeURPercent: " + consumeUserPercent); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test007.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test007.java new file mode 100644 index 00000000000..f4ab1ea698f --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test007.java @@ -0,0 +1,358 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test007 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = false, description = "Deploy factory contract") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = false, description = "Trigger create2 with salt -1") + public void test02TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + Long salt = -1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + Assert.assertEquals(salt, actualSalt); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = false, description = "Trigger test contract") + public void test03TriggerTestContract() { + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + final String triggerTxid = PublicMethed.triggerContract(testContractAddress, + "plusOne()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + Long ret = ByteArray.toLong(ByteArray.fromHexString(retList.get(0))); + + logger.info("ret: " + ret); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("transaction failed with message: " + infoById.get().getResMessage()); + } + + SmartContract smartContract = PublicMethed.getContract(infoById.get().getContractAddress() + .toByteArray(), blockingStubFull); + + long consumeUserPercent = smartContract.getConsumeUserResourcePercent(); + logger.info("ConsumeURPercent: " + consumeUserPercent); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test008.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test008.java new file mode 100644 index 00000000000..3bd45115367 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test008.java @@ -0,0 +1,358 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test008 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = false, description = "Deploy factory contract") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = false, description = "Trigger create2 with salt 100") + public void test02TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + Long salt = 100L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + Assert.assertEquals(salt, actualSalt); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = false, description = "Trigger test contract") + public void test03TriggerTestContract() { + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + final String triggerTxid = PublicMethed.triggerContract(testContractAddress, + "plusOne()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + Long ret = ByteArray.toLong(ByteArray.fromHexString(retList.get(0))); + + logger.info("ret: " + ret); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("transaction failed with message: " + infoById.get().getResMessage()); + } + + SmartContract smartContract = PublicMethed.getContract(infoById.get().getContractAddress() + .toByteArray(), blockingStubFull); + + long consumeUserPercent = smartContract.getConsumeUserResourcePercent(); + logger.info("ConsumeURPercent: " + consumeUserPercent); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test009.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test009.java new file mode 100644 index 00000000000..cda26f9439e --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test009.java @@ -0,0 +1,365 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test009 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = false, description = "Deploy factory contract generated by new solidity") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + + @Test(enabled = false, description = "Trigger create2 function to deploy test contract") + public void test02TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + + String[] parameter = {Base58.encode58Check(user001Address), testContractCode, salt.toString()}; + logger.info(PublicMethed.create2(parameter)); + + Assert.assertEquals(Base58.encode58Check(testContractAddress), PublicMethed.create2(parameter)); + + } + + + @Test(enabled = false, description = "Trigger Test contact") + public void test03TriggerTestContract() { + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + final String triggerTxid = PublicMethed.triggerContract(testContractAddress, + "plusOne()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + Long ret = ByteArray.toLong(ByteArray.fromHexString(retList.get(0))); + + logger.info("ret: " + ret); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("transaction failed with message: " + infoById.get().getResMessage()); + } + + SmartContract smartContract = PublicMethed.getContract(infoById.get().getContractAddress() + .toByteArray(), blockingStubFull); + + long consumeUserPercent = smartContract.getConsumeUserResourcePercent(); + logger.info("ConsumeURPercent: " + consumeUserPercent); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test010.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test010.java new file mode 100644 index 00000000000..df968624a91 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test010.java @@ -0,0 +1,210 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test010 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = false, description = "TransferToken with correct value, deploy transfer contract") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + + @Test(enabled = false, description = "Trigger create2 with salt empty") + public void test02TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + String param = "\"" + testContractCode + "\"," + null; + boolean ret = false; + try { + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + } catch (NullPointerException e) { + logger.info("Expected NullPointerException!"); + ret = true; + } + Assert.assertTrue(ret); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test011.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test011.java new file mode 100644 index 00000000000..d41603ce140 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test011.java @@ -0,0 +1,369 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test011 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = false, description = "Deploy factory contract") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "FactoryBytes"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + + @Test(enabled = false, description = "Trigger create2 with salt f * 64") + public void test02TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + String saltHexString = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"; + logger.info("saltHexString: " + saltHexString); + + String param = "\"" + testContractCode + "\",\"" + saltHexString + "\""; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,bytes32)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + // The first + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("addressHex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("addressFinal: " + addressFinal); + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + String actualSalt = retList.get(1); + logger.info("actualSalt: " + actualSalt); + + byte[] tmpSenderAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(2)), 12, tmpSenderAddress, 0, 20); + String senderAddressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("senderAddressHex: " + senderAddressHex); + String senderAddressFinal = Base58.encode58Check(ByteArray.fromHexString(senderAddressHex)); + logger.info("senderAddressFinal: " + senderAddressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + Assert.assertEquals(saltHexString, actualSalt); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + + @Test(enabled = false, description = "Trigger test contract") + public void test03TriggerTestContract() { + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + final String triggerTxid = PublicMethed.triggerContract(testContractAddress, + "plusOne()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + Long ret = ByteArray.toLong(ByteArray.fromHexString(retList.get(0))); + + logger.info("ret: " + ret); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("transaction failed with message: " + infoById.get().getResMessage()); + } + + SmartContract smartContract = PublicMethed.getContract(infoById.get().getContractAddress() + .toByteArray(), blockingStubFull); + + long consumeUserPercent = smartContract.getConsumeUserResourcePercent(); + logger.info("ConsumeURPercent: " + consumeUserPercent); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test012.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test012.java new file mode 100644 index 00000000000..0d33efa7f04 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test012.java @@ -0,0 +1,396 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test012 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + private byte[] testContractAddress2 = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = false, description = "Deploy factory contract") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + + @Test(enabled = false, description = "Trigger create2 command with test bytecode and salt 1") + public void test02TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 80000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + Assert.assertEquals(salt, actualSalt); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + + @Test(enabled = false, description = "Trigger create2 command with test bytecode and salt 2") + public void test03TriggerCreate2ToDeployTestContract2() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 80000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + Long salt = 2L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress2 = WalletClient.decodeFromBase58Check(addressFinal); + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + Assert.assertEquals(salt, actualSalt); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + + // contract address are different with different salt + Assert.assertNotEquals(Base58.encode58Check(testContractAddress), + Base58.encode58Check(testContractAddress2)); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test013.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test013.java new file mode 100644 index 00000000000..82d6c405ca8 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test013.java @@ -0,0 +1,436 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import static org.hamcrest.core.StringContains.containsString; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test013 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = false, description = "Deploy factory contract") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = false, description = "Trigger factory contract to deploy test contract") + public void test02TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = false, description = "Trigger factory contract to deploy test contract again " + + "with same code, salt and address") + public void test03TriggerCreate2ToDeployTestContractAgain() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + Assert.assertEquals(1, infoById.get().getResultValue()); + Assert + .assertThat(infoById.get().getResMessage().toStringUtf8(), + containsString("Not enough energy for 'SWAP1' operation executing")); + } + + @Test(enabled = false, description = "Trigger test1 contract") + public void test04TriggerTestContract() { + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + final String triggerTxid = PublicMethed.triggerContract(testContractAddress, + "plusOne()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + Long ret = ByteArray.toLong(ByteArray.fromHexString(retList.get(0))); + + logger.info("ret: " + ret); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("transaction failed with message: " + infoById.get().getResMessage()); + } + + SmartContract smartContract = PublicMethed.getContract(infoById.get().getContractAddress() + .toByteArray(), blockingStubFull); + + long consumeUserPercent = smartContract.getConsumeUserResourcePercent(); + logger.info("ConsumeURPercent: " + consumeUserPercent); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test014.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test014.java new file mode 100644 index 00000000000..974f0e4321c --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test014.java @@ -0,0 +1,638 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import static org.hamcrest.core.StringContains.containsString; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test014 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + private byte[] testContractAddress2 = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = true, description = "Deploy factory contract") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + + @Test(enabled = true, description = "Trigger factory contract with Test " + + "bytecode and salt using user account") + public void test02TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = true, description = "Trigger factory contract to deploy test contract again " + + "with same code, salt and address") + public void test02TriggerCreate2ToDeployTestContractAgain() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + Assert.assertEquals(1, infoById.get().getResultValue()); + Assert + .assertThat(infoById.get().getResMessage().toStringUtf8(), + containsString("Not enough energy for 'SWAP1' operation executing")); + } + + @Test(enabled = true, description = "Same code, salt and address," + + " create contract using develop account") + public void test03TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, dev001Address, dev001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress2 = WalletClient.decodeFromBase58Check(addressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress2, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + + // contract address are different + Assert.assertNotEquals(Base58.encode58Check(testContractAddress), + Base58.encode58Check(testContractAddress2)); + } + + @Test(enabled = true, description = "Trigger test1 contract") + public void test04TriggerTest1Contract() { + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + final String triggerTxid = PublicMethed.triggerContract(testContractAddress, + "plusOne()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + Long ret = ByteArray.toLong(ByteArray.fromHexString(retList.get(0))); + + logger.info("ret: " + ret); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("transaction failed with message: " + infoById.get().getResMessage()); + } + + SmartContract smartContract = PublicMethed.getContract(infoById.get().getContractAddress() + .toByteArray(), blockingStubFull); + + long consumeUserPercent = smartContract.getConsumeUserResourcePercent(); + logger.info("ConsumeURPercent: " + consumeUserPercent); + } + + @Test(enabled = true, description = "Trigger test2 contract") + public void test05TriggerTest2Contract() { + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + final String triggerTxid = PublicMethed.triggerContract(testContractAddress2, + "plusOne()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + Long ret = ByteArray.toLong(ByteArray.fromHexString(retList.get(0))); + + logger.info("ret: " + ret); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("transaction failed with message: " + infoById.get().getResMessage()); + } + + SmartContract smartContract = PublicMethed.getContract(infoById.get().getContractAddress() + .toByteArray(), blockingStubFull); + + long consumeUserPercent = smartContract.getConsumeUserResourcePercent(); + logger.info("ConsumeURPercent: " + consumeUserPercent); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test015.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test015.java new file mode 100644 index 00000000000..65259f1bc09 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test015.java @@ -0,0 +1,500 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test015 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] callerContractAddress = null; + private byte[] callContractAddress = null; + private byte[] delegateCallContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = true, description = "Deploy caller contract") + public void test01DeployCallerContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2CallContract.sol"; + String contractName = "callerContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + callerContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(callerContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = true, description = "Deploy factory contract") + public void test02DeployFactoryContract() { + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = true, description = "Trigger callCreate2 function in caller contract " + + "with factory contract address") + public void test03TriggerCreate2ToDeployTestContract() { + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + Long salt = 1L; + + String param = "\"" + Base58.encode58Check(factoryContractAddress) + + "\",\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(callerContractAddress, + "callCreate2(address,bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), + 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + callContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(callContractAddress, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // call type make the caller contract to be the owner of + // test contract (the contract address in transaction info) + Assert.assertEquals(Base58.encode58Check(callerContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = true, description = "Trigger delegateCallCreate2 function in caller contract " + + "with factory contract address") + public void test04TriggerCreate2ToDeployTestContract() { + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + Long salt = 1L; + + String param = "\"" + Base58.encode58Check(factoryContractAddress) + + "\",\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(callerContractAddress, + "delegateCallCreate2(address,bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + delegateCallContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed + .getContract(delegateCallContractAddress, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // delegatecall type make the caller contract to be the owner of test contract (contract info) + Assert.assertEquals(Base58.encode58Check(callerContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // call type make the caller contract to be the owner of test contract + // (the contract address in transaction info) + Assert.assertEquals(Base58.encode58Check(callerContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = true, description = "Trigger test contract") + public void test09TriggerTestContract() { + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + final String triggerTxid = PublicMethed.triggerContract(callContractAddress, + "plusOne()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + Long ret = ByteArray.toLong(ByteArray.fromHexString(retList.get(0))); + + logger.info("ret: " + ret); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("transaction failed with message: " + infoById.get().getResMessage()); + } + + SmartContract smartContract = PublicMethed.getContract(infoById.get().getContractAddress() + .toByteArray(), blockingStubFull); + + long consumeUserPercent = smartContract.getConsumeUserResourcePercent(); + logger.info("ConsumeURPercent: " + consumeUserPercent); + + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test016.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test016.java new file mode 100644 index 00000000000..d4b45711d72 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test016.java @@ -0,0 +1,422 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test016 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] callerContractAddress = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = false, description = "Deploy caller contract") + public void test01DeployCallerContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2CallContract.sol"; + String contractName = "callerContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + callerContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(callerContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = false, description = "Deploy factory contract") + public void test02DeployFactoryContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = false, description = "Trigger delegateCallCreate2 function in caller contract " + + "with factory contract address") + public void test03TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + Long salt = 1L; + + String param = "\"" + Base58.encode58Check(factoryContractAddress) + + "\",\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(callerContractAddress, + "delegateCallCreate2(address,bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // delegatecall type make the caller contract to be the owner of test contract (contract info) + Assert.assertEquals(Base58.encode58Check(callerContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // call type make the caller contract to be the owner of test contract + // (the contract address in transaction info) + Assert.assertEquals(Base58.encode58Check(callerContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = false, description = "Trigger test contract") + public void test04TriggerTestContract() { + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + final String triggerTxid = PublicMethed.triggerContract(testContractAddress, + "plusOne()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + Long ret = ByteArray.toLong(ByteArray.fromHexString(retList.get(0))); + + logger.info("ret: " + ret); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("transaction failed with message: " + infoById.get().getResMessage()); + } + + SmartContract smartContract = PublicMethed.getContract(infoById.get().getContractAddress() + .toByteArray(), blockingStubFull); + + long consumeUserPercent = smartContract.getConsumeUserResourcePercent(); + logger.info("ConsumeURPercent: " + consumeUserPercent); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test017.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test017.java new file mode 100644 index 00000000000..872dc4ebbc9 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test017.java @@ -0,0 +1,405 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test017 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = false, description = "Deploy factory contract") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "FactoryBytes"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = false, description = "Trigger create2 with salt efffe") + public void test02TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + final String saltHexString = "EFFFE"; + final String expectedSalt = "0EFFFE0000000000000000000000000000000000000000000000000000000000"; + + logger.info("saltHexString: " + saltHexString); + + String param = "\"" + testContractCode + "\",\"" + saltHexString + "\""; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,bytes32)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + // The first + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("addressHex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("addressFinal: " + addressFinal); + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + String actualSalt = retList.get(1); + logger.info("actualSalt: " + actualSalt); + + byte[] tmpSenderAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(2)), 12, tmpSenderAddress, 0, 20); + String senderAddressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("senderAddressHex: " + senderAddressHex); + String senderAddressFinal = Base58.encode58Check(ByteArray.fromHexString(senderAddressHex)); + logger.info("senderAddressFinal: " + senderAddressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + Assert.assertEquals(expectedSalt, actualSalt); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = false, description = "Trigger create2 with salt affffa") + public void test03TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + + final String saltHexString = "AFFFFA"; + final String expectedSalt = "AFFFFA0000000000000000000000000000000000000000000000000000000000"; + logger.info("saltHexString: " + saltHexString); + + String param = "\"" + testContractCode + "\",\"" + saltHexString + "\""; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,bytes32)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + // The first + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("addressHex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("addressFinal: " + addressFinal); + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + String actualSalt = retList.get(1); + logger.info("actualSalt: " + actualSalt); + + byte[] tmpSenderAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(2)), 12, tmpSenderAddress, 0, 20); + String senderAddressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("senderAddressHex: " + senderAddressHex); + String senderAddressFinal = Base58.encode58Check(ByteArray.fromHexString(senderAddressHex)); + logger.info("senderAddressFinal: " + senderAddressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + Assert.assertEquals(expectedSalt, actualSalt); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test018.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test018.java new file mode 100644 index 00000000000..c0a0096ae0e --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test018.java @@ -0,0 +1,360 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.Random; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test018 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private String witnessKey001 = Configuration.getByPath("testng.conf") + .getString("witness.key2"); + private byte[] witnessAddress001 = PublicMethed.getFinalAddress(witnessKey001); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(witnessKey001); + } + + @Test(enabled = false, description = "Deploy factory contract generated by new solidity") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(witnessAddress001, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + + @Test(enabled = false, description = "Trigger create2 function to deploy test contract " + + "using Witness account") + public void test02TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 9000_000_000_000L, 0, 1, + ByteString.copyFrom(witnessAddress001), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(witnessAddress001, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(witnessAddress001, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + Long salt = new Random().nextLong(); + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, witnessAddress001, witnessKey001, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(witnessAddress001, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(witnessAddress001, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + + @Test(enabled = false, description = "Trigger Test contact") + public void test03TriggerTestContract() { + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(witnessAddress001, witnessKey001, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(witnessAddress001), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(witnessAddress001, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(witnessAddress001, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + final String triggerTxid = PublicMethed.triggerContract(testContractAddress, + "plusOne()", "#", false, callValue, + 1000000000L, "0", 0, witnessAddress001, witnessKey001, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(witnessAddress001, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(witnessAddress001, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + Long ret = ByteArray.toLong(ByteArray.fromHexString(retList.get(0))); + + logger.info("ret: " + ret); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("transaction failed with message: " + infoById.get().getResMessage()); + } + + SmartContract smartContract = PublicMethed.getContract(infoById.get().getContractAddress() + .toByteArray(), blockingStubFull); + + long consumeUserPercent = smartContract.getConsumeUserResourcePercent(); + logger.info("ConsumeURPercent: " + consumeUserPercent); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + witnessAddress001, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + witnessAddress001, blockingStubFull); + + + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test019.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test019.java new file mode 100644 index 00000000000..cce3d710083 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test019.java @@ -0,0 +1,309 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import static org.hamcrest.core.StringContains.containsString; +import static org.tron.protos.Protocol.Transaction.Result.contractResult.SUCCESS_VALUE; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.Transaction; +import org.tron.protos.Protocol.Transaction.Result.contractResult; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test019 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "seted Value of Contract that created by create2," + + " should not be stored after contact suicided ande create2 again") + public void testTriggerContract() { + String sendcoin = PublicMethed + .sendcoinGetTransactionId(contractExcAddress, 1000000000L, testNetAccountAddress, + testNetAccountKey, + blockingStubFull); + + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById0 = null; + infoById0 = PublicMethed.getTransactionInfoById(sendcoin, blockingStubFull); + logger.info("infoById0 " + infoById0.get()); + Assert.assertEquals(ByteArray.toHexString(infoById0.get().getContractResult(0).toByteArray()), + ""); + Assert.assertEquals(infoById0.get().getResult().getNumber(), 0); + Optional ById = PublicMethed.getTransactionById(sendcoin, blockingStubFull); + Assert.assertEquals(ById.get().getRet(0).getContractRet().getNumber(), + SUCCESS_VALUE); + Assert.assertEquals(ById.get().getRet(0).getContractRetValue(), SUCCESS_VALUE); + Assert.assertEquals(ById.get().getRet(0).getContractRet(), contractResult.SUCCESS); + String filePath = "src/test/resources/soliditycode/create2contractn2.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String contractName1 = "TestConstract"; + HashMap retMap1 = PublicMethed.getBycodeAbi(filePath, contractName1); + String code1 = retMap1.get("byteCode").toString(); + String abi1 = retMap1.get("abI").toString(); + String txid = ""; + String num = "\"" + code1 + "\"" + "," + 1; + txid = PublicMethed + .triggerContract(contractAddress, + "deploy(bytes,uint256)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + byte[] returnAddressBytes = infoById.get().getInternalTransactions(0).getTransferToAddress() + .toByteArray(); + String returnAddress = Base58.encode58Check(returnAddressBytes); + logger.info("returnAddress:" + returnAddress); + txid = PublicMethed + .triggerContract(returnAddressBytes, + "i()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById1 = null; + infoById1 = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee1 = infoById1.get().getFee(); + Long netUsed1 = infoById1.get().getReceipt().getNetUsage(); + Long energyUsed1 = infoById1.get().getReceipt().getEnergyUsage(); + Long netFee1 = infoById1.get().getReceipt().getNetFee(); + long energyUsageTotal1 = infoById1.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee1:" + fee1); + logger.info("netUsed1:" + netUsed1); + logger.info("energyUsed1:" + energyUsed1); + logger.info("netFee1:" + netFee1); + logger.info("energyUsageTotal1:" + energyUsageTotal1); + + Account infoafter1 = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter1 = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance1 = infoafter1.getBalance(); + Long afterEnergyUsed1 = resourceInfoafter1.getEnergyUsed(); + Long afterNetUsed1 = resourceInfoafter1.getNetUsed(); + Long afterFreeNetUsed1 = resourceInfoafter1.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance1); + logger.info("afterEnergyUsed:" + afterEnergyUsed1); + logger.info("afterNetUsed:" + afterNetUsed1); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed1); + + Assert.assertTrue(infoById1.get().getResultValue() == 0); + Assert.assertTrue(afterBalance1 + fee1 == afterBalance); + Assert.assertTrue(afterEnergyUsed + energyUsed1 >= afterEnergyUsed1); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById1.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + txid = PublicMethed + .triggerContract(returnAddressBytes, + "set()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + txid = PublicMethed + .triggerContract(returnAddressBytes, + "i()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById1 = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById1.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(5 == returnnumber); + + String param1 = "\"" + Base58.encode58Check(returnAddressBytes) + "\""; + + txid = PublicMethed + .triggerContract(returnAddressBytes, + "testSuicideNonexistentTarget(address)", param1, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById2 = PublicMethed + .getTransactionInfoById(txid, blockingStubFull); + + Assert.assertEquals("suicide", ByteArray + .toStr(infoById2.get().getInternalTransactions(0).getNote().toByteArray())); + TransactionExtention transactionExtention = PublicMethed + .triggerContractForExtention(returnAddressBytes, + "i()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Assert + .assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_VALIDATE_ERROR")); + Assert + .assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("contract validate error : No contract or not a smart contract")); + + txid = PublicMethed + .triggerContract(contractAddress, + "deploy(bytes,uint256)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional infoById3 = PublicMethed + .getTransactionInfoById(txid, blockingStubFull); + byte[] returnAddressBytes1 = infoById3.get().getInternalTransactions(0).getTransferToAddress() + .toByteArray(); + String returnAddress1 = Base58.encode58Check(returnAddressBytes1); + Assert.assertEquals(returnAddress1, returnAddress); + txid = PublicMethed + .triggerContract(returnAddressBytes1, + "i()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById1 = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById1.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test020.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test020.java new file mode 100644 index 00000000000..849177628fe --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test020.java @@ -0,0 +1,913 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test020 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "Deploy Factory contract, create2 with salt type : trcToken") + public void testTriggerContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/create2contract22.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String contractName1 = "TestConstract"; + HashMap retMap1 = PublicMethed.getBycodeAbi(filePath, contractName1); + String code1 = retMap1.get("byteCode").toString(); + String abi1 = retMap1.get("abI").toString(); + String txid = ""; + String num = "\"" + code1 + "\"" + "," + 1000001; + txid = PublicMethed + .triggerContract(contractAddress, + "deploy(bytes,trcToken)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + byte[] returnAddressBytes = infoById.get().getInternalTransactions(0).getTransferToAddress() + .toByteArray(); + String returnAddress = Base58.encode58Check(returnAddressBytes); + logger.info("returnAddress:" + returnAddress); + txid = PublicMethed + .triggerContract(returnAddressBytes, + "i()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById1 = null; + infoById1 = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee1 = infoById1.get().getFee(); + Long netUsed1 = infoById1.get().getReceipt().getNetUsage(); + Long energyUsed1 = infoById1.get().getReceipt().getEnergyUsage(); + Long netFee1 = infoById1.get().getReceipt().getNetFee(); + long energyUsageTotal1 = infoById1.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee1:" + fee1); + logger.info("netUsed1:" + netUsed1); + logger.info("energyUsed1:" + energyUsed1); + logger.info("netFee1:" + netFee1); + logger.info("energyUsageTotal1:" + energyUsageTotal1); + + Account infoafter1 = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter1 = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance1 = infoafter1.getBalance(); + Long afterEnergyUsed1 = resourceInfoafter1.getEnergyUsed(); + Long afterNetUsed1 = resourceInfoafter1.getNetUsed(); + Long afterFreeNetUsed1 = resourceInfoafter1.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance1); + logger.info("afterEnergyUsed:" + afterEnergyUsed1); + logger.info("afterNetUsed:" + afterNetUsed1); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed1); + + Assert.assertTrue(infoById1.get().getResultValue() == 0); + Assert.assertTrue(afterBalance1 + fee1 == afterBalance); + Assert.assertTrue(afterEnergyUsed + energyUsed1 >= afterEnergyUsed1); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById1.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + } + + + @Test(enabled = true, description = "Deploy Factory contract, create2 with salt type : uint8") + public void testTriggerContract1() { + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String contractName1 = "TestConstract"; + String filePath = "src/test/resources/soliditycode/create2contract22.sol"; + HashMap retMap1 = PublicMethed.getBycodeAbi(filePath, contractName1); + String code1 = retMap1.get("byteCode").toString(); + String abi1 = retMap1.get("abI").toString(); + String txid = ""; + String num = "\"" + code1 + "\"" + "," + 1000001; + txid = PublicMethed + .triggerContract(contractAddress, + "deploy1(bytes,uint8)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + byte[] returnAddressBytes = infoById.get().getInternalTransactions(0).getTransferToAddress() + .toByteArray(); + String returnAddress = Base58.encode58Check(returnAddressBytes); + logger.info("returnAddress:" + returnAddress); + txid = PublicMethed + .triggerContract(returnAddressBytes, + "i()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById1 = null; + infoById1 = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee1 = infoById1.get().getFee(); + Long netUsed1 = infoById1.get().getReceipt().getNetUsage(); + Long energyUsed1 = infoById1.get().getReceipt().getEnergyUsage(); + Long netFee1 = infoById1.get().getReceipt().getNetFee(); + long energyUsageTotal1 = infoById1.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee1:" + fee1); + logger.info("netUsed1:" + netUsed1); + logger.info("energyUsed1:" + energyUsed1); + logger.info("netFee1:" + netFee1); + logger.info("energyUsageTotal1:" + energyUsageTotal1); + + Account infoafter1 = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter1 = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance1 = infoafter1.getBalance(); + Long afterEnergyUsed1 = resourceInfoafter1.getEnergyUsed(); + Long afterNetUsed1 = resourceInfoafter1.getNetUsed(); + Long afterFreeNetUsed1 = resourceInfoafter1.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance1); + logger.info("afterEnergyUsed:" + afterEnergyUsed1); + logger.info("afterNetUsed:" + afterNetUsed1); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed1); + + Assert.assertTrue(infoById1.get().getResultValue() == 0); + Assert.assertTrue(afterBalance1 + fee1 == afterBalance); + Assert.assertTrue(afterEnergyUsed + energyUsed1 >= afterEnergyUsed1); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById1.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + + } + + + @Test(enabled = true, description = "Deploy Factory contract, create2 with salt type : address") + public void testTriggerContract2() { + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String contractName1 = "TestConstract"; + String filePath = "src/test/resources/soliditycode/create2contract22.sol"; + HashMap retMap1 = PublicMethed.getBycodeAbi(filePath, contractName1); + String code1 = retMap1.get("byteCode").toString(); + String abi1 = retMap1.get("abI").toString(); + String txid = ""; + String num = "\"" + code1 + "\"" + ",\"" + Base58.encode58Check(contractExcAddress) + "\""; + txid = PublicMethed + .triggerContract(contractAddress, + "deploy2(bytes,address)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + byte[] returnAddressBytes = infoById.get().getInternalTransactions(0).getTransferToAddress() + .toByteArray(); + String returnAddress = Base58.encode58Check(returnAddressBytes); + logger.info("returnAddress:" + returnAddress); + txid = PublicMethed + .triggerContract(returnAddressBytes, + "i()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById1 = null; + infoById1 = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee1 = infoById1.get().getFee(); + Long netUsed1 = infoById1.get().getReceipt().getNetUsage(); + Long energyUsed1 = infoById1.get().getReceipt().getEnergyUsage(); + Long netFee1 = infoById1.get().getReceipt().getNetFee(); + long energyUsageTotal1 = infoById1.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee1:" + fee1); + logger.info("netUsed1:" + netUsed1); + logger.info("energyUsed1:" + energyUsed1); + logger.info("netFee1:" + netFee1); + logger.info("energyUsageTotal1:" + energyUsageTotal1); + + Account infoafter1 = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter1 = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance1 = infoafter1.getBalance(); + Long afterEnergyUsed1 = resourceInfoafter1.getEnergyUsed(); + Long afterNetUsed1 = resourceInfoafter1.getNetUsed(); + Long afterFreeNetUsed1 = resourceInfoafter1.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance1); + logger.info("afterEnergyUsed:" + afterEnergyUsed1); + logger.info("afterNetUsed:" + afterNetUsed1); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed1); + + Assert.assertTrue(infoById1.get().getResultValue() == 0); + Assert.assertTrue(afterBalance1 + fee1 == afterBalance); + Assert.assertTrue(afterEnergyUsed + energyUsed1 >= afterEnergyUsed1); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById1.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + + } + + + @Test(enabled = true, description = "Deploy Factory contract, create2 with salt type : string") + public void testTriggerContract3() { + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String contractName1 = "TestConstract"; + String filePath = "src/test/resources/soliditycode/create2contract22.sol"; + HashMap retMap1 = PublicMethed.getBycodeAbi(filePath, contractName1); + String code1 = retMap1.get("byteCode").toString(); + String abi1 = retMap1.get("abI").toString(); + String txid = ""; + String num = "\"" + code1 + "\"" + ",\"" + Base58.encode58Check(contractExcAddress) + "\""; + txid = PublicMethed + .triggerContract(contractAddress, + "deploy3(bytes,string)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + byte[] returnAddressBytes = infoById.get().getInternalTransactions(0).getTransferToAddress() + .toByteArray(); + String returnAddress = Base58.encode58Check(returnAddressBytes); + logger.info("returnAddress:" + returnAddress); + txid = PublicMethed + .triggerContract(returnAddressBytes, + "i()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById1 = null; + infoById1 = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee1 = infoById1.get().getFee(); + Long netUsed1 = infoById1.get().getReceipt().getNetUsage(); + Long energyUsed1 = infoById1.get().getReceipt().getEnergyUsage(); + Long netFee1 = infoById1.get().getReceipt().getNetFee(); + long energyUsageTotal1 = infoById1.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee1:" + fee1); + logger.info("netUsed1:" + netUsed1); + logger.info("energyUsed1:" + energyUsed1); + logger.info("netFee1:" + netFee1); + logger.info("energyUsageTotal1:" + energyUsageTotal1); + + Account infoafter1 = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter1 = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance1 = infoafter1.getBalance(); + Long afterEnergyUsed1 = resourceInfoafter1.getEnergyUsed(); + Long afterNetUsed1 = resourceInfoafter1.getNetUsed(); + Long afterFreeNetUsed1 = resourceInfoafter1.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance1); + logger.info("afterEnergyUsed:" + afterEnergyUsed1); + logger.info("afterNetUsed:" + afterNetUsed1); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed1); + + Assert.assertTrue(infoById1.get().getResultValue() == 0); + Assert.assertTrue(afterBalance1 + fee1 == afterBalance); + Assert.assertTrue(afterEnergyUsed + energyUsed1 >= afterEnergyUsed1); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById1.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + + } + + + @Test(enabled = true, description = "TriggerContract a constant function created by create2") + public void testTriggerContract4() { + Account info; + Assert.assertTrue(PublicMethed + .sendcoin(contractAddress, 1000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String contractName1 = "TestConstract1"; + String filePath = "src/test/resources/soliditycode/create2contract22.sol"; + HashMap retMap1 = PublicMethed.getBycodeAbi(filePath, contractName1); + String code1 = retMap1.get("byteCode").toString(); + String abi1 = retMap1.get("abI").toString(); + String txid = ""; + String num = "\"" + code1 + "\"" + ",\"" + Base58.encode58Check(contractAddress) + "\""; + txid = PublicMethed + .triggerContract(contractAddress, + "deploy3(bytes,string)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + byte[] returnAddressBytes = infoById.get().getInternalTransactions(0).getTransferToAddress() + .toByteArray(); + String returnAddress = Base58.encode58Check(returnAddressBytes); + logger.info("returnAddress:" + returnAddress); + txid = PublicMethed + .triggerContract(returnAddressBytes, + "i()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById1 = null; + infoById1 = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee1 = infoById1.get().getFee(); + Long netUsed1 = infoById1.get().getReceipt().getNetUsage(); + Long energyUsed1 = infoById1.get().getReceipt().getEnergyUsage(); + Long netFee1 = infoById1.get().getReceipt().getNetFee(); + long energyUsageTotal1 = infoById1.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee1:" + fee1); + logger.info("netUsed1:" + netUsed1); + logger.info("energyUsed1:" + energyUsed1); + logger.info("netFee1:" + netFee1); + logger.info("energyUsageTotal1:" + energyUsageTotal1); + + Account infoafter1 = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter1 = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance1 = infoafter1.getBalance(); + Long afterEnergyUsed1 = resourceInfoafter1.getEnergyUsed(); + Long afterNetUsed1 = resourceInfoafter1.getNetUsed(); + Long afterFreeNetUsed1 = resourceInfoafter1.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance1); + logger.info("afterEnergyUsed:" + afterEnergyUsed1); + logger.info("afterNetUsed:" + afterNetUsed1); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed1); + + Assert.assertTrue(infoById1.get().getResultValue() == 0); + Assert.assertTrue(afterBalance1 + fee1 == afterBalance); + Assert.assertTrue(afterEnergyUsed + energyUsed1 >= afterEnergyUsed1); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById1.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(2 == returnnumber); + + txid = PublicMethed + .triggerContract(contractAddress, + "deploy3(bytes,string)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional infoById2 = null; + infoById2 = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + + Assert.assertTrue(infoById2.get().getResultValue() != 0); + Assert + .assertThat(ByteArray + .toStr(infoById2.get().getResMessage().toByteArray()), + containsString("Not enough energy")); + } + + + @Test(enabled = true, description = "TriggerContract a constant function created by create2") + public void testTriggerContract5() { + + Account info; + Assert.assertTrue(PublicMethed + .sendcoin(contractAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String contractName1 = "TestConstract2"; + String filePath = "src/test/resources/soliditycode/create2contract22.sol"; + HashMap retMap1 = PublicMethed.getBycodeAbi(filePath, contractName1); + String code1 = retMap1.get("byteCode").toString(); + String abi1 = retMap1.get("abI").toString(); + String txid = ""; + String num = "\"" + code1 + "\"" + ",\"" + Base58.encode58Check(contractAddress) + "\""; + txid = PublicMethed + .triggerContract(contractAddress, + "deploy3(bytes,string)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + byte[] returnAddressBytes = infoById.get().getInternalTransactions(0).getTransferToAddress() + .toByteArray(); + String returnAddress = Base58.encode58Check(returnAddressBytes); + logger.info("returnAddress:" + returnAddress); + txid = PublicMethed + .triggerContract(returnAddressBytes, + "i()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById1 = null; + infoById1 = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee1 = infoById1.get().getFee(); + Long netUsed1 = infoById1.get().getReceipt().getNetUsage(); + Long energyUsed1 = infoById1.get().getReceipt().getEnergyUsage(); + Long netFee1 = infoById1.get().getReceipt().getNetFee(); + long energyUsageTotal1 = infoById1.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee1:" + fee1); + logger.info("netUsed1:" + netUsed1); + logger.info("energyUsed1:" + energyUsed1); + logger.info("netFee1:" + netFee1); + logger.info("energyUsageTotal1:" + energyUsageTotal1); + + Account infoafter1 = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter1 = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance1 = infoafter1.getBalance(); + Long afterEnergyUsed1 = resourceInfoafter1.getEnergyUsed(); + Long afterNetUsed1 = resourceInfoafter1.getNetUsed(); + Long afterFreeNetUsed1 = resourceInfoafter1.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance1); + logger.info("afterEnergyUsed:" + afterEnergyUsed1); + logger.info("afterNetUsed:" + afterNetUsed1); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed1); + + Assert.assertTrue(infoById1.get().getResultValue() == 0); + Assert.assertTrue(afterBalance1 + fee1 == afterBalance); + Assert.assertTrue(afterEnergyUsed + energyUsed1 >= afterEnergyUsed1); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById1.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(3 == returnnumber); + num = "\"" + code1 + "\"" + ",\"" + Base58.encode58Check(testNetAccountAddress) + "\""; + + txid = PublicMethed + .triggerContract(contractAddress, + "deploy3(bytes,string)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional infoById2 = null; + infoById2 = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + + Assert.assertTrue(infoById2.get().getResultValue() != 0); + Assert + .assertThat(ByteArray + .toStr(infoById2.get().getResMessage().toByteArray()), + containsString("Not enough energy")); + } + + + @Test(enabled = true, description = "TriggerContract a constant function created by create2") + public void testTriggerContract6() { + + Account info; + Assert.assertTrue(PublicMethed + .sendcoin(contractAddress, 1000000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String contractName1 = "TestConstract3"; + String filePath = "src/test/resources/soliditycode/create2contract22.sol"; + HashMap retMap1 = PublicMethed.getBycodeAbi(filePath, contractName1); + String code1 = retMap1.get("byteCode").toString(); + String abi1 = retMap1.get("abI").toString(); + String txid = ""; + String num = "\"" + code1 + "\"" + ",\"" + Base58.encode58Check(contractAddress) + "\""; + txid = PublicMethed + .triggerContract(contractAddress, + "deploy3(bytes,string)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + byte[] returnAddressBytes = infoById.get().getInternalTransactions(0).getTransferToAddress() + .toByteArray(); + String returnAddress = Base58.encode58Check(returnAddressBytes); + logger.info("returnAddress:" + returnAddress); + txid = PublicMethed + .triggerContract(returnAddressBytes, + "i()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById1 = null; + infoById1 = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee1 = infoById1.get().getFee(); + Long netUsed1 = infoById1.get().getReceipt().getNetUsage(); + Long energyUsed1 = infoById1.get().getReceipt().getEnergyUsage(); + Long netFee1 = infoById1.get().getReceipt().getNetFee(); + long energyUsageTotal1 = infoById1.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee1:" + fee1); + logger.info("netUsed1:" + netUsed1); + logger.info("energyUsed1:" + energyUsed1); + logger.info("netFee1:" + netFee1); + logger.info("energyUsageTotal1:" + energyUsageTotal1); + + Account infoafter1 = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter1 = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance1 = infoafter1.getBalance(); + Long afterEnergyUsed1 = resourceInfoafter1.getEnergyUsed(); + Long afterNetUsed1 = resourceInfoafter1.getNetUsed(); + Long afterFreeNetUsed1 = resourceInfoafter1.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance1); + logger.info("afterEnergyUsed:" + afterEnergyUsed1); + logger.info("afterNetUsed:" + afterNetUsed1); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed1); + + Assert.assertTrue(infoById1.get().getResultValue() == 0); + Assert.assertTrue(afterBalance1 + fee1 == afterBalance); + Assert.assertTrue(afterEnergyUsed + energyUsed1 >= afterEnergyUsed1); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById1.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(4 == returnnumber); + String fakeAddress = "FFFFFFF"; + + num = "\"" + code1 + "\"" + ",\"" + fakeAddress + "\""; + + txid = PublicMethed + .triggerContract(contractAddress, + "deploy3(bytes,string)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional infoById2 = null; + infoById2 = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + + Assert.assertTrue(infoById2.get().getResultValue() != 0); + Assert + .assertThat(ByteArray + .toStr(infoById2.get().getResMessage().toByteArray()), + containsString("Not enough energy")); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test021.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test021.java new file mode 100644 index 00000000000..52e5a104f02 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test021.java @@ -0,0 +1,381 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test021 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] contractExcAddress = PublicMethed + .getFinalAddress("9fc9b78370cdeab1bc11ba5e387e5e4f205f17d1957b1bebf4ce6d0330a448a4"); + private String contractExcKey = + "9fc9b78370cdeab1bc11ba5e387e5e4f205f17d1957b1bebf4ce6d0330a448a4"; + byte[] bytes; + private static final long now = System.currentTimeMillis(); + private static final String name = "Asset008_" + Long.toString(now); + private static final long totalSupply = now; + String description = "just-test"; + String url = "https://github.com/tronprotocol/wallet-cli/"; + ByteString assetAccountId = null; + + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] resourceOnwerAddress = ecKey2.getAddress(); + String resourceOnwerKey = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + PublicMethed.printAddress(resourceOnwerKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + + } + + @Test(enabled = true, description = "TriggerContract a constant function created by create2") + public void test1TriggerContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + Assert.assertTrue(PublicMethed + .sendcoin(resourceOnwerAddress, 1000000000L + 1024000000L, testNetAccountAddress, + testNetAccountKey, + blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + //Create 3 the same name token. + Long start = System.currentTimeMillis() + 2000; + Long end = System.currentTimeMillis() + 1000000000; + Assert.assertTrue(PublicMethed.createAssetIssue(resourceOnwerAddress, + name, totalSupply, 1, 1, start, end, 1, description, url, + 2000L, 2000L, 1L, 1L, resourceOnwerKey, blockingStubFull)); + String filePath = "src/test/resources/soliditycode/create2contractn.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + bytes = ByteArray.fromHexString("416CED4D6BF0AE10676347961BEFB7F47A8664AE36"); + + String param2 = "\"" + Base58.encode58Check(contractExcAddress) + "\""; + String txidn = PublicMethed + .triggerContract(bytes, + "testSuicideNonexistentTarget(address)", param2, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Assert.assertTrue(PublicMethed + .sendcoin(bytes, 1000000L, contractExcAddress, contractExcKey, blockingStubFull)); + //Trigger contract to transfer trx and token. + Account getAssetIdFromAccount = PublicMethed + .queryAccount(resourceOnwerAddress, blockingStubFull); + assetAccountId = getAssetIdFromAccount.getAssetIssuedID(); + Long contractBeforeBalance = PublicMethed.queryAccount(bytes, blockingStubFull).getBalance(); + + Assert.assertTrue( + PublicMethed.transferAsset(bytes, assetAccountId.toByteArray(), 100, resourceOnwerAddress, + resourceOnwerKey, + blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account account1 = PublicMethed.queryAccount(bytes, blockingStubFull); + int typeValue1 = account1.getTypeValue(); + Assert.assertEquals(0, typeValue1); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(resourceOnwerAddress, 1000000L, 0, 0, + ByteString.copyFrom(bytes), resourceOnwerKey, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(resourceOnwerAddress, 1000000L, 0, 1, + ByteString.copyFrom(bytes), resourceOnwerKey, blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + final Long beforeExcAccountBalance = PublicMethed + .queryAccount(resourceOnwerAddress, blockingStubFull).getBalance(); + Assert.assertTrue(PublicMethed.getAccountResource(bytes, blockingStubFull).getNetLimit() > 0); + Assert + .assertTrue(PublicMethed.getAccountResource(bytes, blockingStubFull).getEnergyLimit() > 0); + + String contractName1 = "TestConstract"; + HashMap retMap1 = PublicMethed.getBycodeAbi(filePath, contractName1); + String code1 = "6080604052600160005534801561001557600080fd5b50d3801561002257600080fd5b50" + + "d2801561002f57600080fd5b506101fd8061003f6000396000f3fe60806040526004361061005b577" + + "c01000000000000000000000000000000000000000000000000000000006000350463040821fc8114" + + "61006057806317b6ad5b1461007f578063cc133e94146100b2578063e5aa3d58146100d5575b60008" + + "0fd5b61007d6004803603602081101561007657600080fd5b5035610116565b005b61007d60048036" + + "03602081101561009557600080fd5b503573ffffffffffffffffffffffffffffffffffffffff16610" + + "147565b61007d600480360360408110156100c857600080fd5b5080359060200135610160565b3480" + + "156100e157600080fd5b50d380156100ee57600080fd5b50d280156100fb57600080fd5b506101046" + + "101cb565b60408051918252519081900360200190f35b604051339082156108fc0290839060008181" + + "81858888f19350505050158015610143573d6000803e3d6000fd5b5050565b8073fffffffffffffff" + + "fffffffffffffffffffffffff16ff5b3382156108fc0283838015801561017657600080fd5b508067" + + "80000000000000001115801561018e57600080fd5b5080620f4240101580156101a157600080fd5b5" + + "0604051600081818185878a8ad09450505050501580156101c6573d6000803e3d6000fd5b50505056" + + "5b6000548156fea165627a7a72305820485b773c60fed3b76621350dd3da7ecf152a2d37ca02dc195" + + "d6f8a26aec196850029"; + String abi1 = retMap1.get("abI").toString(); + String txid = ""; + String num = "\"" + code1 + "\"" + "," + 1; + txid = PublicMethed + .triggerContract(contractAddress, + "deploy(bytes,uint256)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Assert.assertFalse(PublicMethed.freezeBalanceForReceiver(resourceOnwerAddress, 5000000L, 0, 0, + ByteString.copyFrom(bytes), resourceOnwerKey, blockingStubFull)); + Assert.assertFalse(PublicMethed.freezeBalanceForReceiver(resourceOnwerAddress, 5000000L, 0, 1, + ByteString.copyFrom(bytes), resourceOnwerKey, blockingStubFull)); + Long afterExcAccountBalance = PublicMethed.queryAccount(resourceOnwerAddress, blockingStubFull) + .getBalance(); + Assert.assertTrue(PublicMethed.getAccountResource(bytes, blockingStubFull).getNetLimit() == 0); + Assert + .assertTrue(PublicMethed.getAccountResource(bytes, blockingStubFull).getEnergyLimit() == 0); + logger.info("afterExcAccountBalance: " + afterExcAccountBalance); + logger.info("beforeExcAccountBalance:" + beforeExcAccountBalance); + + Assert.assertTrue(afterExcAccountBalance - beforeExcAccountBalance == 0); + + Assert.assertTrue(PublicMethed.unFreezeBalance(resourceOnwerAddress, resourceOnwerKey, + 0, bytes, blockingStubFull)); + Assert.assertTrue(PublicMethed.unFreezeBalance(resourceOnwerAddress, resourceOnwerKey, + 1, bytes, blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Long afterUnfreezeBalance = PublicMethed.queryAccount(resourceOnwerAddress, blockingStubFull) + .getBalance(); + Assert.assertTrue(afterUnfreezeBalance == beforeExcAccountBalance + 1000000L * 2); + + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + + byte[] returnAddressBytes = infoById.get().getInternalTransactions(0).getTransferToAddress() + .toByteArray(); + String returnAddress = Base58.encode58Check(returnAddressBytes); + Assert.assertEquals(Base58.encode58Check(bytes), returnAddress); + logger.info("returnAddress:" + returnAddress); + txid = PublicMethed + .triggerContract(returnAddressBytes, + "i()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById1 = null; + infoById1 = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee1 = infoById1.get().getFee(); + Long netUsed1 = infoById1.get().getReceipt().getNetUsage(); + Long energyUsed1 = infoById1.get().getReceipt().getEnergyUsage(); + Long netFee1 = infoById1.get().getReceipt().getNetFee(); + long energyUsageTotal1 = infoById1.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee1:" + fee1); + logger.info("netUsed1:" + netUsed1); + logger.info("energyUsed1:" + energyUsed1); + logger.info("netFee1:" + netFee1); + logger.info("energyUsageTotal1:" + energyUsageTotal1); + + Account infoafter1 = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter1 = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance1 = infoafter1.getBalance(); + Long afterEnergyUsed1 = resourceInfoafter1.getEnergyUsed(); + Long afterNetUsed1 = resourceInfoafter1.getNetUsed(); + Long afterFreeNetUsed1 = resourceInfoafter1.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance1); + logger.info("afterEnergyUsed:" + afterEnergyUsed1); + logger.info("afterNetUsed:" + afterNetUsed1); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed1); + + Assert.assertTrue(infoById1.get().getResultValue() == 0); + Assert.assertTrue(afterBalance1 + fee1 == afterBalance); + Assert.assertTrue(afterEnergyUsed + energyUsed1 >= afterEnergyUsed1); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById1.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + Account account = PublicMethed.queryAccount(returnAddressBytes, blockingStubFull); + int typeValue = account.getTypeValue(); + Assert.assertEquals(2, typeValue); + Assert.assertEquals(account.getBalance(), 1000000); + } + + @Test(enabled = true, description = "Create2 contract can transfer trx and token.") + public void test2TriggerContract() { + Account accountbefore = PublicMethed.queryAccount(bytes, blockingStubFull); + int typeValue = accountbefore.getTypeValue(); + Assert.assertEquals(2, typeValue); + long accountbeforeBalance = accountbefore.getBalance(); + Assert.assertEquals(accountbeforeBalance, 1000000); + Account contractExcAddressbefore = PublicMethed + .queryAccount(contractExcAddress, blockingStubFull); + long contractExcAddressbeforeBalance = contractExcAddressbefore.getBalance(); + + String num = "1"; + + String txid = PublicMethed + .triggerContract(bytes, + "testTransfer(uint256)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional transactionInfoById = PublicMethed + .getTransactionInfoById(txid, blockingStubFull); + Assert.assertTrue(transactionInfoById.get().getResultValue() == 0); + Long fee1 = transactionInfoById.get().getFee(); + + Account accountafter = PublicMethed.queryAccount(bytes, blockingStubFull); + long accountafterBalance = accountafter.getBalance(); + Assert.assertTrue(accountbeforeBalance - 1 == accountafterBalance); + + Account contractExcAddressafter = PublicMethed + .queryAccount(contractExcAddress, blockingStubFull); + long contractExcAddressafterBalance = contractExcAddressafter.getBalance(); + Assert.assertTrue(contractExcAddressbeforeBalance + 1 - fee1 == contractExcAddressafterBalance); + + num = "1" + ",\"" + assetAccountId.toStringUtf8() + "\""; + Long returnAddressBytesAccountCountBefore = PublicMethed + .getAssetIssueValue(bytes, assetAccountId, blockingStubFull); + Long contractExcAddressAccountCountBefore = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + String txid1 = PublicMethed + .triggerContract(bytes, + "testTransferToken(uint256,trcToken)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + Optional transactionInfoById1 = PublicMethed + .getTransactionInfoById(txid1, blockingStubFull); + Assert.assertTrue(transactionInfoById1.get().getResultValue() == 0); + Long returnAddressBytesAccountCountAfter = PublicMethed + .getAssetIssueValue(bytes, assetAccountId, blockingStubFull); + + Long contractExcAddressAccountCountAfter = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Assert.assertTrue( + returnAddressBytesAccountCountBefore - 1 == returnAddressBytesAccountCountAfter); + Assert.assertTrue( + contractExcAddressAccountCountBefore + 1 == contractExcAddressAccountCountAfter); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} \ No newline at end of file diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test023.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test023.java new file mode 100644 index 00000000000..99f313b910d --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test023.java @@ -0,0 +1,292 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import static org.hamcrest.core.StringContains.containsString; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test023 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + + public byte[] subByte(byte[] b, int off, int length) { + byte[] b1 = new byte[length]; + System.arraycopy(b, off, b1, 0, length); + return b1; + + } + + @Test(enabled = true, description = "Deploy factory contract") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 10000_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 10000_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/Create2Test023.sol"; + String contractName = "factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = true, description = "contract A new B contract,A suicide,contract B still exist") + public void test02TriggerTestContract() { + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "testCreate()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + + byte[] a = infoById.get().getContractResult(0).toByteArray(); + byte[] b = subByte(a, 11, 1); + byte[] c = subByte(a, 0, 11); + byte[] e = "41".getBytes(); + byte[] d = subByte(a, 12, 20); + + logger.info("a:" + ByteArray.toHexString(a)); + + logger.info("b:" + ByteArray.toHexString(b)); + logger.info("c:" + ByteArray.toHexString(c)); + + logger.info("d:" + ByteArray.toHexString(d)); + + logger.info("41" + ByteArray.toHexString(d)); + String exceptedResult = "41" + ByteArray.toHexString(d); + String realResult = ByteArray.toHexString(b); + Assert.assertEquals(realResult, "00"); + Assert.assertNotEquals(realResult, "41"); + + + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(exceptedResult)); + logger.info("B Address : " + addressFinal); + + //B Address is created by A, Trigger contract B + triggerTxid = PublicMethed.triggerContract(ByteArray.fromHexString(exceptedResult), + "test()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + Assert.assertEquals(infoById.get().getResultValue(),0); + Assert.assertEquals(ByteArray.toLong(infoById.get().getContractResult(0).toByteArray()),1); + Assert.assertEquals("SUCESS",infoById.get().getResult().toString()); + + + triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "kill()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + String note = ByteArray + .toStr(infoById.get().getInternalTransactions(0).getNote().toByteArray()); + + Assert.assertEquals(infoById.get().getResultValue(),0); + Assert.assertEquals("SUCESS",infoById.get().getResult().toString()); + Assert.assertEquals("suicide", note); + + + + triggerTxid = PublicMethed.triggerContract(ByteArray.fromHexString(exceptedResult), + "test()", "#", false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + Assert.assertEquals(infoById.get().getResultValue(),0); + Assert.assertEquals("SUCESS",infoById.get().getResult().toString()); + Assert.assertEquals(1,ByteArray.toInt(infoById.get().getContractResult(0).toByteArray())); + + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test024.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test024.java new file mode 100644 index 00000000000..307960819a3 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test024.java @@ -0,0 +1,277 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class Create2Test024 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + + public byte[] subByte(byte[] b, int off, int length) { + byte[] b1 = new byte[length]; + System.arraycopy(b, off, b1, 0, length); + return b1; + + } + + @Test(enabled = true, description = "Deploy factory contract") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 10000_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 10000_000_000L, fromAddress, + testKey002, blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/Create2Test024.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = true, description = "create2 not allowed create2 twice in function") + public void test02TriggerTestContract() { + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/Create2Test024.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + Long salt = 4L; + + String param = "\"" + testContractCode + "\"," + salt; + + String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + byte[] a = infoById.get().getContractResult(0).toByteArray(); + byte[] b = subByte(a, 11, 1); + byte[] c = subByte(a, 0, 11); + byte[] e = "41".getBytes(); + byte[] d = subByte(a, 12, 20); + + logger.info("a:" + ByteArray.toHexString(a)); + + logger.info("b:" + ByteArray.toHexString(b)); + logger.info("c:" + ByteArray.toHexString(c)); + + logger.info("d:" + ByteArray.toHexString(d)); + + logger.info("41" + ByteArray.toHexString(d)); + String exceptedResult = "41" + ByteArray.toHexString(d); + String realResult = ByteArray.toHexString(b); + Assert.assertEquals(realResult, "00"); + Assert.assertNotEquals(realResult, "41"); + + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(exceptedResult)); + logger.info("create2 Address : " + addressFinal); + + Assert.assertEquals(infoById.get().getResult().toString(), "SUCESS"); + Assert.assertEquals(infoById.get().getResultValue(), 0); + + triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy2(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + devEnergyLimitAfter = accountResource.getEnergyLimit(); + devEnergyUsageAfter = accountResource.getEnergyUsed(); + devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + userEnergyLimitAfter = accountResource.getEnergyLimit(); + userEnergyUsageAfter = accountResource.getEnergyUsed(); + userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + Assert.assertEquals(infoById.get().getResultValue(), 1); + Assert.assertEquals(infoById.get().getResult().toString(), "FAILED"); + Assert.assertThat(ByteArray.toStr(infoById.get().getResMessage().toByteArray()), + containsString("Not enough energy for 'SWAP1' operation executing: ")); + + + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test025.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test025.java new file mode 100644 index 00000000000..e63db5de9ef --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/create2/Create2Test025.java @@ -0,0 +1,272 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.create2; + +import static org.hamcrest.core.StringContains.containsString; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; +import zmq.socket.pubsub.Pub; + +@Slf4j +public class Create2Test025 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] testContractAddress = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = false, description = "Deploy factory contract") + public void test01DeployFactoryContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 10000_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 10000_000_000L, fromAddress, + testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/Create2Test025.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + code += "05"; + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = false, description = "create2 bytecode with parm") + public void test02TriggerTestContract() { + //Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + // PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + // blockingStubFull), 0, 1, + // ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + String filePath = "./src/test/resources/soliditycode/Create2Test025.sol"; + String contractName = "TestContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + testContractCode += "0000000000000000000000000000000000000000000000000000000000000005"; + Long salt = 4L; + + String param = "\"" + testContractCode + "\"," + salt; + + String triggerTxid = null; + triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "create2(bytes,uint256)", param, false, 0L, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + + String txid = PublicMethed.triggerContract(testContractAddress, + "getNum()", "#", false, 0L, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + Optional infoById2 = PublicMethed.getTransactionInfoById(txid, + blockingStubFull); + TransactionInfo transactionInfo2 = infoById2.get(); + final int Num = ByteArray.toInt(transactionInfo2.getContractResult(0).toByteArray()); + + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + userEnergyLimitAfter = accountResource.getEnergyLimit(); + userEnergyUsageAfter = accountResource.getEnergyUsed(); + userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + logger.info("NUM :" + Num); + Assert.assertEquals(infoById.get().getResult().toString(),"SUCESS"); + Assert.assertEquals(infoById.get().getResultValue(),0); + Assert.assertEquals(5,Num); + + + + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest001.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest001.java new file mode 100644 index 00000000000..60ec980a7fb --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest001.java @@ -0,0 +1,689 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.extCodeHash; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.crypto.Hash; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ExtCodeHashTest001 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] extCodeHashContractAddress = null; + private byte[] testContractAddress = null; + private String testContractAddress2 = null; + + private String expectedCodeHash = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + private ECKey ecKey3 = new ECKey(Utils.getRandom()); + private byte[] testAddress = ecKey3.getAddress(); + private String testKey = ByteArray.toHexString(ecKey3.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = true, description = "Deploy extcodehash contract") + public void test01DeployExtCodeHashContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHash.sol"; + String contractName = "TestExtCodeHash"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + expectedCodeHash = ByteArray.toHexString(Hash.sha3(Hex.decode(code))); + logger.info("expectedCodeHash: " + expectedCodeHash); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + extCodeHashContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(extCodeHashContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = false, description = "Get the extcodehash of a normal address") + public void test02GetNormalAddressCodeHash() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String param = "\"" + Base58.encode58Check(dev001Address) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("transaction failed with message: " + + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info( + "the value: " + retList); + + Assert.assertEquals("C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", + retList.get(0)); + + } + + @Test(enabled = true, description = "Get a contract extcodehash") + public void test03GetContactCodeHash() { + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String param = "\"" + Base58.encode58Check(extCodeHashContractAddress) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + + Assert.assertFalse(retList.isEmpty()); + Assert.assertNotEquals("C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", + retList.get(0)); + Assert.assertNotEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + @Test(enabled = true, description = "Get a not exist account extcodehash") + public void test04GetNotExistAddressCodeHash() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String param = "\"" + Base58.encode58Check(testAddress) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info( + "the value: " + retList); + + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + + SmartContract smartContract = PublicMethed + .getContract(extCodeHashContractAddress, blockingStubFull); + logger.info(smartContract.getBytecode().toStringUtf8()); + } + + @Test(enabled = true, description = "Active the account and get extcodehash again") + public void test05ActiveAccountGetCodeHash() { + + Assert.assertTrue(PublicMethed.sendcoin(testAddress, 1000000, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String param = "\"" + Base58.encode58Check(testAddress) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + + Assert.assertEquals("C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", + retList.get(0)); + + SmartContract smartContract = PublicMethed + .getContract(extCodeHashContractAddress, blockingStubFull); + logger.info(smartContract.getBytecode().toStringUtf8()); + + } + + @Test(enabled = true, description = "Get a not deployed create2 extcodehash") + public void test06GetCreate2CodeHash() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHash.sol"; + String contractName = "TestExtCodeHash"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + final String abi = retMap.get("abI").toString(); + + Long salt = 100L; + String[] parameter = {Base58.encode58Check(user001Address), code, salt.toString()}; + logger.info(PublicMethed.create2(parameter)); + testContractAddress2 = PublicMethed.create2(parameter); + + Long callValue = Long.valueOf(0); + + String param = "\"" + + Base58.encode58Check(WalletClient.decodeFromBase58Check(testContractAddress2)) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info( + "the value: " + retList); + + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + + /*PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull);*/ + } + + @Test(enabled = true, description = "Get the EXTCODEHASH of an account created " + + "in the current transaction") + public void test07DeployExtCodeHashContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHashConstruct.sol"; + String contractName = "CounterConstruct"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + extCodeHashContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(extCodeHashContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getTopics(0).toByteArray()); + + logger.info("the value: " + retList); + + Assert.assertFalse(retList.isEmpty()); + Assert.assertNotEquals("C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", + retList.get(0)); + Assert.assertNotEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest002.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest002.java new file mode 100644 index 00000000000..eb3c733a7f1 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest002.java @@ -0,0 +1,246 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.extCodeHash; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.junit.runners.AllTests; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ExtCodeHashTest002 { + private final boolean AllTest = false; + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] extCodeHashContractAddress = null; + private byte[] testContractAddress = null; + + private String expectedCodeHash = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = AllTest, description = "Deploy extcodehash contract") + public void test01DeployExtCodeHashContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHash.sol"; + String contractName = "TestExtCodeHash"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + extCodeHashContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(extCodeHashContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = AllTest, description = "Get a contract extcodehash") + public void test02GetContactCodeHash() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String param = "\"" + Base58.encode58Check(extCodeHashContractAddress) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + + Assert.assertFalse(retList.isEmpty()); + Assert.assertNotEquals("C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", + retList.get(0)); + Assert.assertNotEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest003.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest003.java new file mode 100644 index 00000000000..3135f1d6fbc --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest003.java @@ -0,0 +1,336 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.extCodeHash; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ExtCodeHashTest003 { + + private final boolean AllTest = false; + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] extCodeHashContractAddress = null; + private byte[] testContractAddress = null; + + private String expectedCodeHash = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + private ECKey ecKey3 = new ECKey(Utils.getRandom()); + private byte[] testAddress = ecKey3.getAddress(); + private String testKey = ByteArray.toHexString(ecKey3.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = AllTest, description = "Deploy extcodehash contract") + public void test01DeployExtCodeHashContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHash.sol"; + String contractName = "TestExtCodeHash"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + extCodeHashContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(extCodeHashContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = AllTest, description = "Get a not exist account extcodehash") + public void test02GetNotExistAddressCodeHash() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String param = "\"" + Base58.encode58Check(testAddress) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info( + "the value: " + retList); + + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + + SmartContract smartContract = PublicMethed + .getContract(extCodeHashContractAddress, blockingStubFull); + logger.info(smartContract.getBytecode().toStringUtf8()); + } + + @Test(enabled = AllTest, description = "Active the account and get extcodehash again") + public void test03ActiveAccountGetCodeHash() { + + Assert.assertTrue(PublicMethed.sendcoin(testAddress, 1000000, fromAddress, + testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String param = "\"" + Base58.encode58Check(testAddress) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + + Assert.assertEquals("C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", + retList.get(0)); + + SmartContract smartContract = PublicMethed + .getContract(extCodeHashContractAddress, blockingStubFull); + logger.info(smartContract.getBytecode().toStringUtf8()); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest004.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest004.java new file mode 100644 index 00000000000..eb60051b1fb --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest004.java @@ -0,0 +1,255 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.extCodeHash; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.crypto.Hash; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ExtCodeHashTest004 { + + private final boolean AllTest = false; + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] extCodeHashContractAddress = null; + private String testContractAddress = null; + + private String expectedCodeHash = null; + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = AllTest, description = "Deploy extcodehash contract") + public void test01DeployExtCodeHashContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHash.sol"; + String contractName = "TestExtCodeHash"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + final String abi = retMap.get("abI").toString(); + + expectedCodeHash = ByteArray.toHexString(Hash.sha3(Hex.decode(code))); + logger.info("expectedCodeHash: " + expectedCodeHash); + + Long salt = 100L; + String[] parameter = {Base58.encode58Check(user001Address), code, salt.toString()}; + logger.info(PublicMethed.create2(parameter)); + testContractAddress = PublicMethed.create2(parameter); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + extCodeHashContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(extCodeHashContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = AllTest, description = "Get a not deployed create2 extcodehash") + public void test02GetCreate2CodeHash() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String param = + "\"" + Base58.encode58Check(WalletClient.decodeFromBase58Check(testContractAddress)) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info( + "the value: " + retList); + + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest005.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest005.java new file mode 100644 index 00000000000..15edc1d6140 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest005.java @@ -0,0 +1,716 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.extCodeHash; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.math.BigInteger; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.runtime.vm.DataWord; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ExtCodeHashTest005 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] extCodeHashContractAddress = null; + private byte[] testContractAddress = null; + + private String contractCodeHash = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + private ECKey ecKey3 = new ECKey(Utils.getRandom()); + private byte[] testAddress = ecKey3.getAddress(); + private String testKey = ByteArray.toHexString(ecKey3.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + + String fakeAddress = ""; + + logger.info("realAddress: " + fakeAddress); + byte[] fullHexAddr = new DataWord(fakeAddress).getData(); + logger.info("fullHexAddr ++= " + Hex.toHexString(fullHexAddr)); + + fakeAddress = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"; + + logger.info("realAddress: " + fakeAddress); + fullHexAddr = new DataWord(fakeAddress).getData(); + logger.info("fullHexAddr ++= " + Hex.toHexString(fullHexAddr)); + + } + + @Test(enabled = true, description = "Deploy extcodehash contract") + public void test01DeployExtCodeHashContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHash.sol"; + String contractName = "TestExtCodeHash"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + extCodeHashContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(extCodeHashContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = true, description = "Get codehash of a real contract by uint") + public void test02GetContractCodeHash() { + + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String testAddress = ByteArray.toHexString(extCodeHashContractAddress); + logger.info("realAddress: " + testAddress); + byte[] fullHexAddr = new DataWord(testAddress).getData(); + + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByUint(uint256)", Hex.toHexString(fullHexAddr), true, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + + Assert.assertFalse(retList.isEmpty()); + Assert.assertNotEquals("C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", + retList.get(0)); + Assert.assertNotEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + + contractCodeHash = retList.get(0); + + SmartContract smartContract = PublicMethed + .getContract(extCodeHashContractAddress, blockingStubFull); + logger.info(smartContract.getBytecode().toStringUtf8()); + } + + @Test(enabled = true, description = "Get codehash of a fake address by uint") + public void test03GetInvalidAddressCodeHash() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String fakeAddress = "41660757B2543F4849D3F42B90F58DE1C14C7E0038"; + logger.info("realAddress: " + fakeAddress); + byte[] fullHexAddr = new DataWord(fakeAddress).getData(); + + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByUint(uint256)", Hex.toHexString(fullHexAddr), true, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + + Assert.assertFalse(retList.isEmpty()); + + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + + SmartContract smartContract = PublicMethed + .getContract(extCodeHashContractAddress, blockingStubFull); + logger.info(smartContract.getBytecode().toStringUtf8()); + } + + @Test(enabled = true, description = "Get codehash of a normal account by uint") + public void test04GetNormalAddressCodeHash() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String fakeAddress = ByteArray.toHexString(user001Address); + logger.info("realAddress: " + fakeAddress); + byte[] fullHexAddr = new DataWord(fakeAddress).getData(); + + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByUint(uint256)", Hex.toHexString(fullHexAddr), true, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + Assert.assertFalse(retList.isEmpty()); + + Assert.assertEquals("C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", + retList.get(0)); + + SmartContract smartContract = PublicMethed + .getContract(extCodeHashContractAddress, blockingStubFull); + logger.info(smartContract.getBytecode().toStringUtf8()); + } + + @Test(enabled = true, description = "Get codehash of a empty address by uint") + public void test05GetEmptyAddressCodeHash() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String fakeAddress = ""; + + logger.info("realAddress: " + fakeAddress); + byte[] fullHexAddr = new DataWord(fakeAddress).getData(); + logger.info("fullHexAddr ++= " + Hex.toHexString(fullHexAddr)); + + + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByUint(uint256)", Hex.toHexString(fullHexAddr), true, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + Assert.assertFalse(retList.isEmpty()); + + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + + SmartContract smartContract = PublicMethed + .getContract(extCodeHashContractAddress, blockingStubFull); + logger.info(smartContract.getBytecode().toStringUtf8()); + } + + @Test(enabled = true, description = "Get codehash of a fffffff*64 address by uint") + public void test06GetFakeAddressCodeHash() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String fakeAddress = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"; + + logger.info("realAddress: " + fakeAddress); + byte[] fullHexAddr = new DataWord(fakeAddress).getData(); + logger.info("fullHexAddr ++= " + Hex.toHexString(fullHexAddr)); + + + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByUint(uint256)", Hex.toHexString(fullHexAddr), true, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + Assert.assertFalse(retList.isEmpty()); + + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + + SmartContract smartContract = PublicMethed + .getContract(extCodeHashContractAddress, blockingStubFull); + logger.info(smartContract.getBytecode().toStringUtf8()); + } + + @Test(enabled = true, description = "Get codehash of a real contract plus 2**160 by uint") + public void test07GetContractAddress96CodeHash() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + BigInteger bigIntAddr = new DataWord(extCodeHashContractAddress).sValue(); + String bigIntAddrChange = BigInteger.valueOf(2).pow(160).add(bigIntAddr).toString(16); + byte[] fullHexAddr = new DataWord(bigIntAddrChange).getData(); + + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByUint(uint256)", Hex.toHexString(fullHexAddr), true, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + Assert.assertFalse(retList.isEmpty()); + + // expect the code hash same + Assert.assertEquals(contractCodeHash, retList.get(0)); + + SmartContract smartContract = PublicMethed + .getContract(extCodeHashContractAddress, blockingStubFull); + logger.info(smartContract.getBytecode().toStringUtf8()); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest006.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest006.java new file mode 100644 index 00000000000..de1a2b185fc --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest006.java @@ -0,0 +1,184 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.extCodeHash; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ExtCodeHashTest006 { + private final boolean AllTest = false; + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] extCodeHashContractAddress = null; + private byte[] testContractAddress = null; + + private String expectedCodeHash = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + private ECKey ecKey3 = new ECKey(Utils.getRandom()); + private byte[] testAddress = ecKey3.getAddress(); + private String testKey = ByteArray.toHexString(ecKey3.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = AllTest, description = "Get the EXTCODEHASH of an account created " + + "in the current transaction") + public void test01DeployExtCodeHashContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHashConstruct.sol"; + String contractName = "CounterConstruct"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + extCodeHashContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(extCodeHashContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getTopics(0).toByteArray()); + + logger.info("the value: " + retList); + + Assert.assertFalse(retList.isEmpty()); + Assert.assertNotEquals("C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", + retList.get(0)); + Assert.assertNotEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest007.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest007.java new file mode 100644 index 00000000000..336744f4dee --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest007.java @@ -0,0 +1,616 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.extCodeHash; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ExtCodeHashTest007 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] testAddressOld = null; + private byte[] testAddressNew = null; + private byte[] testAddress2 = null; + private byte[] extCodeHashContractAddress = null; + + private String expectedCodeHash = null; + private String expectedCodeHashOld = null; + + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = true, description = "Deploy testNoPayable contract using old solidity") + public void test01DeployTestContractOld() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String contractName = "testExtHashContract"; + String code = "608060405234801561001057600080fd5b50d3801561001d57600080fd5b50d2801561002a576000" + + "80fd5b5060ef806100396000396000f30060806040526004361060485763ffffffff7c010000000000000000" + + "0000000000000000000000000000000000000000600035041663c518aa0f8114604d578063e5aa3d58146089" + + "575b600080fd5b348015605857600080fd5b50d38015606457600080fd5b50d28015607057600080fd5b5060" + + "7760b3565b60408051918252519081900360200190f35b348015609457600080fd5b50d3801560a057600080" + + "fd5b50d2801560ac57600080fd5b50607760bd565b6001600081905590565b600054815600a165627a7a7230" + + "5820766b4e2fca9081689cd89419411d2cbc5588a17a5c9fa900fd9cfe4b0d9652be0029"; + String abi = "[{\"constant\":false,\"inputs\":[],\"name\":\"testNoPayable\"," + + "\"outputs\":[{\"name\":\"z\",\"type\":\"uint256\"}],\"payable\":false," + + "\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true," + + "\"inputs\":[],\"name\":\"i\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}]," + + "\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"; + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + testAddressOld = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(testAddressOld, + blockingStubFull); + } + + @Test(enabled = true, description = "Deploy testNoPayable contract using new solidity") + public void test02DeployTestContractNew() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String contractName = "testConstantContract"; + String code = "608060405234801561001057600080fd5b50d3801561001d57600080fd5b50d2801561002a5760" + + "0080fd5b5060c5806100396000396000f3fe6080604052348015600f57600080fd5b50d38015601b576000" + + "80fd5b50d28015602757600080fd5b50600436106066577c01000000000000000000000000000000000000" + + "000000000000000000006000350463c518aa0f8114606b578063e5aa3d58146083575b600080fd5b607160" + + "89565b60408051918252519081900360200190f35b60716093565b6001600081905590565b6000548156fe" + + "a165627a7a723058205c5aadfbd06ea264db7b73e7b7f3c36ac64a9d520ba46b4bc7f1dc56252f17ac0029"; + String abi = "[{\"constant\":false,\"inputs\":[],\"name\":\"testNoPayable\",\"outputs\":[{\"" + + "name\":\"z\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable" + + "\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"i\",\"outputs\":" + + "[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"" + + "type\":\"function\"}]"; + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + testAddressNew = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(testAddressNew, + blockingStubFull); + } + + @Test(enabled = true, description = "Deploy extcodehash contract") + public void test03DeployExtCodeHashContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHash.sol"; + String contractName = "TestExtCodeHash"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + extCodeHashContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(extCodeHashContractAddress, + blockingStubFull); + } + + @Test(enabled = true, description = "Get contract code hash with old solidity") + public void test04GetTestOldCodeHash() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String param = "\"" + Base58.encode58Check(testAddressOld) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info( + "the value: " + retList); + + expectedCodeHashOld = retList.get(0); + Assert.assertEquals( + "B4AB5B9FF1A4FF7793E60EBFF0C769443AF66D0A6F9455AF145432CE8BA78175",expectedCodeHashOld); + Assert.assertFalse(retList.isEmpty()); + } + + @Test(enabled = true, description = "Get contract code hash with new solidity") + public void test05GetTestNewCodeHash() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String param = "\"" + Base58.encode58Check(testAddressNew) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + Assert.assertFalse(retList.isEmpty()); + + Assert.assertNotEquals(retList.get(0), expectedCodeHashOld); + expectedCodeHash = retList.get(0); + Assert.assertEquals( + "34DB53BD1F7214367E8D6B2A7A6FBBF0E3B7DDB4939ECADE4CDEF6749C27A2DA",expectedCodeHash); + } + + @Test(enabled = true, description = "Deploy contract using new solidity again") + public void test06DeployTest2Contract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String contractName = "testConstantContract"; + String code = "608060405234801561001057600080fd5b50d3801561001d57600080fd5b50d2801561002a5760" + + "0080fd5b5060c5806100396000396000f3fe6080604052348015600f57600080fd5b50d38015601b576000" + + "80fd5b50d28015602757600080fd5b50600436106066577c01000000000000000000000000000000000000" + + "000000000000000000006000350463c518aa0f8114606b578063e5aa3d58146083575b600080fd5b607160" + + "89565b60408051918252519081900360200190f35b60716093565b6001600081905590565b6000548156fe" + + "a165627a7a723058205c5aadfbd06ea264db7b73e7b7f3c36ac64a9d520ba46b4bc7f1dc56252f17ac0029"; + String abi = "[{\"constant\":false,\"inputs\":[],\"name\":\"testNoPayable\",\"outputs\":[{\"" + + "name\":\"z\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable" + + "\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"i\",\"outputs\":" + + "[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"" + + "type\":\"function\"}]"; + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + testAddress2 = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(testAddress2, + blockingStubFull); + } + + @Test(enabled = true, description = "Get contract code hash with test2") + public void test07GetTest2CodeHash() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String param = "\"" + Base58.encode58Check(testAddress2) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + Assert.assertFalse(retList.isEmpty()); + + Assert.assertEquals(expectedCodeHash, retList.get(0)); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest008.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest008.java new file mode 100644 index 00000000000..6ef73cdfb29 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest008.java @@ -0,0 +1,512 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.extCodeHash; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ExtCodeHashTest008 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] extCodeHashContractAddress = null; + private byte[] testContractAddress = null; + + private String expectedCodeHash = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = true, description = "Deploy extcodehash contract") + public void test01DeployExtCodeHashContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHash.sol"; + String contractName = "TestExtCodeHash"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + extCodeHashContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(extCodeHashContractAddress, + blockingStubFull); + } + + @Test(enabled = true, description = "Get code hash of create2 empty contract") + public void test02GetTestContractCodeHash() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + Long salt = 1L; + + String[] parameter = {Base58.encode58Check(user001Address), testContractCode, salt.toString()}; + logger.info(PublicMethed.create2(parameter)); + + Long callValue = Long.valueOf(0); + + String param = "\"" + PublicMethed.create2(parameter) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + + Assert.assertFalse(retList.isEmpty()); + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + } + + @Test(enabled = true, description = "Deploy factory contract") + public void test03DeployFactoryContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = true, description = "Trigger create2 function to deploy test contract") + public void test04TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = true, description = "Get code hash of test contract") + public void test05GetTestContractCodeHash() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String param = "\"" + Base58.encode58Check(testContractAddress) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + + Assert.assertFalse(retList.isEmpty()); + Assert.assertNotEquals("C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", + retList.get(0)); + Assert.assertNotEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest009.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest009.java new file mode 100644 index 00000000000..963ab54a07a --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest009.java @@ -0,0 +1,512 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.extCodeHash; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ExtCodeHashTest009 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] extCodeHashContractAddress = null; + private byte[] testContractAddress = null; + + private String expectedCodeHash = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = true, description = "Deploy extcodehash contract") + public void test01DeployExtCodeHashContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHash.sol"; + String contractName = "TestExtCodeHash"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + extCodeHashContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(extCodeHashContractAddress, + blockingStubFull); + } + + @Test(enabled = true, description = "Get code hash of create2 empty contract") + public void test02GetTestContractCodeHash() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + Long salt = 1L; + + String[] parameter = {Base58.encode58Check(user001Address), testContractCode, salt.toString()}; + logger.info(PublicMethed.create2(parameter)); + + Long callValue = Long.valueOf(0); + + String param = "\"" + PublicMethed.create2(parameter) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + + Assert.assertFalse(retList.isEmpty()); + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + } + + @Test(enabled = true, description = "Deploy factory contract") + public void test03DeployFactoryContract() { + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(dev001Address, dev001Key, 170000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, 10_000_000L, + 0, 0, ByteString.copyFrom(dev001Address), testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + factoryContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(factoryContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + @Test(enabled = true, description = "Trigger create2 function to deploy test contract") + public void test04TriggerCreate2ToDeployTestContract() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String filePath = "./src/test/resources/soliditycode/create2contract.sol"; + String contractName = "TestConstract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String testContractCode = retMap.get("byteCode").toString(); + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + final String triggerTxid = PublicMethed.triggerContract(factoryContractAddress, + "deploy(bytes,uint256)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger.info( + "the value: " + PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray())); + + List retList = PublicMethed + .getStrings(transactionInfo.getLogList().get(0).getData().toByteArray()); + + Long actualSalt = ByteArray.toLong(ByteArray.fromHexString(retList.get(1))); + + logger.info("actualSalt: " + actualSalt); + + byte[] tmpAddress = new byte[20]; + System.arraycopy(ByteArray.fromHexString(retList.get(0)), 12, tmpAddress, 0, 20); + String addressHex = "41" + ByteArray.toHexString(tmpAddress); + logger.info("address_hex: " + addressHex); + String addressFinal = Base58.encode58Check(ByteArray.fromHexString(addressHex)); + logger.info("address_final: " + addressFinal); + + testContractAddress = WalletClient.decodeFromBase58Check(addressFinal); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + SmartContract smartContract = PublicMethed.getContract(testContractAddress, blockingStubFull); + + // contract created by create2, doesn't have ABI + Assert.assertEquals(0, smartContract.getAbi().getEntrysCount()); + + // the contract owner of contract created by create2 is the factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(smartContract.getOriginAddress().toByteArray())); + + // the contract address in transaction info, + // contract address of create2 contract is factory contract + Assert.assertEquals(Base58.encode58Check(factoryContractAddress), + Base58.encode58Check(infoById.get().getContractAddress().toByteArray())); + } + + @Test(enabled = true, description = "Get code hash of test contract") + public void test05GetTestContractCodeHash() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + Long callValue = Long.valueOf(0); + + String param = "\"" + Base58.encode58Check(testContractAddress) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", param, false, callValue, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + + Assert.assertFalse(retList.isEmpty()); + Assert.assertNotEquals("C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", + retList.get(0)); + Assert.assertNotEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + dev001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 1, + user001Address, blockingStubFull); + PublicMethed.unFreezeBalance(fromAddress, testKey002, 0, + user001Address, blockingStubFull); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest010.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest010.java new file mode 100644 index 00000000000..dc32ba60c46 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest010.java @@ -0,0 +1,379 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.extCodeHash; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ExtCodeHashTest010 { + + final boolean AllTest = false; + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] factoryContractAddress = null; + private byte[] extCodeHashContractAddress = null; + private byte[] testContractAddress = null; + + private String expectedCodeHash = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = AllTest, description = "Deploy extcodehash contract") + public void test01DeployExtCodeHashContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/ExtCodeHashTest010.sol"; + String contractName = "Counter"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage()); + } + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + extCodeHashContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(extCodeHashContractAddress, + blockingStubFull); + } + + + @Test(enabled = AllTest, description = "The EXTCODEHASH of an account that selfdestructed in the " + + "current transaction. but later been revert") + public void test02GetTestContractCodeHash() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashRevert()", "#", false, 0L, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + + Assert.assertFalse(retList.isEmpty()); + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + } + + + @Test(enabled = AllTest, description = "The EXTCODEHASH of an account that create in the current " + + "transaction. but later been revert") + public void test03GetTestContractCodeHash() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashCreate()", "#", false, 0L, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + + Assert.assertFalse(retList.isEmpty()); + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + } + + @Test(enabled = AllTest, description = "The EXTCODEHASH of an account that selfdestructed in the" + + " current transaction.") + public void test04GetTestContractCodeHash() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long devEnergyLimitBefore = accountResource.getEnergyLimit(); + long devEnergyUsageBefore = accountResource.getEnergyUsed(); + long devBalanceBefore = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("before trigger, devEnergyLimitBefore is " + Long.toString(devEnergyLimitBefore)); + logger.info("before trigger, devEnergyUsageBefore is " + Long.toString(devEnergyUsageBefore)); + logger.info("before trigger, devBalanceBefore is " + Long.toString(devBalanceBefore)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitBefore = accountResource.getEnergyLimit(); + long userEnergyUsageBefore = accountResource.getEnergyUsed(); + long userBalanceBefore = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("before trigger, userEnergyLimitBefore is " + Long.toString(userEnergyLimitBefore)); + logger.info("before trigger, userEnergyUsageBefore is " + Long.toString(userEnergyUsageBefore)); + logger.info("before trigger, userBalanceBefore is " + Long.toString(userBalanceBefore)); + + + String param = "\"" + Base58.encode58Check(extCodeHashContractAddress) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashSuicide(address)", param, false, 0L, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + long devEnergyLimitAfter = accountResource.getEnergyLimit(); + long devEnergyUsageAfter = accountResource.getEnergyUsed(); + long devBalanceAfter = PublicMethed.queryAccount(dev001Address, blockingStubFull).getBalance(); + + logger.info("after trigger, devEnergyLimitAfter is " + Long.toString(devEnergyLimitAfter)); + logger.info("after trigger, devEnergyUsageAfter is " + Long.toString(devEnergyUsageAfter)); + logger.info("after trigger, devBalanceAfter is " + Long.toString(devBalanceAfter)); + + accountResource = PublicMethed.getAccountResource(user001Address, blockingStubFull); + long userEnergyLimitAfter = accountResource.getEnergyLimit(); + long userEnergyUsageAfter = accountResource.getEnergyUsed(); + long userBalanceAfter = PublicMethed.queryAccount(user001Address, blockingStubFull) + .getBalance(); + + logger.info("after trigger, userEnergyLimitAfter is " + Long.toString(userEnergyLimitAfter)); + logger.info("after trigger, userEnergyUsageAfter is " + Long.toString(userEnergyUsageAfter)); + logger.info("after trigger, userBalanceAfter is " + Long.toString(userBalanceAfter)); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info("the value: " + retList); + + Assert.assertFalse(retList.isEmpty()); + Assert.assertEquals("0000000000000000000000000000000000000000000000000000000000000000", + retList.get(0)); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest011.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest011.java new file mode 100644 index 00000000000..28c5fe7bde5 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/extCodeHash/ExtCodeHashTest011.java @@ -0,0 +1,369 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.extCodeHash; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.crypto.Hash; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ExtCodeHashTest011 { + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] extCodeHashContractAddress = null; + private byte[] testContractAddress = null; + + private String expectedCodeHash = null; + + private ECKey ecKey1 = new ECKey(Utils.getRandom()); + private byte[] dev001Address = ecKey1.getAddress(); + private String dev001Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + @Test(enabled = true, description = "Deploy extcodehash contract") + public void test01DeployExtCodeHashContract() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHash11.sol"; + String contractName = "Counter"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + expectedCodeHash = ByteArray.toHexString(Hash.sha3(Hex.decode(code))); + logger.info("expectedCodeHash: " + expectedCodeHash); + + String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + extCodeHashContractAddress = infoById.get().getContractAddress().toByteArray(); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + transferTokenTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr()", "#", false, 0, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + Assert.assertTrue(infoById.get().getResultValue() != 0); + Assert + .assertThat(ByteArray + .toStr(infoById.get().getResMessage().toByteArray()), + containsString("REVERT opcode executed")); + } + + + @Test(enabled = true, description = "Deploy extcodehash contract") + public void test01DeployExtCodeHashContract1() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHash11.sol"; + String contractName = "Counter1"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + expectedCodeHash = ByteArray.toHexString(Hash.sha3(Hex.decode(code))); + logger.info("expectedCodeHash: " + expectedCodeHash); + + String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + extCodeHashContractAddress = infoById.get().getContractAddress().toByteArray(); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + transferTokenTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr()", "#", false, 0, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info( + "the value: " + retList); + + Assert.assertEquals(retList.get(1), + retList.get(0)); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + extCodeHashContractAddress = infoById.get().getContractAddress().toByteArray(); + SmartContract smartContract = PublicMethed.getContract(extCodeHashContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + + @Test(enabled = true, description = "Deploy extcodehash contract") + public void test01DeployExtCodeHashContract2() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHash11.sol"; + String contractName = "Counter2"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + expectedCodeHash = ByteArray.toHexString(Hash.sha3(Hex.decode(code))); + logger.info("expectedCodeHash: " + expectedCodeHash); + + String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + extCodeHashContractAddress = infoById.get().getContractAddress().toByteArray(); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + String num = "\"" + Base58.encode58Check(dev001Address) + "\""; + + transferTokenTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", num, false, 0, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info( + "the value: " + retList); + Assert.assertEquals(retList.get(1), + retList.get(0)); + } + + + @Test(enabled = true, description = "Deploy extcodehash contract") + public void test01DeployExtCodeHashContract3() { + Assert.assertTrue(PublicMethed.sendcoin(dev001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHash11.sol"; + String contractName = "Counter2"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + expectedCodeHash = ByteArray.toHexString(Hash.sha3(Hex.decode(code))); + logger.info("expectedCodeHash: " + expectedCodeHash); + + String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + extCodeHashContractAddress = infoById.get().getContractAddress().toByteArray(); + + accountResource = PublicMethed.getAccountResource(dev001Address, blockingStubFull); + energyLimit = accountResource.getEnergyLimit(); + energyUsage = accountResource.getEnergyUsed(); + long balanceAfter = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + + logger.info("after energyLimit is " + Long.toString(energyLimit)); + logger.info("after energyUsage is " + Long.toString(energyUsage)); + logger.info("after balanceAfter is " + Long.toString(balanceAfter)); + + String num = "\"" + Base58.encode58Check(dev001Address) + "\""; + + transferTokenTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "getCodeHashByAddr(address)", num, false, 0, + 1000000000L, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + List retList = PublicMethed + .getStrings(transactionInfo.getContractResult(0).toByteArray()); + + logger.info( + "the value: " + retList); + Assert.assertEquals(retList.get(1), + retList.get(0)); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand001.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand001.java new file mode 100644 index 00000000000..5362d481943 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand001.java @@ -0,0 +1,264 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.shiftcommand; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ShiftCommand001 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + + @Test(enabled = true, description = "Trigger old ShiftLeft ShiftRight") + public void test1OldInstruction() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TvmOldCommand001.sol"; + String contractName = "binaryRightContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + String num = "1"; + txid = PublicMethed.triggerContract(contractAddress, + "binaryMoveR(int256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + txid = PublicMethed.triggerContract(contractAddress, + "binaryLiftR(int256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Assert.assertTrue(infoById.get().getResultValue() == 0); + + + } + + @Test(enabled = true, description = "Trigger new ShiftLeft ShiftRight ShiftRightSigned") + public void test2NewInstruction() { + String filePath = "src/test/resources/soliditycode/ShiftCommand001.sol"; + String contractName = "TestBitwiseShift"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + String num = "1" + "," + "5"; + + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + txid = PublicMethed.triggerContract(contractAddress, + "shlTest(uint256,uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertEquals(10,ByteArray.toInt(infoById.get().getContractResult(0).toByteArray())); + txid = PublicMethed.triggerContract(contractAddress, + "shrTest(uint256,uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertEquals(2,ByteArray.toInt(infoById.get().getContractResult(0).toByteArray())); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand002.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand002.java new file mode 100644 index 00000000000..eac053fb372 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand002.java @@ -0,0 +1,281 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.shiftcommand; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ShiftCommand002 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + + @Test(enabled = true, description = "OLd compiler compile shift instruction") + public void test1Oldcompile() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + String contractName = "TestBitwiseShift"; + String code = "608060405234801561001057600080fd5b50d3801561001d57600080fd5b50d2801561002a5" + + "7600080fd5b506101478061003a6000396000f3006080604052600436106100565763ffffffff7c0100" + + "000000000000000000000000000000000000000000000000000000600035041663614eb4da811461005" + + "b578063b5675d6d146100a2578063baf27c0c146100d7575b600080fd5b34801561006757600080fd5b" + + "50d3801561007457600080fd5b50d2801561008157600080fd5b5061009060043560243561010c565b6" + + "0408051918252519081900360200190f35b3480156100ae57600080fd5b50d380156100bb57600080fd" + + "5b50d280156100c857600080fd5b50610090600435602435610111565b3480156100e357600080fd5b5" + + "0d380156100f057600080fd5b50d280156100fd57600080fd5b50610090600435602435610116565b90" + + "1b90565b901d90565b901c905600a165627a7a723058200d5cc53ffdc6db62c4d7414d8b7d95c98218e" + + "50b4c1ea5961d527de1439733450029"; + String abi = "[{\"constant\":false,\"inputs\":[{\"name\":\"num\",\"type\":\"uint256\"}," + + "{\"name\":\"input\",\"type\":\"uint256\"}],\"name\":\"shlTest\",\"outputs\":" + + "[{\"name\":\"out\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":" + + "\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":" + + "\"num\",\"type\":\"uint256\"},{\"name\":\"input\",\"type\":\"uint256\"}],\"name" + + "\":\"sarTest\",\"outputs\":[{\"name\":\"out\",\"type\":\"bytes32\"}],\"payable" + + "\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant" + + "\":false,\"inputs\":[{\"name\":\"num\",\"type\":\"uint256\"},{\"name\":\"input\"" + + ",\"type\":\"uint256\"}],\"name\":\"shrTest\",\"outputs\":[{\"name\":\"out\",\"" + + "type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"" + + "type\":\"function\"}]"; + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + String num = "1" + "," + "5"; + + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + txid = PublicMethed.triggerContract(contractAddress, + "shlTest(uint256,uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Assert.assertTrue(infoById.get().getResultValue() == 0); + txid = PublicMethed.triggerContract(contractAddress, + "shrTest(uint256,uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Assert.assertTrue(infoById.get().getResultValue() == 0); + + } + + @Test(enabled = true, description = "New compiler compile shift instruction") + public void test2Newcompile() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + String filePath = "src/test/resources/soliditycode/ShiftCommand001.sol"; + String contractName = "TestBitwiseShift"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + String num = "1" + "," + "5"; + + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + txid = PublicMethed.triggerContract(contractAddress, + "shlTest(uint256,uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Assert.assertTrue(infoById.get().getResultValue() == 0); + txid = PublicMethed.triggerContract(contractAddress, + "shrTest(uint256,uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Assert.assertTrue(infoById.get().getResultValue() == 0); + + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand003.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand003.java new file mode 100644 index 00000000000..87e08eed76e --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand003.java @@ -0,0 +1,343 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.shiftcommand; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.DataWord; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ShiftCommand003 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "Trigger new ShiftLeft with displacement number too short ") + public void test1ShiftLeft() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + String filePath = "src/test/resources/soliditycode/ShiftCommand001.sol"; + String contractName = "TestBitwiseShift"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x01")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + logger.info("param:" + param); + String txid = ""; + txid = PublicMethed.triggerContract(contractAddress, + "shlTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + + @Test(enabled = true, description = "Trigger new ShiftRight with displacement number too short ") + public void test2ShiftRight() { + Account info; + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x01")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + logger.info("param:" + param); + String txid = ""; + txid = PublicMethed.triggerContract(contractAddress, + "shrTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("00007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + + @Test(enabled = true, description = "Trigger new ShiftRightSigned " + + "with displacement number too short ") + public void test3ShiftRightSigned() { + Account info; + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x01")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + logger.info("param:" + param); + String txid = ""; + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("00007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand004.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand004.java new file mode 100644 index 00000000000..49a16cfbae5 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand004.java @@ -0,0 +1,1051 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.shiftcommand; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.DataWord; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ShiftCommand004 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "Trigger new ShiftLeft,value is " + + "0x0000000000000000000000000000000000000000000000000000000000000001 and Displacement number" + + "is 0x00") + public void test1ShiftLeft() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + String filePath = "src/test/resources/soliditycode/ShiftCommand001.sol"; + String contractName = "TestBitwiseShift"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x00")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shlTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftLeft,value is " + + "0x0000000000000000000000000000000000000000000000000000000000000001 and Displacement number" + + "is 0x01") + public void test2ShiftLeft() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray + .fromHexString("0x01")) + .getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shlTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000002")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + + @Test(enabled = true, description = "Trigger new ShiftLeft,value is " + + "0x0000000000000000000000000000000000000000000000000000000000000001 and Displacement number" + + "is 0xff") + public void test3ShiftLeft() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray + .fromHexString("0xff")) + .getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shlTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x8000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + + @Test(enabled = true, description = "Trigger new ShiftLeft,value is " + + "0x0000000000000000000000000000000000000000000000000000000000000001 and Displacement number" + + "is 0x0100") + public void test4ShiftLeft() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x0100")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + txid = PublicMethed.triggerContract(contractAddress, + "shlTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftLeft,value is " + + "0x0000000000000000000000000000000000000000000000000000000000000001 and Displacement number" + + "is 0x0101") + public void test5ShiftLeft() { + Account info; + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x0101")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + txid = PublicMethed.triggerContract(contractAddress, + "shlTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftLeft,value is " + + "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0x00") + public void test6ShiftLeft() { + Account info; + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x00")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + txid = PublicMethed.triggerContract(contractAddress, + "shlTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftLeft,value is " + + "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0x01") + public void test7ShiftLeft() { + String filePath = "src/test/resources/soliditycode/ShiftCommand001.sol"; + String contractName = "TestBitwiseShift"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x01")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shlTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + + @Test(enabled = true, description = "Trigger new ShiftLeft,value is " + + "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0xff") + public void test8ShiftLeft() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0xff")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shlTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x8000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + + @Test(enabled = true, description = "Trigger new ShiftLeft,value is " + + "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0x0100") + public void test9ShiftLeft() { + + Account info; + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x0100")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shlTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + + @Test(enabled = true, description = "Trigger new ShiftLeft,value is " + + "0x0000000000000000000000000000000000000000000000000000000000000000 and Displacement number" + + "is 0x01") + public void testShiftLeft10() { + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x01")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shlTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftLeft,value is " + + "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0x01") + public void testShiftLeft11() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x01")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shlTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftLeft,value is " + + "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0x0101") + public void testShiftLeft12() { + + String filePath = "src/test/resources/soliditycode/TvmNewCommand043.sol"; + String contractName = "TestBitwiseShift"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x0101")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shlTest(int256,int256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand005.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand005.java new file mode 100644 index 00000000000..33291d18812 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand005.java @@ -0,0 +1,1060 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.shiftcommand; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.DataWord; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ShiftCommand005 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "Trigger new ShiftRight,value is " + + "0x0000000000000000000000000000000000000000000000000000000000000001 and Displacement number" + + "is 0x00") + public void test1ShiftRight() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 100000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + String filePath = "src/test/resources/soliditycode/ShiftCommand001.sol"; + String contractName = "TestBitwiseShift"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x00")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shrTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRight,value is " + + "0x0000000000000000000000000000000000000000000000000000000000000001 and Displacement number" + + "is 0x01") + public void test2ShiftRight() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x01")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shrTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRight,value is " + + "0x8000000000000000000000000000000000000000000000000000000000000000 and Displacement number" + + "is 0x01") + public void test3ShiftRight() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + String originNumber = String.valueOf(ByteArray.toLong(ByteArray + .fromHexString("0x8000000000000000000000000000000000000000000000000000000000000000"))); + String valueNumber = String.valueOf(ByteArray.toLong((ByteArray + .fromHexString("0x01")))); + String num = valueNumber + "," + originNumber; + + logger.info("returnnumber:" + originNumber); + logger.info("returnnumber1:" + valueNumber); + + txid = PublicMethed.triggerContract(contractAddress, + "shrTest(uint256,uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x4000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRight,value is " + + "0x8000000000000000000000000000000000000000000000000000000000000000 and Displacement number" + + "is 0xff") + public void test4ShiftRight() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x8000000000000000000000000000000000000000000000000000000000000000")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray + .fromHexString("0xff")) + .getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + txid = PublicMethed.triggerContract(contractAddress, + "shrTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + + @Test(enabled = true, description = "Trigger new ShiftRight,value is " + + "0x8000000000000000000000000000000000000000000000000000000000000000 and Displacement number" + + "is 0x0100") + public void test5ShiftRight() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x8000000000000000000000000000000000000000000000000000000000000000")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x0100")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shrTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRight,value is " + + "0x8000000000000000000000000000000000000000000000000000000000000000 and Displacement number" + + "is 0x0101") + public void test6ShiftRight() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x8000000000000000000000000000000000000000000000000000000000000000")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x0101")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shrTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRight,value is " + + "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0x00") + public void test7ShiftRight() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x00")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shrTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRight,value is " + + "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0x01") + public void test8ShiftRight() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x01")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shrTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRight,value is " + + "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0xff") + public void test9ShiftRight() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0xff")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shrTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRight,value is " + + "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0x0100") + public void testShiftRight10() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x0100")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shrTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRight,value is " + + "0x0000000000000000000000000000000000000000000000000000000000000000 and Displacement number" + + "is 0x01") + public void testShiftRight11() { + + String filePath = "src/test/resources/soliditycode/ShiftCommand001.sol"; + String contractName = "TestBitwiseShift"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x01")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shrTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + + @Test(enabled = true, description = "Trigger new ShiftRight,value is " + + "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0x0101") + public void testShiftRight12() { + + String filePath = "src/test/resources/soliditycode/TvmNewCommand043.sol"; + String contractName = "TestBitwiseShift"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x0101")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "shrTest(int256,int256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand006.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand006.java new file mode 100644 index 00000000000..80258809be0 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/shiftcommand/ShiftCommand006.java @@ -0,0 +1,1549 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.shiftcommand; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.DataWord; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ShiftCommand006 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0x0000000000000000000000000000000000000000000000000000000000000001 and Displacement number" + + "is 0x00") + public void test1ShiftRightSigned() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 100000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + String filePath = "src/test/resources/soliditycode/ShiftCommand001.sol"; + String contractName = "TestBitwiseShift"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x00")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0x0000000000000000000000000000000000000000000000000000000000000001 and Displacement number" + + "is 0x01") + public void test2ShiftRightSigned() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x01")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0x8000000000000000000000000000000000000000000000000000000000000000 and Displacement number" + + "is 0x01") + public void test3ShiftRightSigned() { + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x8000000000000000000000000000000000000000000000000000000000000000")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x01")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0xc000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0x8000000000000000000000000000000000000000000000000000000000000000 and Displacement number" + + "is 0xff") + public void test4ShiftRightSigned() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x8000000000000000000000000000000000000000000000000000000000000000")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray + .fromHexString("0xff")) + .getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0x8000000000000000000000000000000000000000000000000000000000000000 and Displacement number" + + "is 0x0100") + public void test5ShiftRightSigned() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x8000000000000000000000000000000000000000000000000000000000000000")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x0100")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0x8000000000000000000000000000000000000000000000000000000000000000 and Displacement number" + + "is 0x0101") + public void test6ShiftRightSigned() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x8000000000000000000000000000000000000000000000000000000000000000")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x0101")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0x00") + public void test7ShiftRightSigned() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray + .fromHexString("0x00")) + .getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + + } + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0x01") + public void test8ShiftRightSigned() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray + .fromHexString("0x01")) + .getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0xff") + public void test9ShiftRightSigned() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray + .fromHexString("0xff")) + .getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0x0100") + public void testShiftRightSigned10() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray + .fromHexString("0x0100")) + .getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0x0000000000000000000000000000000000000000000000000000000000000000 and Displacement number" + + "is 0x01") + public void testShiftRightSigned11() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray + .fromHexString("0x01")) + .getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0x4000000000000000000000000000000000000000000000000000000000000000 and Displacement number" + + "is 0xfe") + public void testShiftRightSigned12() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x4000000000000000000000000000000000000000000000000000000000000000")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray + .fromHexString("0xfe")) + .getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0xf8") + public void testShiftRightSigned13() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray + .fromHexString("0xf8")) + .getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x000000000000000000000000000000000000000000000000000000000000007f")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0xfe") + public void testShiftRightSigned14() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0xfe")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0xff") + public void testShiftRightSigned15() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0xff")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + + String param = Hex.toHexString(paramBytes); + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0x0100") + public void testShiftRightSigned16() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x0100")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + + String param = Hex.toHexString(paramBytes); + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(uint256,uint256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0x0101") + public void testShiftRightSigned17() { + + String filePath = "src/test/resources/soliditycode/TvmNewCommand043.sol"; + String contractName = "TestBitwiseShift"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray + .fromHexString("0x0101")) + .getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + String param = Hex.toHexString(paramBytes); + + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(int256,int256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber14 = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + @Test(enabled = true, description = "Trigger new ShiftRightSigned,value is " + + "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff and Displacement number" + + "is 0x0101") + public void testShiftRightSigned18() { + + String filePath = "src/test/resources/soliditycode/TvmNewCommand043.sol"; + String contractName = "TestBitwiseShift"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + byte[] originNumber = new DataWord( + ByteArray + .fromHexString("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + .getData(); + byte[] valueNumber = new DataWord( + ByteArray.fromHexString("0x0101")).getData(); + byte[] paramBytes = new byte[originNumber.length + valueNumber.length]; + System.arraycopy(valueNumber, 0, paramBytes, 0, valueNumber.length); + System.arraycopy(originNumber, 0, paramBytes, valueNumber.length, originNumber.length); + + String param = Hex.toHexString(paramBytes); + txid = PublicMethed.triggerContract(contractAddress, + "sarTest(int256,int256)", param, true, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + String returnString = (ByteArray + .toHexString(infoById.get().getContractResult(0).toByteArray())); + logger.info("returnString:" + returnString); + Assert.assertEquals(ByteArray.toLong(ByteArray + .fromHexString("0x0000000000000000000000000000000000000000000000000000000000000000")), + ByteArray.toLong(ByteArray + .fromHexString( + ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray())))); + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TestResourceReceiver.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TestResourceReceiver.java new file mode 100644 index 00000000000..697e8b22c02 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TestResourceReceiver.java @@ -0,0 +1,200 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.transferfailed; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TestResourceReceiver { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = false) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + + @Test(enabled = false, description = "Suicide existent Target") + public void test1SuicideExistentTarget() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TransferFailed001.sol"; + String contractName = "EnergyOfTransferFailedTest"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Assert.assertTrue(PublicMethed + .sendcoin(contractAddress, 3000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(testNetAccountAddress, + 1000000, 0, 1, + ByteString.copyFrom(contractAddress), testNetAccountKey, blockingStubFull)); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] existentAddress = ecKey2.getAddress(); + Assert.assertTrue(PublicMethed + .sendcoin(contractAddress, 1000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + String txid = ""; + String num = "\"" + Base58.encode58Check(contractAddress) + "\""; + txid = PublicMethed.triggerContract(contractAddress, + "testSuicideNonexistentTarget(address)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull1); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + Account contractafter = PublicMethed.queryAccount(contractAddress, blockingStubFull1); + long contractBalance = contractafter.getBalance(); + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertEquals(contractBalance, 0); + txid = PublicMethed.triggerContract(contractAddress, + "testSuicideNonexistentTarget(address)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Assert.assertNull(txid); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + PublicMethed.unFreezeBalance(testNetAccountAddress, testNetAccountKey, 1, + contractAddress, blockingStubFull); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed001.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed001.java new file mode 100644 index 00000000000..90883fcf4c2 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed001.java @@ -0,0 +1,834 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.transferfailed; + +import static org.tron.protos.Protocol.TransactionInfo.code.FAILED; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.Transaction.Result.contractResult; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TransferFailed001 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "Transfer trx insufficient balance") + public void test1TransferTrxInsufficientBalance() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + String filePath = "src/test/resources/soliditycode/TransferFailed001.sol"; + String contractName = "EnergyOfTransferFailedTest"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + String num = "1"; + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTrxInsufficientBalance(uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + logger.info("infoById:" + infoById); + Assert.assertTrue(infoById.get().getResultValue() == 1); + Assert.assertEquals(contractResult.REVERT, infoById.get().getReceipt().getResult()); + Assert.assertEquals( + "REVERT opcode executed", + ByteArray.toStr(infoById.get().getResMessage().toByteArray())); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Assert.assertNotEquals(10000000, energyUsageTotal); + + + } + + + @Test(enabled = true, description = "Transfer balance enough") + public void test2TransferEnough() { + + Assert.assertTrue(PublicMethed + .sendcoin(contractAddress, 3000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + String num = "1"; + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTrxInsufficientBalance(uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + logger.info("infoById" + infoById); + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee - 1 == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + + + } + + + @Test(enabled = true, description = "Transfer trx nonexistent target") + public void test3TransferTrxNonexistentTarget() { + + Assert.assertTrue(PublicMethed + .sendcoin(contractAddress, 1000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] nonexistentAddress = ecKey2.getAddress(); + String txid = ""; + String num = "1" + ",\"" + Base58.encode58Check(nonexistentAddress) + "\""; + + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTrxNonexistentTarget(uint256,address)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infobyid : --- " + infoById); + + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 1); + Assert.assertEquals(contractResult.TRANSFER_FAILED, infoById.get().getReceipt().getResult()); + Assert.assertEquals( + "transfer trx failed: Validate InternalTransfer error, no ToAccount." + + " And not allowed to create account in smart contract.", + ByteArray.toStr(infoById.get().getResMessage().toByteArray())); + + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Assert.assertNotEquals(10000000, energyUsageTotal); + + + } + + + @Test(enabled = true, description = "Transfer trx to myself") + public void test4TransferTrxSelf() { + + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + String num = "1"; + + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTrxSelf(uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infobyid : --- " + infoById); + + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 1); + Assert.assertEquals(contractResult.TRANSFER_FAILED, infoById.get().getReceipt().getResult()); + Assert.assertEquals( + "transfer trx failed: Cannot transfer trx to yourself.", + ByteArray.toStr(infoById.get().getResMessage().toByteArray())); + + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Assert.assertNotEquals(10000000, energyUsageTotal); + + + } + + + @Test(enabled = true, description = "Transfer trx nonexistent target and insufficient balance") + public void test5TransferTrxNonexistentTarget() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] nonexistentAddress = ecKey2.getAddress(); + String txid = ""; + String num = "10000000" + ",\"" + Base58.encode58Check(nonexistentAddress) + "\""; + + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTrxNonexistentTarget(uint256,address)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull1); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infobyid : --- " + infoById); + + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 1); + Assert.assertEquals(contractResult.REVERT, infoById.get().getReceipt().getResult()); + Assert.assertEquals( + "REVERT opcode executed", + ByteArray.toStr(infoById.get().getResMessage().toByteArray())); + + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Assert.assertNotEquals(10000000, energyUsageTotal); + + + } + + + @Test(enabled = true, description = "Transfer trx to myself and insufficient balance") + public void test6TransferTrxSelf() { + + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + ECKey ecKey2 = new ECKey(Utils.getRandom()); + String txid = ""; + String num = "1000000000"; + + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTrxSelf(uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infobyid : --- " + infoById); + + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 1); + Assert.assertEquals(contractResult.REVERT, infoById.get().getReceipt().getResult()); + Assert.assertEquals( + "REVERT opcode executed", + ByteArray.toStr(infoById.get().getResMessage().toByteArray())); + + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Assert.assertNotEquals(10000000, energyUsageTotal); + + + } + + @Test(enabled = true, description = "PreCompiled transfertoken with value," + + " long.max < value or long.min > value") + public void test7TransferTrckenPreCompiled() { + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Account info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String txid = ""; + String num = "1"; + + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTokenCompiledLongMax1()", "#", false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infobyid : --- " + infoById); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + beforeBalance = info.getBalance(); + beforeEnergyUsed = resourceInfo.getEnergyUsed(); + beforeNetUsed = resourceInfo.getNetUsed(); + beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + Assert.assertEquals(FAILED, infoById.get().getResult()); + Assert.assertTrue(energyUsageTotal < maxFeeLimit / 10); + Assert.assertEquals("REVERT opcode executed", infoById.get().getResMessage().toStringUtf8()); + + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTokenCompiledLongMin1()", "#", false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infobyid : --- " + infoById); + fee = infoById.get().getFee(); + netUsed = infoById.get().getReceipt().getNetUsage(); + energyUsed = infoById.get().getReceipt().getEnergyUsage(); + netFee = infoById.get().getReceipt().getNetFee(); + energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + beforeBalance = info.getBalance(); + beforeEnergyUsed = resourceInfo.getEnergyUsed(); + beforeNetUsed = resourceInfo.getNetUsed(); + beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + Assert.assertEquals(FAILED, infoById.get().getResult()); + Assert.assertTrue(energyUsageTotal < maxFeeLimit / 10); + Assert.assertEquals("REVERT opcode executed", infoById.get().getResMessage().toStringUtf8()); + + } + + @Test(enabled = false, description = "PreCompiled tokenbalance") + public void test8TransferTrctoken() { + + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000_000_000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + long start = System.currentTimeMillis() + 2000; + long end = System.currentTimeMillis() + 1000000000; + String description = Configuration.getByPath("testng.conf") + .getString("defaultParameter.assetDescription"); + String url = Configuration.getByPath("testng.conf") + .getString("defaultParameter.assetUrl"); + + ByteString assetAccountId = null; + final long TotalSupply = 10000000L; + long now = System.currentTimeMillis(); + String tokenName = "testAssetIssue_" + Long.toString(now); + + //Create a new AssetIssue success. + Assert + .assertTrue(PublicMethed.createAssetIssue(contractExcAddress, tokenName, TotalSupply, 1, + 10000, start, end, 1, description, url, 100000L, + 100000L, 1L, 1L, contractExcKey, blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + assetAccountId = PublicMethed.queryAccount(contractExcAddress, blockingStubFull) + .getAssetIssuedID(); + + String filePath = "src/test/resources/soliditycode/TransferFailed001.sol"; + String contractName = "EnergyOfTransferFailedTest"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Assert.assertTrue(PublicMethed.transferAsset(contractAddress, + assetAccountId.toByteArray(), 100L, contractExcAddress, contractExcKey, + blockingStubFull)); + + Long returnAddressBytesAccountCountBefore = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("returnAddressBytesAccountCountBefore : " + returnAddressBytesAccountCountBefore); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + Long testNetAccountCountBefore = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountBefore = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + logger.info("testNetAccountCountBefore:" + testNetAccountCountBefore); + logger.info("contractAccountCountBefore:" + contractAccountCountBefore); + String txid = ""; + String num = + "\"" + Base58.encode58Check(contractAddress) + "\"," + "\"" + assetAccountId.toStringUtf8() + + "\""; + //String num = "\""+Base58.encode58Check(contractAddress) +"\","+ "\"" + -1 + "\""; + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTokenTest(address,uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + Long testNetAccountCountAfter = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountAfter = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + logger.info("testNetAccountCountAfter:" + testNetAccountCountAfter); + logger.info("contractAccountCountAfter:" + contractAccountCountAfter); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(energyUsageTotal < maxFeeLimit / 10); + Assert.assertEquals(100, ByteArray.toInt(infoById.get().getContractResult(0).toByteArray())); + + + } + + @Test(enabled = true, description = "PreCompiled address(0x1) query tokenbalance") + public void test9TransferTrctoken() { + //address: 410000000000000000000000000000000000000001 + String addressx = "T9yD14Nj9j7xAB4dbGeiX9h8unkKLxmGkn"; + byte[] addressxx = WalletClient.decodeFromBase58Check(addressx); + + Assert.assertTrue(PublicMethed + .sendcoin(addressxx, 1000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + + long start = System.currentTimeMillis() + 2000; + long end = System.currentTimeMillis() + 1000000000; + String description = Configuration.getByPath("testng.conf") + .getString("defaultParameter.assetDescription"); + String url = Configuration.getByPath("testng.conf") + .getString("defaultParameter.assetUrl"); + + ByteString assetAccountId = null; + final long TotalSupply = 10000000L; + long now = System.currentTimeMillis(); + String tokenName = "testAssetIssue_" + Long.toString(now); + + //Create a new AssetIssue success. + Assert + .assertTrue(PublicMethed.createAssetIssue(contractExcAddress, tokenName, TotalSupply, 1, + 10000, start, end, 1, description, url, 100000L, + 100000L, 1L, 1L, contractExcKey, blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + assetAccountId = PublicMethed.queryAccount(contractExcAddress, blockingStubFull) + .getAssetIssuedID(); + + Assert.assertTrue(PublicMethed.transferAsset(addressxx, + assetAccountId.toByteArray(), 100L, contractExcAddress, contractExcKey, + blockingStubFull)); + + Long returnAddressBytesAccountCountBefore = PublicMethed + .getAssetIssueValue(addressxx, assetAccountId, blockingStubFull); + logger.info("returnAddressBytesAccountCountBefore : " + returnAddressBytesAccountCountBefore); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + Long testNetAccountCountBefore = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountBefore = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + logger.info("testNetAccountCountBefore:" + testNetAccountCountBefore); + logger.info("contractAccountCountBefore:" + contractAccountCountBefore); + String txid = ""; + //String num = "\""+Base58.encode58Check(contractAddress) + // +"\","+ "\"" + assetAccountId.toStringUtf8() + "\""; + String num = "\"" + assetAccountId.toStringUtf8() + "\""; + //String num = "\""+Base58.encode58Check(contractAddress) +"\","+ "\"" + -1 + "\""; + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTokenCompiledTokenId(uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + Long testNetAccountCountAfter = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountAfter = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + logger.info("testNetAccountCountAfter:" + testNetAccountCountAfter); + logger.info("contractAccountCountAfter:" + contractAccountCountAfter); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(energyUsageTotal < maxFeeLimit / 10); + Assert.assertEquals(100, ByteArray.toInt(infoById.get().getContractResult(0).toByteArray())); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed002.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed002.java new file mode 100644 index 00000000000..cb3187857d1 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed002.java @@ -0,0 +1,495 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.transferfailed; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.Transaction.Result.contractResult; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TransferFailed002 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "Send balance not enough") + public void test1SendNotEnough() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 100000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + String filePath = "src/test/resources/soliditycode/TransferFailed001.sol"; + String contractName = "EnergyOfTransferFailedTest"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + String num = "1"; + txid = PublicMethed.triggerContract(contractAddress, + "testSendTrxInsufficientBalance(uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + logger.info("infoById:" + infoById); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Assert.assertNotEquals(10000000, energyUsageTotal); + + + } + + @Test(enabled = true, description = "Send balance enough") + public void test2SendEnough() { + Assert.assertTrue(PublicMethed + .sendcoin(contractAddress, 3000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + String num = "1"; + txid = PublicMethed.triggerContract(contractAddress, + "testSendTrxInsufficientBalance(uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + logger.info("infoById:" + infoById); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee - 1 == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + + } + + + @Test(enabled = true, description = "Send trx nonexistent target") + public void test3SendTrxNonexistentTarget() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] nonexistentAddress = ecKey2.getAddress(); + String txid = ""; + String num = "1" + ",\"" + Base58.encode58Check(nonexistentAddress) + "\""; + + txid = PublicMethed.triggerContract(contractAddress, + "testSendTrxNonexistentTarget(uint256,address)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infobyid : --- " + infoById); + + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 1); + Assert.assertEquals(contractResult.TRANSFER_FAILED, infoById.get().getReceipt().getResult()); + Assert.assertEquals( + "transfer trx failed: Validate InternalTransfer error, no ToAccount." + + " And not allowed to create account in smart contract.", + ByteArray.toStr(infoById.get().getResMessage().toByteArray())); + + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Assert.assertNotEquals(10000000, energyUsageTotal); + + + } + + + @Test(enabled = true, description = "Send trx self") + public void test4SendTrxSelf() { + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + String num = "1"; + txid = PublicMethed.triggerContract(contractAddress, + "testSendTrxSelf(uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infobyid : --- " + infoById); + + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 1); + Assert.assertEquals(contractResult.TRANSFER_FAILED, infoById.get().getReceipt().getResult()); + Assert.assertEquals( + "transfer trx failed: Cannot transfer trx to yourself.", + ByteArray.toStr(infoById.get().getResMessage().toByteArray())); + + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Assert.assertNotEquals(10000000, energyUsageTotal); + Assert.assertNotEquals(10000000, energyUsageTotal); + + + } + + + @Test(enabled = true, description = "Send trx nonexistent target and balance not enough") + public void test5SendTrxNonexistentTarget() { + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] nonexistentAddress = ecKey2.getAddress(); + String txid = ""; + + String num = "100000000" + ",\"" + Base58.encode58Check(contractExcAddress) + "\""; + + txid = PublicMethed.triggerContract(contractAddress, + "testSendTrxNonexistentTarget(uint256,address)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infobyid : --- " + infoById); + + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Assert.assertNotEquals(10000000, energyUsageTotal); + + } + + + @Test(enabled = true, description = "Send trx self and balance not enough") + public void test6SendTrxSelf() { + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + ECKey ecKey2 = new ECKey(Utils.getRandom()); + String txid = ""; + + String num = "1000000000"; + + txid = PublicMethed.triggerContract(contractAddress, + "testSendTrxSelf(uint256)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infobyid : --- " + infoById); + + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Assert.assertNotEquals(10000000, energyUsageTotal); + + + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed003.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed003.java new file mode 100644 index 00000000000..910ce65c936 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed003.java @@ -0,0 +1,699 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.transferfailed; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.Transaction.Result.contractResult; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TransferFailed003 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + private static ByteString assetAccountId = null; + private static final long now = System.currentTimeMillis(); + private static String tokenName = "testAssetIssue_" + Long.toString(now); + private static final long TotalSupply = 10000000L; + + String description = Configuration.getByPath("testng.conf") + .getString("defaultParameter.assetDescription"); + String url = Configuration.getByPath("testng.conf") + .getString("defaultParameter.assetUrl"); + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + + @Test(enabled = true, description = "TransferToken enough tokenBalance") + public void test1TransferTokenEnough() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000_000_000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + long start = System.currentTimeMillis() + 2000; + long end = System.currentTimeMillis() + 1000000000; + + //Create a new AssetIssue success. + Assert + .assertTrue(PublicMethed.createAssetIssue(contractExcAddress, tokenName, TotalSupply, 1, + 10000, start, end, 1, description, url, 100000L, + 100000L, 1L, 1L, contractExcKey, blockingStubFull)); + assetAccountId = PublicMethed.queryAccount(contractExcAddress, blockingStubFull) + .getAssetIssuedID(); + + String filePath = "src/test/resources/soliditycode/TransferFailed001.sol"; + String contractName = "EnergyOfTransferFailedTest"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Assert.assertTrue(PublicMethed.transferAsset(contractAddress, + assetAccountId.toByteArray(), 100L, contractExcAddress, contractExcKey, + blockingStubFull)); + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + Long testNetAccountCountBefore = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountBefore = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + logger.info("testNetAccountCountBefore:" + testNetAccountCountBefore); + logger.info("contractAccountCountBefore:" + contractAccountCountBefore); + String txid = ""; + String num = "1" + ",\"" + assetAccountId.toStringUtf8() + "\""; + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTokenInsufficientBalance(uint256,trcToken)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + Long testNetAccountCountAfter = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountAfter = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + logger.info("testNetAccountCountAfter:" + testNetAccountCountAfter); + logger.info("contractAccountCountAfter:" + contractAccountCountAfter); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(testNetAccountCountBefore + 1 == testNetAccountCountAfter); + Assert.assertTrue(contractAccountCountBefore - 1 == contractAccountCountAfter); + + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + + + } + + @Test(enabled = true, description = "TransferToken insufficient tokenBalance") + public void test2TransferTokenNotEnough() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + Long testNetAccountCountBefore = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountBefore = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + logger.info("testNetAccountCountBefore:" + testNetAccountCountBefore); + logger.info("contractAccountCountBefore:" + contractAccountCountBefore); + String txid = ""; + String num = "1000" + ",\"" + assetAccountId.toStringUtf8() + "\""; + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTokenInsufficientBalance(uint256,trcToken)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + Long testNetAccountCountAfter = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountAfter = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + logger.info("testNetAccountCountAfter:" + testNetAccountCountAfter); + logger.info("contractAccountCountAfter:" + contractAccountCountAfter); + logger.info("infoById:" + infoById); + Assert.assertTrue(infoById.get().getResultValue() == 1); + Assert.assertEquals(contractResult.REVERT, infoById.get().getReceipt().getResult()); + Assert.assertEquals( + "REVERT opcode executed", + ByteArray.toStr(infoById.get().getResMessage().toByteArray())); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertEquals(testNetAccountCountBefore, testNetAccountCountAfter); + Assert.assertEquals(contractAccountCountBefore, contractAccountCountAfter); + + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Assert.assertNotEquals(10000000, energyUsageTotal); + + } + + + @Test(enabled = true, description = "TransferToken to nonexistent target") + public void test3TransferTokenNonexistentTarget() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + Long testNetAccountCountBefore = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountBefore = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + logger.info("testNetAccountCountBefore:" + testNetAccountCountBefore); + logger.info("contractAccountCountBefore:" + contractAccountCountBefore); + String txid = ""; + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] nonexistentAddress = ecKey2.getAddress(); + String num = + "\"1" + "\",\"" + Base58.encode58Check(nonexistentAddress) + "\",\"" + assetAccountId + .toStringUtf8() + "\""; + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTokenNonexistentTarget(uint256,address,trcToken)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infoById:" + infoById); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + Long testNetAccountCountAfter = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountAfter = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + logger.info("testNetAccountCountAfter:" + testNetAccountCountAfter); + logger.info("contractAccountCountAfter:" + contractAccountCountAfter); + + Assert.assertTrue(infoById.get().getResultValue() == 1); + Assert.assertEquals(contractResult.TRANSFER_FAILED, infoById.get().getReceipt().getResult()); + Assert.assertEquals( + "transfer trc10 failed: Validate InternalTransfer error, no ToAccount." + + " And not allowed to create account in smart contract.", + ByteArray.toStr(infoById.get().getResMessage().toByteArray())); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertEquals(testNetAccountCountBefore, testNetAccountCountAfter); + Assert.assertEquals(contractAccountCountBefore, contractAccountCountAfter); + + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Assert.assertNotEquals(10000000, energyUsageTotal); + + + } + + + @Test(enabled = true, description = "TransferToken to myself") + public void test4TransferTokenSelf() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + Long testNetAccountCountBefore = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountBefore = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + logger.info("testNetAccountCountBefore:" + testNetAccountCountBefore); + logger.info("contractAccountCountBefore:" + contractAccountCountBefore); + String txid = ""; + String num = "1" + ",\"" + assetAccountId.toStringUtf8() + "\""; + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTokenSelf(uint256,trcToken)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infoById:" + infoById); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + Long testNetAccountCountAfter = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountAfter = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + logger.info("testNetAccountCountAfter:" + testNetAccountCountAfter); + logger.info("contractAccountCountAfter:" + contractAccountCountAfter); + + Assert.assertTrue(infoById.get().getResultValue() == 1); + Assert.assertEquals(contractResult.TRANSFER_FAILED, infoById.get().getReceipt().getResult()); + Assert.assertEquals( + "transfer trc10 failed: Cannot transfer asset to yourself.", + ByteArray.toStr(infoById.get().getResMessage().toByteArray())); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertEquals(testNetAccountCountBefore, testNetAccountCountAfter); + Assert.assertEquals(contractAccountCountBefore, contractAccountCountAfter); + + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Assert.assertNotEquals(10000000, energyUsageTotal); + + + } + + + @Test(enabled = true, description = "TransferToken notexist tokenID ") + public void test5TransferTokenNotexist() { + + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + Long testNetAccountCountBefore = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountBefore = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + logger.info("testNetAccountCountBefore:" + testNetAccountCountBefore); + logger.info("contractAccountCountBefore:" + contractAccountCountBefore); + String txid = ""; + String fakeassetAccountId = Long.toString(0L); + + String num = "1" + ",\"" + fakeassetAccountId + "\""; + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTokenInsufficientBalance(uint256,trcToken)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infoById:" + infoById); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + Long testNetAccountCountAfter = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountAfter = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + logger.info("testNetAccountCountAfter:" + testNetAccountCountAfter); + logger.info("contractAccountCountAfter:" + contractAccountCountAfter); + + Assert.assertTrue(infoById.get().getResultValue() == 1); + Assert.assertEquals(contractResult.REVERT, infoById.get().getReceipt().getResult()); + Assert.assertEquals( + "REVERT opcode executed", + ByteArray.toStr(infoById.get().getResMessage().toByteArray())); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertEquals(testNetAccountCountBefore, testNetAccountCountAfter); + Assert.assertEquals(contractAccountCountBefore, contractAccountCountAfter); + + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + + + } + + + @Test(enabled = true, description = "TransferToken to nonexistent target and " + + "insufficient tokenBalance") + public void test7TransferTokenNonexistentTarget() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + Long testNetAccountCountBefore = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountBefore = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + logger.info("testNetAccountCountBefore:" + testNetAccountCountBefore); + logger.info("contractAccountCountBefore:" + contractAccountCountBefore); + String txid = ""; + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] nonexistentAddress = ecKey2.getAddress(); + String num = + "\"100000000000" + "\",\"" + Base58.encode58Check(nonexistentAddress) + "\",\"" + + assetAccountId + .toStringUtf8() + "\""; + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTokenNonexistentTarget(uint256,address,trcToken)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infoById:" + infoById); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + Long testNetAccountCountAfter = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountAfter = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + logger.info("testNetAccountCountAfter:" + testNetAccountCountAfter); + logger.info("contractAccountCountAfter:" + contractAccountCountAfter); + + Assert.assertTrue(infoById.get().getResultValue() == 1); + Assert.assertEquals(contractResult.REVERT, infoById.get().getReceipt().getResult()); + Assert.assertEquals( + "REVERT opcode executed", + ByteArray.toStr(infoById.get().getResMessage().toByteArray())); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertEquals(testNetAccountCountBefore, testNetAccountCountAfter); + Assert.assertEquals(contractAccountCountBefore, contractAccountCountAfter); + + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Assert.assertNotEquals(10000000, energyUsageTotal); + + + } + + + @Test(enabled = true, description = "TransferToken to myself and insufficient tokenBalance") + public void test8TransferTokenSelf() { + + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + Long testNetAccountCountBefore = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountBefore = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + logger.info("testNetAccountCountBefore:" + testNetAccountCountBefore); + logger.info("contractAccountCountBefore:" + contractAccountCountBefore); + String txid = ""; + String num = "1000000000000000" + ",\"" + assetAccountId.toStringUtf8() + "\""; + txid = PublicMethed.triggerContract(contractAddress, + "testTransferTokenSelf(uint256,trcToken)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infoById:" + infoById); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + Long testNetAccountCountAfter = PublicMethed + .getAssetIssueValue(contractExcAddress, assetAccountId, blockingStubFull); + Long contractAccountCountAfter = PublicMethed + .getAssetIssueValue(contractAddress, assetAccountId, blockingStubFull); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + logger.info("testNetAccountCountAfter:" + testNetAccountCountAfter); + logger.info("contractAccountCountAfter:" + contractAccountCountAfter); + + Assert.assertTrue(infoById.get().getResultValue() == 1); + Assert.assertEquals(contractResult.REVERT, infoById.get().getReceipt().getResult()); + Assert.assertEquals( + "REVERT opcode executed", + ByteArray.toStr(infoById.get().getResMessage().toByteArray())); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertEquals(testNetAccountCountBefore, testNetAccountCountAfter); + Assert.assertEquals(contractAccountCountBefore, contractAccountCountAfter); + + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + + Assert.assertNotEquals(10000000, energyUsageTotal); + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed004.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed004.java new file mode 100644 index 00000000000..a04d01b2720 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed004.java @@ -0,0 +1,261 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.transferfailed; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.Transaction.Result.contractResult; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TransferFailed004 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] nonexistentAddress = ecKey2.getAddress(); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "Suicide nonexistent target") + public void test1SuicideNonexistentTarget() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + String filePath = "src/test/resources/soliditycode/TransferFailed001.sol"; + String contractName = "EnergyOfTransferFailedTest"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Assert.assertTrue(PublicMethed + .sendcoin(contractAddress, 1000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + String num = "\"" + Base58.encode58Check(nonexistentAddress) + "\""; + + txid = PublicMethed.triggerContract(contractAddress, + "testSuicideNonexistentTarget(address)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + logger.info("infobyid : --- " + infoById); + + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 1); + Assert.assertEquals(contractResult.TRANSFER_FAILED, infoById.get().getReceipt().getResult()); + Assert.assertEquals( + "transfer all token or transfer all trx failed in suicide: " + + "Validate InternalTransfer error, no ToAccount. And not allowed " + + "to create account in smart contract.", + ByteArray.toStr(infoById.get().getResMessage().toByteArray())); + + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Assert.assertNotEquals(10000000, energyUsageTotal); + + + } + + @Test(enabled = true, description = "Suicide existent target") + public void test2SuicideExistentTarget() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + Assert.assertTrue(PublicMethed + .sendcoin(nonexistentAddress, 1000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + String txid = ""; + String num = "\"" + Base58.encode58Check(nonexistentAddress) + "\""; + txid = PublicMethed.triggerContract(contractAddress, + "testSuicideNonexistentTarget(address)", num, false, + 0, maxFeeLimit, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull1); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull1); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + Account contractafter = PublicMethed.queryAccount(contractAddress, blockingStubFull1); + long contractBalance = contractafter.getBalance(); + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertEquals(contractBalance, 0); + + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + + + } + + + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed005.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed005.java new file mode 100644 index 00000000000..88bae7d9ea1 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed005.java @@ -0,0 +1,509 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.transferfailed; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TransferFailed005 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key1"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private final Long maxFeeLimit = Configuration.getByPath("testng.cong") + .getLong("defaultParameter.maxFeeLimit"); + + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + byte[] contractAddress = null; + byte[] contractAddress1 = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] accountExcAddress = ecKey1.getAddress(); + String accountExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(accountExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + { + Assert.assertTrue(PublicMethed + .sendcoin(accountExcAddress, 10000_000_000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + String filePath = "src/test/resources/soliditycode/TransferFailed005.sol"; + String contractName = "EnergyOfTransferFailedTest"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed + .deployContract(contractName, abi, code, "", maxFeeLimit, 0L, 100L, + null, accountExcKey, accountExcAddress, blockingStubFull); + + filePath = "src/test/resources/soliditycode/TransferFailed005.sol"; + contractName = "Caller"; + retMap = PublicMethed.getBycodeAbi(filePath, contractName); + code = retMap.get("byteCode").toString(); + abi = retMap.get("abI").toString(); + + contractAddress1 = PublicMethed + .deployContract(contractName, abi, code, "", maxFeeLimit, 0L, 100L, + null, accountExcKey, accountExcAddress, blockingStubFull); + } + } + + @Test(enabled = false, description = "Deploy contract for trigger") + public void deployContract() { + Assert.assertTrue(PublicMethed + .sendcoin(accountExcAddress, 10000_000_000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + String filePath = "src/test/resources/soliditycode/TransferFailed005.sol"; + String contractName = "EnergyOfTransferFailedTest"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed + .deployContract(contractName, abi, code, "", maxFeeLimit, 0L, 100L, + null, accountExcKey, accountExcAddress, blockingStubFull); + String Txid1 = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", maxFeeLimit, 0L, 100L, + null, accountExcKey, accountExcAddress, blockingStubFull); + Optional infoById = PublicMethed + .getTransactionInfoById(Txid1, blockingStubFull); + contractAddress = infoById.get().getContractAddress().toByteArray(); + Assert.assertEquals(0, infoById.get().getResultValue()); + + filePath = "src/test/resources/soliditycode/TransferFailed005.sol"; + contractName = "Caller"; + retMap = PublicMethed.getBycodeAbi(filePath, contractName); + code = retMap.get("byteCode").toString(); + abi = retMap.get("abI").toString(); + + contractAddress1 = PublicMethed + .deployContract(contractName, abi, code, "", maxFeeLimit, 0L, 100L, + null, accountExcKey, accountExcAddress, blockingStubFull); + Txid1 = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", maxFeeLimit, 0L, 100L, + null, accountExcKey, accountExcAddress, blockingStubFull); + infoById = PublicMethed + .getTransactionInfoById(Txid1, blockingStubFull); + contractAddress1 = infoById.get().getContractAddress().toByteArray(); + logger.info("caller address : " + Base58.encode58Check(contractAddress1)); + Assert.assertEquals(0, infoById.get().getResultValue()); + } + + @Test(enabled = true, description = "TransferFailed for function call_value ") + public void triggerContract01() { + Account info = null; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(accountExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(accountExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + Assert.assertTrue(PublicMethed + .sendcoin(contractAddress, 1000100L, accountExcAddress, accountExcKey, blockingStubFull)); + //Assert.assertTrue(PublicMethed + // .sendcoin(contractAddress1, 1, accountExcAddress, accountExcKey, blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + logger.info( + "contractAddress balance before: " + PublicMethed + .queryAccount(contractAddress, blockingStubFull) + .getBalance()); + logger.info( + "callerAddress balance before: " + PublicMethed + .queryAccount(contractAddress1, blockingStubFull) + .getBalance()); + long paramValue = 1000000; + + // transfer trx to self`s account + String param = "\"" + paramValue + "\",\"" + Base58.encode58Check(contractAddress) + "\""; + String triggerTxid = PublicMethed.triggerContract(contractAddress, + "testCallTrxInsufficientBalance(uint256,address)", param, false, 0L, + maxFeeLimit, accountExcAddress, accountExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + Assert.assertEquals(infoById.get().getResultValue(), 1); + Assert.assertEquals("FAILED", infoById.get().getResult().toString()); + Assert.assertEquals("TRANSFER_FAILED", infoById.get().getReceipt().getResult().toString()); + Assert.assertEquals("transfer trx failed: Cannot transfer trx to yourself.", + infoById.get().getResMessage().toStringUtf8()); + Assert.assertEquals(1000100L, + PublicMethed.queryAccount(contractAddress, blockingStubFull).getBalance()); + Assert.assertEquals(0L, + PublicMethed.queryAccount(contractAddress1, blockingStubFull).getBalance()); + Assert.assertTrue(infoById.get().getReceipt().getEnergyUsageTotal() < 10000000); + + // transfer trx to unactivate account + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] accountExcAddress2 = ecKey2.getAddress(); + param = "\"" + paramValue + "\",\"" + Base58.encode58Check(accountExcAddress2) + "\""; + triggerTxid = PublicMethed.triggerContract(contractAddress, + "testCallTrxInsufficientBalance(uint256,address)", param, false, 0L, + maxFeeLimit, accountExcAddress, accountExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + Assert.assertEquals(infoById.get().getResultValue(), 1); + Assert.assertEquals("FAILED", infoById.get().getResult().toString()); + Assert.assertEquals("TRANSFER_FAILED", infoById.get().getReceipt().getResult().toString()); + Assert.assertEquals( + "transfer trx failed: Validate InternalTransfer error, no ToAccount. " + + "And not allowed to create account in smart contract.", + infoById.get().getResMessage().toStringUtf8()); + Assert.assertEquals(1000100L, + PublicMethed.queryAccount(contractAddress, blockingStubFull).getBalance()); + Assert.assertEquals(0L, + PublicMethed.queryAccount(contractAddress1, blockingStubFull).getBalance()); + Assert.assertTrue(infoById.get().getReceipt().getEnergyUsageTotal() < 10000000); + + // transfer trx to caller, value enough , function success contractResult(call_value) failed + param = "\"" + paramValue + "\",\"" + Base58.encode58Check(contractAddress1) + "\""; + triggerTxid = PublicMethed.triggerContract(contractAddress, + "testCallTrxInsufficientBalance(uint256,address)", param, false, 0L, + maxFeeLimit, accountExcAddress, accountExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + logger.info(infoById.get().getReceipt().getResult() + ""); + + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + int contractResult = ByteArray + .toInt(infoById.get().getContractResult(0).toByteArray()); + Assert.assertEquals(1, contractResult); + + Assert.assertEquals(infoById.get().getResultValue(), 0); + Assert.assertEquals(infoById.get().getResult().toString(), "SUCESS"); + Assert.assertEquals(100L, + PublicMethed.queryAccount(contractAddress, blockingStubFull).getBalance()); + Assert.assertEquals(1000000L, + PublicMethed.queryAccount(contractAddress1, blockingStubFull).getBalance()); + Assert.assertTrue(infoById.get().getReceipt().getEnergyUsageTotal() < 10000000); + + // transfer trx to caller, value not enough, function success + // but contractResult(call_value) failed + triggerTxid = PublicMethed.triggerContract(contractAddress, + "testCallTrxInsufficientBalance(uint256,address)", param, false, 0L, + maxFeeLimit, accountExcAddress, accountExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + infoById = PublicMethed.getTransactionInfoById(triggerTxid, blockingStubFull); + fee = infoById.get().getFee(); + netUsed = infoById.get().getReceipt().getNetUsage(); + energyUsed = infoById.get().getReceipt().getEnergyUsage(); + netFee = infoById.get().getReceipt().getNetFee(); + energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + //contractResult`s first boolean value + contractResult = ByteArray + .toInt(infoById.get().getContractResult(0).toByteArray()); + Assert.assertEquals(0, contractResult); + Assert.assertEquals(infoById.get().getResultValue(), 0); + Assert.assertEquals(infoById.get().getResult().toString(), "SUCESS"); + Assert.assertEquals(100L, + PublicMethed.queryAccount(contractAddress, blockingStubFull).getBalance()); + Assert.assertEquals(1000000L, + PublicMethed.queryAccount(contractAddress1, blockingStubFull).getBalance()); + Assert.assertTrue(infoById.get().getReceipt().getEnergyUsageTotal() < 10000000); + + + } + + @Test(enabled = true, description = "TransferFailed for create") + public void triggerContract02() { + Account info = null; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(accountExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(accountExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + Assert.assertTrue(PublicMethed + .sendcoin(contractAddress, 1000100L, accountExcAddress, accountExcKey, blockingStubFull)); + //Assert.assertTrue(PublicMethed + // .sendcoin(contractAddress1, 1, accountExcAddress, accountExcKey, blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + logger.info( + "contractAddress balance before: " + PublicMethed + .queryAccount(contractAddress, blockingStubFull) + .getBalance()); + logger.info( + "callerAddress balance before: " + PublicMethed + .queryAccount(contractAddress1, blockingStubFull) + .getBalance()); + long paramValue = 1000000; + String param = "\"" + paramValue + "\""; + + String triggerTxid = PublicMethed.triggerContract(contractAddress, + "testCreateTrxInsufficientBalance(uint256)", param, false, 0L, + maxFeeLimit, accountExcAddress, accountExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + logger.info(infoById.get().getReceipt().getResult() + ""); + + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + logger.info( + "contractAddress balance before: " + PublicMethed + .queryAccount(contractAddress, blockingStubFull) + .getBalance()); + logger.info( + "callerAddress balance before: " + PublicMethed + .queryAccount(contractAddress1, blockingStubFull) + .getBalance()); + Assert.assertEquals(infoById.get().getResultValue(), 0); + Assert.assertFalse(infoById.get().getInternalTransactions(0).getRejected()); + Assert.assertEquals(200L, + PublicMethed.queryAccount(contractAddress, blockingStubFull).getBalance()); + Assert.assertTrue(infoById.get().getReceipt().getEnergyUsageTotal() < 10000000); + + triggerTxid = PublicMethed.triggerContract(contractAddress, + "testCreateTrxInsufficientBalance(uint256)", param, false, 0L, + maxFeeLimit, accountExcAddress, accountExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + infoById = PublicMethed.getTransactionInfoById(triggerTxid, blockingStubFull); + fee = infoById.get().getFee(); + netUsed = infoById.get().getReceipt().getNetUsage(); + energyUsed = infoById.get().getReceipt().getEnergyUsage(); + netFee = infoById.get().getReceipt().getNetFee(); + energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + logger.info( + "contractAddress balance before: " + PublicMethed + .queryAccount(contractAddress, blockingStubFull) + .getBalance()); + logger.info( + "callerAddress balance before: " + PublicMethed + .queryAccount(contractAddress1, blockingStubFull) + .getBalance()); + + Assert.assertEquals(infoById.get().getResultValue(), 1); + Assert.assertEquals(infoById.get().getResMessage().toStringUtf8(), "REVERT opcode executed"); + Assert.assertEquals(200L, + PublicMethed.queryAccount(contractAddress, blockingStubFull).getBalance()); + Assert.assertEquals(1000000L, + PublicMethed.queryAccount(contractAddress1, blockingStubFull).getBalance()); + Assert.assertTrue(infoById.get().getReceipt().getEnergyUsageTotal() < 10000000); + + + } + + @Test(enabled = true, description = "TransferFailed for create2") + public void triggerContract03() { + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(accountExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(accountExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + Assert.assertTrue(PublicMethed + .sendcoin(contractAddress, 15L, accountExcAddress, accountExcKey, blockingStubFull)); + logger.info( + "contractAddress balance before: " + PublicMethed + .queryAccount(contractAddress, blockingStubFull) + .getBalance()); + + String filePath = "./src/test/resources/soliditycode/TransferFailed007.sol"; + String contractName = "Caller"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String testContractCode = retMap.get("byteCode").toString(); + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + String triggerTxid = PublicMethed.triggerContract(contractAddress, + "deploy(bytes,uint256)", param, false, 0L, + maxFeeLimit, accountExcAddress, accountExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + long afterBalance = 0L; + afterBalance = PublicMethed.queryAccount(contractAddress, blockingStubFull) + .getBalance(); + logger.info( + "contractAddress balance after : " + PublicMethed + .queryAccount(contractAddress, blockingStubFull) + .getBalance()); + Assert.assertEquals(0, infoById.get().getResultValue()); + Assert.assertEquals("SUCESS", infoById.get().getResult().toString()); + Assert.assertEquals(205L, afterBalance); + Assert.assertFalse(infoById.get().getInternalTransactions(0).getRejected()); + Assert.assertTrue(infoById.get().getReceipt().getEnergyUsageTotal() < 10000000); + + triggerTxid = PublicMethed.triggerContract(contractAddress, + "deploy2(bytes,uint256)", param, false, 0L, + maxFeeLimit, accountExcAddress, accountExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + fee = infoById.get().getFee(); + netUsed = infoById.get().getReceipt().getNetUsage(); + energyUsed = infoById.get().getReceipt().getEnergyUsage(); + netFee = infoById.get().getReceipt().getNetFee(); + energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + afterBalance = PublicMethed.queryAccount(contractAddress, blockingStubFull).getBalance(); + logger.info( + "contractAddress balance after : " + PublicMethed + .queryAccount(contractAddress, blockingStubFull) + .getBalance()); + Assert.assertEquals(1, infoById.get().getResultValue()); + Assert.assertEquals("FAILED", infoById.get().getResult().toString()); + Assert.assertEquals(205L, afterBalance); + Assert.assertEquals(0, ByteArray.toInt( + infoById.get().getContractResult(0).toByteArray())); + Assert.assertTrue(infoById.get().getReceipt().getEnergyUsageTotal() < 10000000); + + } + + + /** + * constructor. + */ + @AfterClass + + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed006.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed006.java new file mode 100644 index 00000000000..1fa6ed77279 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed006.java @@ -0,0 +1,240 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.transferfailed; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TransferFailed006 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key1"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private final Long maxFeeLimit = Configuration.getByPath("testng.cong") + .getLong("defaultParameter.maxFeeLimit"); + + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + byte[] contractAddress = null; + byte[] contractAddress1 = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] accountExcAddress = ecKey1.getAddress(); + String accountExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(accountExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + } + + @Test(enabled = false, description = "Deploy contract for trigger") + public void deployContract() { + Assert.assertTrue(PublicMethed + .sendcoin(accountExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + String filePath = "src/test/resources/soliditycode/TransferFailed006.sol"; + String contractName = "EnergyOfTransferFailedTest"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + String Txid1 = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", maxFeeLimit, 0L, 100L, + null, accountExcKey, accountExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = PublicMethed + .getTransactionInfoById(Txid1, blockingStubFull); + contractAddress = infoById.get().getContractAddress().toByteArray(); + Assert.assertEquals(0, infoById.get().getResultValue()); + + filePath = "src/test/resources/soliditycode/TransferFailed006.sol"; + contractName = "Caller"; + retMap = PublicMethed.getBycodeAbi(filePath, contractName); + code = retMap.get("byteCode").toString(); + abi = retMap.get("abI").toString(); + + Txid1 = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", maxFeeLimit, 0L, 100L, + null, accountExcKey, accountExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + infoById = PublicMethed + .getTransactionInfoById(Txid1, blockingStubFull); + contractAddress1 = infoById.get().getContractAddress().toByteArray(); + logger.info("caller address : " + Base58.encode58Check(contractAddress1)); + Assert.assertEquals(0, infoById.get().getResultValue()); + } + + @Test(enabled = false, description = "TransferFailed for create") + public void triggerContract() { + Account info = null; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(accountExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(accountExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + Assert.assertTrue(PublicMethed + .sendcoin(contractAddress, 1000100L, accountExcAddress, accountExcKey, blockingStubFull)); + Assert.assertTrue(PublicMethed + .sendcoin(contractAddress1, 1, accountExcAddress, accountExcKey, blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + logger.info( + "contractAddress balance before: " + PublicMethed + .queryAccount(contractAddress, blockingStubFull) + .getBalance()); + logger.info( + "callerAddress balance before: " + PublicMethed + .queryAccount(contractAddress1, blockingStubFull) + .getBalance()); + long paramValue = 1000000; + String param = "\"" + paramValue + "\""; + + String triggerTxid = PublicMethed.triggerContract(contractAddress, + "testCreateTrxInsufficientBalance(uint256)", param, false, 0L, + maxFeeLimit, accountExcAddress, accountExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + logger.info(infoById.get().getReceipt().getResult() + ""); + + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + logger.info( + "contractAddress balance before: " + PublicMethed + .queryAccount(contractAddress, blockingStubFull) + .getBalance()); + logger.info( + "callerAddress balance before: " + PublicMethed + .queryAccount(contractAddress1, blockingStubFull) + .getBalance()); + Assert.assertEquals(infoById.get().getResultValue(), 0); + Assert.assertFalse(infoById.get().getInternalTransactions(0).getRejected()); + Assert.assertEquals(100L, + PublicMethed.queryAccount(contractAddress, blockingStubFull).getBalance()); + Assert.assertTrue(infoById.get().getReceipt().getEnergyUsageTotal() < 10000000); + + triggerTxid = PublicMethed.triggerContract(contractAddress, + "testCreateTrxInsufficientBalance(uint256)", param, false, 0L, + maxFeeLimit, accountExcAddress, accountExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + infoById = PublicMethed.getTransactionInfoById(triggerTxid, blockingStubFull); + fee = infoById.get().getFee(); + netUsed = infoById.get().getReceipt().getNetUsage(); + energyUsed = infoById.get().getReceipt().getEnergyUsage(); + netFee = infoById.get().getReceipt().getNetFee(); + energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + logger.info( + "contractAddress balance before: " + PublicMethed + .queryAccount(contractAddress, blockingStubFull) + .getBalance()); + logger.info( + "callerAddress balance before: " + PublicMethed + .queryAccount(contractAddress1, blockingStubFull) + .getBalance()); + + Assert.assertEquals(infoById.get().getResultValue(), 1); + Assert.assertEquals(infoById.get().getResMessage().toStringUtf8(), "REVERT opcode executed"); + Assert.assertEquals(100L, + PublicMethed.queryAccount(contractAddress, blockingStubFull).getBalance()); + Assert.assertEquals(1L, + PublicMethed.queryAccount(contractAddress1, blockingStubFull).getBalance()); + Assert.assertTrue(infoById.get().getReceipt().getEnergyUsageTotal() < 10000000); + + + } + + /** + * constructor. + */ + @AfterClass + + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed007.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed007.java new file mode 100644 index 00000000000..ae98ce42096 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/transferfailed/TransferFailed007.java @@ -0,0 +1,211 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.transferfailed; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TransferFailed007 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key1"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private final Long maxFeeLimit = Configuration.getByPath("testng.cong") + .getLong("defaultParameter.maxFeeLimit"); + + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + byte[] contractAddress = null; + byte[] contractAddress1 = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] accountExcAddress = ecKey1.getAddress(); + String accountExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(accountExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + } + + @Test(enabled = false, description = "Deploy contract for trigger") + public void deployContract() { + Assert.assertTrue(PublicMethed + .sendcoin(accountExcAddress, 10000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + String filePath = "src/test/resources/soliditycode/TransferFailed007.sol"; + String contractName = "EnergyOfTransferFailedTest"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + String Txid1 = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, code, "", maxFeeLimit, 0L, 100L, + null, accountExcKey, accountExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = PublicMethed + .getTransactionInfoById(Txid1, blockingStubFull); + contractAddress = infoById.get().getContractAddress().toByteArray(); + Assert.assertEquals(0, infoById.get().getResultValue()); + } + + @Test(enabled = false, description = "TransferFailed for create2") + public void triggerContract() { + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(accountExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(accountExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + Assert.assertTrue(PublicMethed + .sendcoin(contractAddress, 15L, accountExcAddress, accountExcKey, blockingStubFull)); + logger.info( + "contractAddress balance before: " + PublicMethed + .queryAccount(contractAddress, blockingStubFull) + .getBalance()); + + String filePath = "./src/test/resources/soliditycode/TransferFailed007.sol"; + String contractName = "Caller"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String testContractCode = retMap.get("byteCode").toString(); + Long salt = 1L; + + String param = "\"" + testContractCode + "\"," + salt; + + String triggerTxid = PublicMethed.triggerContract(contractAddress, + "deploy(bytes,uint256)", param, false, 0L, + maxFeeLimit, accountExcAddress, accountExcKey, blockingStubFull); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + long afterBalance = 0L; + afterBalance = PublicMethed.queryAccount(contractAddress, blockingStubFull) + .getBalance(); + logger.info( + "contractAddress balance after : " + PublicMethed + .queryAccount(contractAddress, blockingStubFull) + .getBalance()); + Assert.assertEquals(0, infoById.get().getResultValue()); + Assert.assertEquals("SUCESS", infoById.get().getResult().toString()); + Assert.assertEquals(5L, afterBalance); + Assert.assertFalse(infoById.get().getInternalTransactions(0).getRejected()); + Assert.assertTrue(infoById.get().getReceipt().getEnergyUsageTotal() < 10000000); + + triggerTxid = PublicMethed.triggerContract(contractAddress, + "deploy(bytes,uint256)", param, false, 0L, + maxFeeLimit, accountExcAddress, accountExcKey, blockingStubFull); + + infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + fee = infoById.get().getFee(); + netUsed = infoById.get().getReceipt().getNetUsage(); + energyUsed = infoById.get().getReceipt().getEnergyUsage(); + netFee = infoById.get().getReceipt().getNetFee(); + energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + afterBalance = PublicMethed.queryAccount(contractAddress, blockingStubFull).getBalance(); + logger.info( + "contractAddress balance after : " + PublicMethed + .queryAccount(contractAddress, blockingStubFull) + .getBalance()); + Assert.assertEquals(0, infoById.get().getResultValue()); + Assert.assertEquals("SUCESS", infoById.get().getResult().toString()); + Assert.assertEquals(5L, afterBalance); + Assert.assertEquals(0, ByteArray.toInt(infoById.get().getContractResult(0).toByteArray())); + Assert.assertTrue(infoById.get().getReceipt().getEnergyUsageTotal() < 10000000); + + } + + /** + * constructor. + */ + @AfterClass + + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant001.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant001.java new file mode 100644 index 00000000000..0f0a046c7de --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant001.java @@ -0,0 +1,813 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant001 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddressNoAbi = null; + byte[] contractAddressWithAbi = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + + { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 10000_000_000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant001.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + final String abi = retMap.get("abI").toString(); + + contractAddressNoAbi = PublicMethed.deployContract(contractName, "[]", code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract( + contractAddressNoAbi, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + + contractAddressWithAbi = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract2 = PublicMethed.getContract( + contractAddressWithAbi, blockingStubFull); + Assert.assertFalse(smartContract2.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract2.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract2.getBytecode().toString().isEmpty()); + + } + } + + @Test(enabled = true, description = "TriggerConstantContract a payable function without ABI") + public void test01TriggerConstantContract() { + + String txid = ""; + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddressNoAbi, + "testPayable()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + System.out.println("Code = " + transactionExtention.getResult().getCode()); + System.out + .println("Message = " + transactionExtention.getResult().getMessage().toStringUtf8()); + + Assert + .assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_EXE_ERROR")); + Assert + .assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("Attempt to call a state modifying opcode inside STATICCALL")); + + + } + + @Test(enabled = true, description = "TriggerConstantContract a non-payable function without ABI") + public void test02TriggerConstantContract() { + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddressNoAbi, + "testNoPayable()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + System.out.println("Code = " + transactionExtention.getResult().getCode()); + System.out + .println("Message = " + transactionExtention.getResult().getMessage().toStringUtf8()); + + Assert + .assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_EXE_ERROR")); + Assert + .assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("Attempt to call a state modifying opcode inside STATICCALL")); + + + } + + @Test(enabled = true, description = "TriggerConstantContract a view function without ABI") + public void test03TriggerConstantContract() { + + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddressNoAbi, + "testView()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + } + + @Test(enabled = true, description = "TriggerConstantContract a pure function without ABI") + public void test04TriggerConstantContract() { + + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddressNoAbi, + "testPure()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + + + } + + @Test(enabled = true, description = "TriggerConstantContract a payable function with ABI") + public void test05TriggerConstantContract() { + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddressNoAbi, + "testPayable()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + System.out.println("Code = " + transactionExtention.getResult().getCode()); + System.out + .println("Message = " + transactionExtention.getResult().getMessage().toStringUtf8()); + + Assert.assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_EXE_ERROR")); + Assert.assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("Attempt to call a state modifying opcode inside STATICCALL")); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + + } + + @Test(enabled = true, description = "TriggerConstantContract a non-payable function with ABI") + public void test06TriggerConstantContract() { + + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddressWithAbi, + "testNoPayable()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + System.out.println("Code = " + transactionExtention.getResult().getCode()); + System.out + .println("Message = " + transactionExtention.getResult().getMessage().toStringUtf8()); + + Assert.assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_EXE_ERROR")); + Assert.assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("Attempt to call a state modifying opcode inside STATICCALL")); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + + } + + @Test(enabled = true, description = "TriggerConstantContract a view function with ABI") + public void test07TriggerConstantContract() { + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddressWithAbi, + "testView()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + + + } + + @Test(enabled = true, description = "TriggerConstantContract a pure function with ABI") + public void test08TriggerConstantContract() { + + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddressWithAbi, + "testPure()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + + + } + + @Test(enabled = true, description = "TriggerContract a payable function without ABI") + public void test09TriggerContract() { + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + txid = PublicMethed + .triggerContract(contractAddressNoAbi, + "testPayable()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + + } + + @Test(enabled = true, description = "TriggerContract a non-payable function without ABI") + public void test10TriggerContract() { + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + txid = PublicMethed + .triggerContract(contractAddressNoAbi, + "testNoPayable()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + + } + + @Test(enabled = true, description = "TriggerContract a view function without ABI") + public void test11TriggerContract() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + txid = PublicMethed + .triggerContract(contractAddressNoAbi, + "testView()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + + } + + @Test(enabled = true, description = "TriggerContract a pure function without ABI") + public void test12TriggerContract() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + txid = PublicMethed + .triggerContract(contractAddressNoAbi, + "testPure()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + + } + + @Test(enabled = true, description = "TriggerContract a pure function with ABI") + public void test18TriggerContract() { + + TransactionExtention transactionExtention = PublicMethed + .triggerContractForExtention(contractAddressWithAbi, + "testPure()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + + } + + @Test(enabled = true, description = "TriggerContract a payable function with ABI") + public void test19TriggerContract() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + txid = PublicMethed + .triggerContract(contractAddressWithAbi, + "testPayable()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + } + + @Test(enabled = true, description = "TriggerContract a non-payable function with ABI") + public void test20TriggerContract() { + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + txid = PublicMethed + .triggerContract(contractAddressNoAbi, + "testNoPayable()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + } + + @Test(enabled = true, description = "TriggerContract a view function with ABI") + public void test21TriggerContract() { + + TransactionExtention transactionExtention = PublicMethed + .triggerContractForExtention(contractAddressWithAbi, + "testView()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + + } + + @Test(enabled = true, description = "TriggerConstantContract a view method with ABI ,method has " + + "revert()") + public void test24TriggerConstantContract() { + + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddressWithAbi, + "testView2()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + + Assert + .assertThat(transaction.getRet(0).getRet().toString(), + containsString("FAILED")); + Assert + .assertThat(ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray()), + containsString("REVERT opcode executed")); + + + } + + @Test(enabled = true, description = "TriggerContract a view method with ABI ,method has " + + "revert()") + public void test25TriggerContract() { + + TransactionExtention transactionExtention = PublicMethed + .triggerContractForExtention(contractAddressWithAbi, + "testView2()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + + Assert.assertThat(transaction.getRet(0).getRet().toString(), + containsString("FAILED")); + Assert.assertThat(ByteArray.toStr(transactionExtention.getResult().getMessage().toByteArray()), + containsString("REVERT opcode executed")); + + + } + + @Test(enabled = true, description = "TriggerConstantContract a view method without ABI,method has" + + "revert()") + public void testTriggerConstantContract() { + + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddressNoAbi, + "testView2()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert + .assertThat(transaction.getRet(0).getRet().toString(), + containsString("FAILED")); + Assert + .assertThat(ByteArray.toStr(transactionExtention.getResult().getMessage().toByteArray()), + containsString("REVERT opcode executed")); + + + } + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant002.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant002.java new file mode 100644 index 00000000000..acc77a07a5b --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant002.java @@ -0,0 +1,161 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant002 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerConstantContract a non-payable function without ABI") + public void testTriggerConstantContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant002.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, "[]", code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddress, + "testNoPayable()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + System.out.println("Code = " + transactionExtention.getResult().getCode()); + System.out + .println("Message = " + transactionExtention.getResult().getMessage().toStringUtf8()); + + Assert + .assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_EXE_ERROR")); + Assert + .assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("Attempt to call a state modifying opcode inside STATICCALL")); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant003.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant003.java new file mode 100644 index 00000000000..bdc4e1bb730 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant003.java @@ -0,0 +1,218 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant003 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "TriggerConstantContract a view function without ABI") + public void test001TriggerConstantContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant003.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, "[]", code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddress, + "testView()", "#", false, + 0, 1000000000, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + } + + + @Test(enabled = true, description = "TriggerConstantContract a payable function with ABI") + public void test002TriggerConstantContract() { + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddress, + "testPayable()", "#", false, + 0, 1000000000, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + Assert.assertEquals("SUCESS", transaction.getRet(0).getRet().toString()); + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + + transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddress, + "testPayable()", "#", false, + 1L, 1000000000, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + transaction = transactionExtention.getTransaction(); + + result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + Assert.assertEquals("constant cannot set call value or call token value.", + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + Assert.assertEquals("FAILED", transaction.getRet(0).getRet().toString()); + + + } + /** + * constructor. + */ + + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant004.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant004.java new file mode 100644 index 00000000000..94da7df47ee --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant004.java @@ -0,0 +1,163 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant004 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerConstantContract a pure function without ABI") + public void testTriggerConstantContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant004.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, "[]", code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddress, + "testPure()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant005.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant005.java new file mode 100644 index 00000000000..bb592dccfeb --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant005.java @@ -0,0 +1,159 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant005 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "TriggerConstantContract a payable function with ABI") + public void testTriggerConstantContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant001.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddress, + "testPayable()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + System.out.println("Code = " + transactionExtention.getResult().getCode()); + System.out + .println("Message = " + transactionExtention.getResult().getMessage().toStringUtf8()); + + Assert.assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_EXE_ERROR")); + Assert.assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("Attempt to call a state modifying opcode inside STATICCALL")); + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant006.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant006.java new file mode 100644 index 00000000000..b9cb1998d4b --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant006.java @@ -0,0 +1,160 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant006 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerConstantContract a non-payable function with ABI") + public void testTriggerConstantContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant002.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddress, + "testNoPayable()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + System.out.println("Code = " + transactionExtention.getResult().getCode()); + System.out + .println("Message = " + transactionExtention.getResult().getMessage().toStringUtf8()); + + Assert.assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_EXE_ERROR")); + Assert.assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("Attempt to call a state modifying opcode inside STATICCALL")); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant007.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant007.java new file mode 100644 index 00000000000..6dc8e0f33bf --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant007.java @@ -0,0 +1,163 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant007 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerConstantContract a view function with ABI") + public void testTriggerConstantContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant003.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddress, + "testView()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant008.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant008.java new file mode 100644 index 00000000000..a714d5de1be --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant008.java @@ -0,0 +1,163 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant008 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerConstantContract a pure function with ABI") + public void testTriggerConstantContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant004.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddress, + "testPure()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant009.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant009.java new file mode 100644 index 00000000000..31c6ecc7ef7 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant009.java @@ -0,0 +1,187 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant009 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerContract a payable function without ABI") + public void testTriggerContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant001.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, "[]", code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + txid = PublicMethed + .triggerContract(contractAddress, + "testPayable()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant010.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant010.java new file mode 100644 index 00000000000..d5268d6aeb2 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant010.java @@ -0,0 +1,187 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant010 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerContract a non-payable function without ABI") + public void testTriggerContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant002.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, "[]", code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + txid = PublicMethed + .triggerContract(contractAddress, + "testNoPayable()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant011.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant011.java new file mode 100644 index 00000000000..f74c9663e93 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant011.java @@ -0,0 +1,187 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant011 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerContract a view function without ABI") + public void testTriggerContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant003.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, "[]", code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + txid = PublicMethed + .triggerContract(contractAddress, + "testView()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant012.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant012.java new file mode 100644 index 00000000000..d6d2a31738c --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant012.java @@ -0,0 +1,187 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant012 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerContract a pure function without ABI") + public void testTriggerContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant004.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, "[]", code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + + txid = PublicMethed + .triggerContract(contractAddress, + "testPure()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant013.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant013.java new file mode 100644 index 00000000000..f35c7b4c86b --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant013.java @@ -0,0 +1,257 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant013 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + byte[] returnAddressBytes = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "triggerContract a constant function created by create2") + public void test01TriggerContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant015.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String contractName1 = "TestConstract"; + HashMap retMap1 = PublicMethed.getBycodeAbi(filePath, contractName1); + String code1 = retMap1.get("byteCode").toString(); + String abi1 = retMap1.get("abI").toString(); + String txid = ""; + String num = "\"" + code1 + "\"" + "," + 1; + txid = PublicMethed + .triggerContract(contractAddress, + "deploy(bytes,uint256)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + returnAddressBytes = infoById.get().getInternalTransactions(0).getTransferToAddress() + .toByteArray(); + String returnAddress = Base58.encode58Check(returnAddressBytes); + logger.info("returnAddress:" + returnAddress); + txid = PublicMethed + .triggerContract(returnAddressBytes, + "plusOne()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById1 = null; + infoById1 = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee1 = infoById1.get().getFee(); + Long netUsed1 = infoById1.get().getReceipt().getNetUsage(); + Long energyUsed1 = infoById1.get().getReceipt().getEnergyUsage(); + Long netFee1 = infoById1.get().getReceipt().getNetFee(); + long energyUsageTotal1 = infoById1.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee1:" + fee1); + logger.info("netUsed1:" + netUsed1); + logger.info("energyUsed1:" + energyUsed1); + logger.info("netFee1:" + netFee1); + logger.info("energyUsageTotal1:" + energyUsageTotal1); + + Account infoafter1 = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter1 = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance1 = infoafter1.getBalance(); + Long afterEnergyUsed1 = resourceInfoafter1.getEnergyUsed(); + Long afterNetUsed1 = resourceInfoafter1.getNetUsed(); + Long afterFreeNetUsed1 = resourceInfoafter1.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance1); + logger.info("afterEnergyUsed:" + afterEnergyUsed1); + logger.info("afterNetUsed:" + afterNetUsed1); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed1); + + Assert.assertTrue(infoById1.get().getResultValue() == 0); + Assert.assertTrue(afterBalance1 + fee1 == afterBalance); + Assert.assertTrue(afterEnergyUsed + energyUsed1 >= afterEnergyUsed1); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById1.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + } + + + @Test(enabled = true, description = "TriggerConstantContract a constant function " + + "created by create2") + public void test15TriggerConstantContract() { + + SmartContract smartContract = PublicMethed.getContract(returnAddressBytes, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + String returnAddress = Base58.encode58Check(returnAddressBytes); + logger.info("returnAddress:" + returnAddress); + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(returnAddressBytes, + "plusOne()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant014.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant014.java new file mode 100644 index 00000000000..c35d9eea84d --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant014.java @@ -0,0 +1,252 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant014 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + byte[] returnAddressBytes = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "TriggerContract a non-constant function created by create2") + public void test01TriggerContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/ClearAbi005.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String contractName1 = "TestConstract"; + HashMap retMap1 = PublicMethed.getBycodeAbi(filePath, contractName1); + String code1 = retMap1.get("byteCode").toString(); + String abi1 = retMap1.get("abI").toString(); + String txid = ""; + String num = "\"" + code1 + "\"" + "," + 1; + txid = PublicMethed + .triggerContract(contractAddress, + "deploy(bytes,uint256)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + returnAddressBytes = infoById.get().getInternalTransactions(0).getTransferToAddress() + .toByteArray(); + String returnAddress = Base58.encode58Check(returnAddressBytes); + logger.info("returnAddress:" + returnAddress); + txid = PublicMethed + .triggerContract(returnAddressBytes, + "plusOne()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById1 = null; + infoById1 = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee1 = infoById1.get().getFee(); + Long netUsed1 = infoById1.get().getReceipt().getNetUsage(); + Long energyUsed1 = infoById1.get().getReceipt().getEnergyUsage(); + Long netFee1 = infoById1.get().getReceipt().getNetFee(); + long energyUsageTotal1 = infoById1.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee1:" + fee1); + logger.info("netUsed1:" + netUsed1); + logger.info("energyUsed1:" + energyUsed1); + logger.info("netFee1:" + netFee1); + logger.info("energyUsageTotal1:" + energyUsageTotal1); + + Account infoafter1 = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter1 = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance1 = infoafter1.getBalance(); + Long afterEnergyUsed1 = resourceInfoafter1.getEnergyUsed(); + Long afterNetUsed1 = resourceInfoafter1.getNetUsed(); + Long afterFreeNetUsed1 = resourceInfoafter1.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance1); + logger.info("afterEnergyUsed:" + afterEnergyUsed1); + logger.info("afterNetUsed:" + afterNetUsed1); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed1); + + Assert.assertTrue(infoById1.get().getResultValue() == 0); + Assert.assertTrue(afterBalance1 + fee1 == afterBalance); + Assert.assertTrue(afterEnergyUsed + energyUsed1 >= afterEnergyUsed1); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById1.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + } + + @Test(enabled = true, description = "TriggerConstantContract a non-constant function " + + "created by create2") + public void test16TriggerConstantContract() { + + String returnAddress = Base58.encode58Check(returnAddressBytes); + logger.info("returnAddress:" + returnAddress); + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(returnAddressBytes, + "plusOne()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + System.out.println("Code = " + transactionExtention.getResult().getCode()); + System.out + .println("Message = " + transactionExtention.getResult().getMessage().toStringUtf8()); + + Assert + .assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_EXE_ERROR")); + Assert + .assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("Attempt to call a state modifying opcode inside STATICCALL")); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant015.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant015.java new file mode 100644 index 00000000000..088d2c2c53e --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant015.java @@ -0,0 +1,211 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant015 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerConstantContract a constant function " + + "created by create2") + public void testTriggerConstantContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant015.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String contractName1 = "TestConstract"; + HashMap retMap1 = PublicMethed.getBycodeAbi(filePath, contractName1); + String code1 = retMap1.get("byteCode").toString(); + String abi1 = retMap1.get("abI").toString(); + String txid = ""; + String num = "\"" + code1 + "\"" + "," + 1; + txid = PublicMethed + .triggerContract(contractAddress, + "deploy(bytes,uint256)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + byte[] returnAddressBytes = infoById.get().getInternalTransactions(0).getTransferToAddress() + .toByteArray(); + SmartContract smartContract = PublicMethed.getContract(returnAddressBytes, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + String returnAddress = Base58.encode58Check(returnAddressBytes); + logger.info("returnAddress:" + returnAddress); + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(returnAddressBytes, + "plusOne()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant016.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant016.java new file mode 100644 index 00000000000..02876fe2289 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant016.java @@ -0,0 +1,206 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant016 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerConstantContract a non-constant function " + + "created by create2") + public void testTriggerConstantContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/ClearAbi005.sol"; + String contractName = "Factory"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + String contractName1 = "TestConstract"; + HashMap retMap1 = PublicMethed.getBycodeAbi(filePath, contractName1); + String code1 = retMap1.get("byteCode").toString(); + String abi1 = retMap1.get("abI").toString(); + String txid = ""; + String num = "\"" + code1 + "\"" + "," + 1; + txid = PublicMethed + .triggerContract(contractAddress, + "deploy(bytes,uint256)", num, false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + byte[] returnAddressBytes = infoById.get().getInternalTransactions(0).getTransferToAddress() + .toByteArray(); + String returnAddress = Base58.encode58Check(returnAddressBytes); + logger.info("returnAddress:" + returnAddress); + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(returnAddressBytes, + "plusOne()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + System.out.println("Code = " + transactionExtention.getResult().getCode()); + System.out + .println("Message = " + transactionExtention.getResult().getMessage().toStringUtf8()); + + Assert + .assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_EXE_ERROR")); + Assert + .assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("Attempt to call a state modifying opcode inside STATICCALL")); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant017.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant017.java new file mode 100644 index 00000000000..f43f98d8417 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant017.java @@ -0,0 +1,185 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant017 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = true, description = "TriggerConstantContract a constant function which is " + + "deployed with ABI, but cleared ABI later") + public void testTriggerConstantContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 100000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/ClearAbi001.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddress, + "testPayable()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + String txid = ""; + txid = PublicMethed + .clearContractAbi(contractAddress, contractExcAddress, contractExcKey, blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Assert.assertTrue(infoById.get().getResultValue() == 0); + + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + + TransactionExtention transactionExtention1 = PublicMethed + .triggerConstantContractForExtention(contractAddress, + "testPayable()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + Transaction transaction1 = transactionExtention1.getTransaction(); + + byte[] result1 = transactionExtention1.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction1.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention1.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result1)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result1)))); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant018.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant018.java new file mode 100644 index 00000000000..ac5c092a472 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant018.java @@ -0,0 +1,161 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant018 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerContract a pure function with ABI") + public void testTriggerContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant004.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + TransactionExtention transactionExtention = PublicMethed + .triggerContractForExtention(contractAddress, + "testPure()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant019.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant019.java new file mode 100644 index 00000000000..1c34629672a --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant019.java @@ -0,0 +1,185 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant019 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerContract a payable function with ABI") + public void testTriggerContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant001.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + txid = PublicMethed + .triggerContract(contractAddress, + "testPayable()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant020.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant020.java new file mode 100644 index 00000000000..f110a68dde6 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant020.java @@ -0,0 +1,185 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant020 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerContract a non-payable function with ABI") + public void testTriggerContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant002.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + String txid = ""; + txid = PublicMethed + .triggerContract(contractAddress, + "testNoPayable()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + Optional infoById = null; + infoById = PublicMethed.getTransactionInfoById(txid, blockingStubFull); + Long fee = infoById.get().getFee(); + Long netUsed = infoById.get().getReceipt().getNetUsage(); + Long energyUsed = infoById.get().getReceipt().getEnergyUsage(); + Long netFee = infoById.get().getReceipt().getNetFee(); + long energyUsageTotal = infoById.get().getReceipt().getEnergyUsageTotal(); + + logger.info("fee:" + fee); + logger.info("netUsed:" + netUsed); + logger.info("energyUsed:" + energyUsed); + logger.info("netFee:" + netFee); + logger.info("energyUsageTotal:" + energyUsageTotal); + + Account infoafter = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + AccountResourceMessage resourceInfoafter = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + Long afterBalance = infoafter.getBalance(); + Long afterEnergyUsed = resourceInfoafter.getEnergyUsed(); + Long afterNetUsed = resourceInfoafter.getNetUsed(); + Long afterFreeNetUsed = resourceInfoafter.getFreeNetUsed(); + logger.info("afterBalance:" + afterBalance); + logger.info("afterEnergyUsed:" + afterEnergyUsed); + logger.info("afterNetUsed:" + afterNetUsed); + logger.info("afterFreeNetUsed:" + afterFreeNetUsed); + + Assert.assertTrue(infoById.get().getResultValue() == 0); + Assert.assertTrue(afterBalance + fee == beforeBalance); + Assert.assertTrue(beforeEnergyUsed + energyUsed >= afterEnergyUsed); + Assert.assertTrue(beforeFreeNetUsed + netUsed >= afterFreeNetUsed); + Assert.assertTrue(beforeNetUsed + netUsed >= afterNetUsed); + Long returnnumber = ByteArray.toLong(ByteArray + .fromHexString(ByteArray.toHexString(infoById.get().getContractResult(0).toByteArray()))); + Assert.assertTrue(1 == returnnumber); + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant021.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant021.java new file mode 100644 index 00000000000..4bc9c426825 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant021.java @@ -0,0 +1,161 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant021 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerContract a view function with ABI") + public void testTriggerContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant003.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + TransactionExtention transactionExtention = PublicMethed + .triggerContractForExtention(contractAddress, + "testView()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert.assertEquals(1, ByteArray.toLong(ByteArray + .fromHexString(Hex + .toHexString(result)))); + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant022.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant022.java new file mode 100644 index 00000000000..b1462c4c8e8 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant022.java @@ -0,0 +1,164 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant022 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerContract a non-payable function " + + "with ABI(constant ABI)") + public void testTriggerContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant002.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = "[{\"constant\":true,\"inputs\":[],\"name\":\"testNoPayable\",\"outputs\":[{\"" + + "name\":\"z\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable" + + "\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"i\",\"outputs\":" + + "[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\"," + + "\"type\":\"function\"}]"; + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + TransactionExtention transactionExtention = PublicMethed + .triggerContractForExtention(contractAddress, + "testNoPayable()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + System.out.println("Code = " + transactionExtention.getResult().getCode()); + System.out + .println("Message = " + transactionExtention.getResult().getMessage().toStringUtf8()); + + Assert + .assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_EXE_ERROR")); + Assert + .assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("Attempt to call a state modifying opcode inside STATICCALL")); + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant023.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant023.java new file mode 100644 index 00000000000..255aadf3d16 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant023.java @@ -0,0 +1,164 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant023 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerConstantContract a non-payable function with" + + " ABI(constant ABI )") + public void testTriggerConstantContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant002.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = "[{\"constant\":true,\"inputs\":[],\"name\":\"testNoPayable\",\"outputs\":[{\"name" + + "\":\"z\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"" + + "type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"i\",\"outputs\":[{\"na" + + "me\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\"" + + ":\"function\"}]"; + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddress, + "testNoPayable()", "#", false, + 0, maxFeeLimit, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + System.out.println("Code = " + transactionExtention.getResult().getCode()); + System.out + .println("Message = " + transactionExtention.getResult().getMessage().toStringUtf8()); + + Assert + .assertThat(transactionExtention.getResult().getCode().toString(), + containsString("CONTRACT_EXE_ERROR")); + Assert + .assertThat(transactionExtention.getResult().getMessage().toStringUtf8(), + containsString("Attempt to call a state modifying opcode inside STATICCALL")); + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant024.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant024.java new file mode 100644 index 00000000000..c18cb73d435 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant024.java @@ -0,0 +1,168 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant024 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerConstantContract a view method with ABI ,method has " + + "revert()") + public void testTriggerConstantContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant024.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddress, + "testView()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + + Assert + .assertThat(transaction.getRet(0).getRet().toString(), + containsString("FAILED")); + Assert + .assertThat(ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray()), + containsString("REVERT opcode executed")); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant025.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant025.java new file mode 100644 index 00000000000..50d6b6cdc83 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant025.java @@ -0,0 +1,165 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant025 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerContract a view method with ABI ,method has " + + "revert()") + public void testTriggerContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant024.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, abi, code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertFalse(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + TransactionExtention transactionExtention = PublicMethed + .triggerContractForExtention(contractAddress, + "testView()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + + Assert.assertThat(transaction.getRet(0).getRet().toString(), + containsString("FAILED")); + Assert.assertThat(ByteArray.toStr(transactionExtention.getResult().getMessage().toByteArray()), + containsString("REVERT opcode executed")); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant026.java b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant026.java new file mode 100644 index 00000000000..802d23722a7 --- /dev/null +++ b/src/test/java/stest/tron/wallet/dailybuild/tvmnewcommand/triggerconstant/TriggerConstant026.java @@ -0,0 +1,169 @@ +package stest.tron.wallet.dailybuild.tvmnewcommand.triggerconstant; + +import static org.hamcrest.core.StringContains.containsString; + +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.util.HashMap; +import java.util.concurrent.TimeUnit; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.spongycastle.util.encoders.Hex; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.GrpcAPI.TransactionExtention; +import org.tron.api.WalletGrpc; +import org.tron.api.WalletSolidityGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.Account; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.Transaction; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class TriggerConstant026 { + + private final String testNetAccountKey = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] testNetAccountAddress = PublicMethed.getFinalAddress(testNetAccountKey); + private Long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + private ManagedChannel channelSolidity = null; + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + + private ManagedChannel channelFull1 = null; + private WalletGrpc.WalletBlockingStub blockingStubFull1 = null; + + + private WalletSolidityGrpc.WalletSolidityBlockingStub blockingStubSolidity = null; + + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(0); + private String fullnode1 = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + + private String soliditynode = Configuration.getByPath("testng.conf") + .getStringList("solidityNode.ip.list").get(0); + + byte[] contractAddress = null; + + ECKey ecKey1 = new ECKey(Utils.getRandom()); + byte[] contractExcAddress = ecKey1.getAddress(); + String contractExcKey = ByteArray.toHexString(ecKey1.getPrivKeyBytes()); + + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + + @BeforeClass(enabled = true) + public void beforeClass() { + PublicMethed.printAddress(contractExcKey); + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + channelFull1 = ManagedChannelBuilder.forTarget(fullnode1) + .usePlaintext(true) + .build(); + blockingStubFull1 = WalletGrpc.newBlockingStub(channelFull1); + + channelSolidity = ManagedChannelBuilder.forTarget(soliditynode) + .usePlaintext(true) + .build(); + blockingStubSolidity = WalletSolidityGrpc.newBlockingStub(channelSolidity); + } + + @Test(enabled = false, description = "TriggerConstantContract a view method without ABI," + + "method has revert()") + public void testTriggerConstantContract() { + Assert.assertTrue(PublicMethed + .sendcoin(contractExcAddress, 1000000000L, testNetAccountAddress, testNetAccountKey, + blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + String filePath = "src/test/resources/soliditycode/TriggerConstant004.sol"; + String contractName = "testConstantContract"; + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + contractAddress = PublicMethed.deployContract(contractName, "[]", code, "", maxFeeLimit, + 0L, 100, null, contractExcKey, + contractExcAddress, blockingStubFull); + PublicMethed.waitProduceNextBlock(blockingStubFull); + SmartContract smartContract = PublicMethed.getContract(contractAddress, blockingStubFull); + Assert.assertTrue(smartContract.getAbi().toString().isEmpty()); + Assert.assertTrue(smartContract.getName().equalsIgnoreCase(contractName)); + Assert.assertFalse(smartContract.getBytecode().toString().isEmpty()); + Account info; + + AccountResourceMessage resourceInfo = PublicMethed.getAccountResource(contractExcAddress, + blockingStubFull); + info = PublicMethed.queryAccount(contractExcKey, blockingStubFull); + Long beforeBalance = info.getBalance(); + Long beforeEnergyUsed = resourceInfo.getEnergyUsed(); + Long beforeNetUsed = resourceInfo.getNetUsed(); + Long beforeFreeNetUsed = resourceInfo.getFreeNetUsed(); + logger.info("beforeBalance:" + beforeBalance); + logger.info("beforeEnergyUsed:" + beforeEnergyUsed); + logger.info("beforeNetUsed:" + beforeNetUsed); + logger.info("beforeFreeNetUsed:" + beforeFreeNetUsed); + + TransactionExtention transactionExtention = PublicMethed + .triggerConstantContractForExtention(contractAddress, + "testView()", "#", false, + 0, 0, "0", 0, contractExcAddress, contractExcKey, blockingStubFull); + + Transaction transaction = transactionExtention.getTransaction(); + + byte[] result = transactionExtention.getConstantResult(0).toByteArray(); + System.out.println("message:" + transaction.getRet(0).getRet()); + System.out.println(":" + ByteArray + .toStr(transactionExtention.getResult().getMessage().toByteArray())); + System.out.println("Result:" + Hex.toHexString(result)); + + Assert + .assertThat(transaction.getRet(0).getRet().toString(), + containsString("FAILED")); + Assert + .assertThat(ByteArray.toStr(transactionExtention.getResult().getMessage().toByteArray()), + containsString("REVERT opcode executed")); + + + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelFull1 != null) { + channelFull1.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + if (channelSolidity != null) { + channelSolidity.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } + + +} diff --git a/src/test/java/stest/tron/wallet/mutisign/WalletTestMutiSign001.java b/src/test/java/stest/tron/wallet/mutisign/WalletTestMutiSign001.java index fd929cf07ad..e15ad7155e3 100644 --- a/src/test/java/stest/tron/wallet/mutisign/WalletTestMutiSign001.java +++ b/src/test/java/stest/tron/wallet/mutisign/WalletTestMutiSign001.java @@ -284,6 +284,7 @@ public void testMutiSign3ParticipateAssetissue() { Assert.assertNotNull(txid); + PublicMethed.waitProduceNextBlock(blockingStubFull); infoById = PublicMethed .getTransactionInfoById(txid, blockingStubFull); balanceAfter = PublicMethed.queryAccount(participateAddress, blockingStubFull) diff --git a/src/test/java/stest/tron/wallet/onlinestress/ExtCodeHashStressTest.java b/src/test/java/stest/tron/wallet/onlinestress/ExtCodeHashStressTest.java new file mode 100644 index 00000000000..43028647c2a --- /dev/null +++ b/src/test/java/stest/tron/wallet/onlinestress/ExtCodeHashStressTest.java @@ -0,0 +1,636 @@ +package stest.tron.wallet.onlinestress; + +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicLong; +import lombok.extern.slf4j.Slf4j; +import org.junit.Assert; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.api.WalletGrpc; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.Utils; +import org.tron.core.Wallet; +import org.tron.protos.Protocol.SmartContract; +import org.tron.protos.Protocol.TransactionInfo; +import stest.tron.wallet.common.client.Configuration; +import stest.tron.wallet.common.client.Parameter.CommonConstant; +import stest.tron.wallet.common.client.WalletClient; +import stest.tron.wallet.common.client.utils.Base58; +import stest.tron.wallet.common.client.utils.PublicMethed; + +@Slf4j +public class ExtCodeHashStressTest { + + private AtomicLong count = new AtomicLong(); + private AtomicLong errorCount = new AtomicLong(); + private long startTime = System.currentTimeMillis(); + + private final String testKey002 = Configuration.getByPath("testng.conf") + .getString("foundationAccount.key2"); + private final byte[] fromAddress = PublicMethed.getFinalAddress(testKey002); + + private ManagedChannel channelFull = null; + private WalletGrpc.WalletBlockingStub blockingStubFull = null; + private String fullnode = Configuration.getByPath("testng.conf") + .getStringList("fullnode.ip.list").get(1); + private long maxFeeLimit = Configuration.getByPath("testng.conf") + .getLong("defaultParameter.maxFeeLimit"); + + private byte[] extCodeHashContractAddress = null; + private byte[] normalContractAddress = null; + private byte[] testContractAddress = null; + + private byte[] dev001Address = fromAddress; + private String dev001Key = testKey002; + + private ECKey ecKey2 = new ECKey(Utils.getRandom()); + private byte[] user001Address = ecKey2.getAddress(); + private String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + @BeforeSuite + public void beforeSuite() { + Wallet wallet = new Wallet(); + Wallet.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); + } + + /** + * constructor. + */ + @BeforeClass(enabled = true) + public void beforeClass() { + + channelFull = ManagedChannelBuilder.forTarget(fullnode) + .usePlaintext(true) + .build(); + blockingStubFull = WalletGrpc.newBlockingStub(channelFull); + + PublicMethed.printAddress(dev001Key); + PublicMethed.printAddress(user001Key); + } + + + @Test(enabled = true, description = "Deploy a normal contract to be used for stress testing.") + public void test01DeployNormalContract() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHashStress.sol"; + String contractName = "TriggerNormal"; //TBVEkA72g1wFoBBVLSXFZ2Bp944oL17NeU + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + normalContractAddress = deployContract(code, abi, contractName, blockingStubFull); + + SmartContract smartContract = PublicMethed.getContract(normalContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + + @Test(enabled = true, description = "Deploy a extcodehash contract.") + public void test02DeployExtCodeHashContract() { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 100_000_000L, fromAddress, + testKey002, blockingStubFull)); + PublicMethed.waitProduceNextBlock(blockingStubFull); + + //before deploy, check account resource + AccountResourceMessage accountResource = PublicMethed.getAccountResource(dev001Address, + blockingStubFull); + long energyLimit = accountResource.getEnergyLimit(); + long energyUsage = accountResource.getEnergyUsed(); + long balanceBefore = PublicMethed.queryAccount(dev001Key, blockingStubFull).getBalance(); + logger.info("before energyLimit is " + Long.toString(energyLimit)); + logger.info("before energyUsage is " + Long.toString(energyUsage)); + logger.info("before balanceBefore is " + Long.toString(balanceBefore)); + + String filePath = "./src/test/resources/soliditycode/extCodeHashStress.sol"; + String contractName = "Trigger"; //THAx2PcAtRCerwrLGN237dahqSUfq5wLnR + HashMap retMap = PublicMethed.getBycodeAbi(filePath, contractName); + + String code = retMap.get("byteCode").toString(); + String abi = retMap.get("abI").toString(); + + extCodeHashContractAddress = deployContract(code, abi, contractName, blockingStubFull); + + SmartContract smartContract = PublicMethed.getContract(extCodeHashContractAddress, + blockingStubFull); + Assert.assertNotNull(smartContract.getAbi()); + } + + /** + * trigger. + */ + public byte[] deployContract(String bytecode, String abi, String contractName, + WalletGrpc.WalletBlockingStub blockingStubFull) { + + final String transferTokenTxid = PublicMethed + .deployContractAndGetTransactionInfoById(contractName, abi, bytecode, "", + maxFeeLimit, 0L, 0, 10000, + "0", 0, null, dev001Key, + dev001Address, blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + Optional infoById = PublicMethed + .getTransactionInfoById(transferTokenTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + if (infoById.get().getResultValue() != 0) { + Assert.fail("deploy transaction failed with message: " + infoById.get().getResMessage() + .toStringUtf8()); + } + + return infoById.get().getContractAddress().toByteArray(); + } + + /** + * trigger. + */ + public String triggerContractWithMaxFeeLimit(byte[] testAddress, byte[] user001Address, + String user001Key, long maxFeeLimit) { + Assert.assertTrue(PublicMethed.sendcoin(user001Address, 10000_000_000L, fromAddress, + testKey002, blockingStubFull)); + Assert.assertTrue(PublicMethed.freezeBalanceForReceiver(fromAddress, + PublicMethed.getFreezeBalanceCount(user001Address, user001Key, 50000L, + blockingStubFull), 0, 1, + ByteString.copyFrom(user001Address), testKey002, blockingStubFull)); + + Long callValue = Long.valueOf(0); + + String param = "\"" + Base58.encode58Check(testAddress) + "\""; + final String triggerTxid = PublicMethed.triggerContract(extCodeHashContractAddress, + "test(address)", param, false, callValue, + maxFeeLimit, "0", 0, user001Address, user001Key, + blockingStubFull); + + PublicMethed.waitProduceNextBlock(blockingStubFull); + + scheduledExecutorService + .schedule(new CheckTask(triggerTxid, blockingStubFull), 15, TimeUnit.SECONDS); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + + logger + .info("transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + + if (infoById.get().getResMessage().toStringUtf8().toLowerCase().contains("cpu")) { + throw new IllegalArgumentException(); + } + if (infoById.get().getResMessage().toStringUtf8().toLowerCase().contains("timeout")) { + throw new IllegalArgumentException(); + } + return "ok"; + } + + + /** + * trigger. + */ + public String triggerAndGetExtCodeHashList(List testAddress, byte[] user001Address, + String user001Key, long maxFeeLimit, WalletGrpc.WalletBlockingStub blockingStubFull) { + + Long callValue = Long.valueOf(0); + List params = new ArrayList<>(); + for (int i = 0; i < testAddress.size(); i++) { + params.add(Base58.encode58Check(testAddress.get(i))); + } + final String triggerTxid = PublicMethed.triggerParamListContract(extCodeHashContractAddress, + "test(address[])", Arrays.asList(params), false, callValue, + maxFeeLimit, "0", 0, user001Address, user001Key, + blockingStubFull); + + scheduledExecutorService + .schedule(new CheckTask(triggerTxid, blockingStubFull), 15, TimeUnit.SECONDS); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + logger + .info( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + + return "ok"; + + } + + /** + * trigger. + */ + public void triggerAndGetExtCodeHash(byte[] testAddress, byte[] user001Address, + String user001Key, long maxFeeLimit, WalletGrpc.WalletBlockingStub blockingStubFull) { + + Long callValue = Long.valueOf(0); + + String param = "\"" + Base58.encode58Check(testAddress) + "\""; + final String triggerTxid = PublicMethed.triggerContract(normalContractAddress, + "test(address)", param, false, callValue, + 314982000, "0", 0, user001Address, user001Key, + blockingStubFull); + + scheduledExecutorService + .schedule(new CheckTask(triggerTxid, blockingStubFull), 15, TimeUnit.SECONDS); + + Optional infoById = PublicMethed + .getTransactionInfoById(triggerTxid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + logger.info("EnergyUsageTotal: " + transactionInfo.getReceipt().getEnergyUsageTotal()); + logger.info("NetUsage: " + transactionInfo.getReceipt().getNetUsage()); + logger + .info( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + + private synchronized void wirteLine(String fileName, String line) { + try { + BufferedWriter out = new BufferedWriter(new FileWriter(fileName, true)); + out.write(line); + out.newLine(); + out.flush(); + out.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + class DeployTask implements Runnable { + + Map addressList; + CountDownLatch countDownLatch; + WalletGrpc.WalletBlockingStub stub; + int index; + + DeployTask(Map addressList, int index, CountDownLatch countDownLatch, + WalletGrpc.WalletBlockingStub stub) { + this.index = index; + this.addressList = addressList; + this.countDownLatch = countDownLatch; + this.stub = stub; + } + + @Override + public void run() { + logger.info("depoying :" + index); + String code = Configuration.getByPath("testng.conf") + .getString("code.code_veryLarge"); + String abi = Configuration.getByPath("testng.conf") + .getString("abi.abi_veryLarge"); + try { + byte[] deployedAddress = deployContract(code, abi, "test" + index, stub); + String address = Base58.encode58Check(deployedAddress); + wirteLine( + "src/test/resources/addresses2", + address); + logger.info("deployed : " + index + " " + address); + } catch (Throwable e) { + logger.error("deploy error: ", e); + } finally { + countDownLatch.countDown(); + } + } + } + + @Test(enabled = true, description = "Deploy multiple long bytecode contract " + + "and write address to file.") + public void test03DeployMultiLongByteCodeContract() { + + ExecutorService pool = Executors.newFixedThreadPool(30); + Map addressMap = new ConcurrentHashMap<>(); + int size = 50_0_000; + int stubSize = 30; + List stubs = new ArrayList<>(); + for (int i = 0; i < stubSize; i++) { + stubs.add(WalletGrpc.newBlockingStub(channelFull)); + } + + CountDownLatch count = new CountDownLatch(size); + for (int i = 0; i < size; i++) { + + String contractName = "extcodehashContract" + i; + logger.info("[" + i + "]contractName: " + contractName); + pool.submit(new DeployTask(addressMap, i, count, stubs.get(i % stubSize))); + + } + + try { + count.await(); + for (String s : addressMap.keySet()) { + System.out.println(s); + } + + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2); + + class CheckTask implements Runnable { + + String txid; + WalletGrpc.WalletBlockingStub client; + + CheckTask(String txid, WalletGrpc.WalletBlockingStub client) { + this.txid = txid; + this.client = client; + } + + @Override + public void run() { + + Optional infoById = PublicMethed + .getTransactionInfoById(this.txid, blockingStubFull); + + TransactionInfo transactionInfo = infoById.get(); + if (infoById.get().getResultValue() != 0) { + logger.error("txid:" + this.txid); + logger.error( + "transaction failed with message: " + infoById.get().getResMessage().toStringUtf8()); + } + logger.info("infoById" + infoById); + } + } + + + @Test(enabled = true, description = "Calculate the contract maxfeelimit.", + threadPoolSize = 1, invocationCount = 1) + public void test04StressGetExtCodeHashContract() { + + ECKey ecKey2 = new ECKey(Utils.getRandom()); + byte[] user001Address = ecKey2.getAddress(); + String user001Key = ByteArray.toHexString(ecKey2.getPrivKeyBytes()); + + extCodeHashContractAddress = WalletClient + .decodeFromBase58Check("TEsdDpJQrLBDPmJfDF2Ex53iMfzetqHvn9"); + + // long bytecode contract + testContractAddress = WalletClient.decodeFromBase58Check("TDqSAv8gLFXQRfug5Pr1Ev6zrEj1efC8qe"); + + HashMap retMap = new HashMap<>(); + + long feeLimit = 314982000; + // long feeLimit = 393624800; + // long feeLimit = 406731800; + + long base = 100; + long lastSuccess = feeLimit; + int failed = 0; + + for (int i = 0; i < 1000000000; i++) { + try { + String retCode = triggerContractWithMaxFeeLimit(testContractAddress, user001Address, + user001Key, + feeLimit); + logger.info("[" + i + "]retCode: " + retCode); + logger.info("[" + i + "]feeLimit: " + feeLimit); + lastSuccess = feeLimit; + base *= 2; + feeLimit += base; + failed = 0; + } catch (Exception e) { + failed++; + if (failed > 3) { + break; + } + logger.error("cpu timeout"); + feeLimit = lastSuccess; + base = 100; + } + } + } + + + @Test(enabled = true, description = "Trigger extcodeHash contract stress.") + public void test05TriggerContract() throws FileNotFoundException { + + BufferedReader reader = null; + List addresses = new ArrayList<>(); + try { + reader = new BufferedReader(new FileReader("src/test/resources/address2")); + String line = reader.readLine(); + while (line != null) { + System.out.println(line); + // read next line + line = reader.readLine(); + addresses.add(line); + } + reader.close(); + } catch (IOException e) { + e.printStackTrace(); + } + ExecutorService pool = Executors.newFixedThreadPool(50); + int stubSize = 50; + List stubs = new ArrayList<>(); + for (int i = 0; i < stubSize; i++) { + stubs.add(WalletGrpc.newBlockingStub(channelFull)); + } + + int paramsSize = 75; // the address count per trigger + int trigger = 0; + for (int i = 0; i + paramsSize < addresses.size(); i += paramsSize) { + System.err.println(trigger++); + System.err.println(i + " " + (i + paramsSize)); + pool.submit(new TriggerTask(addresses.subList(i, i + paramsSize), stubs.get( + (int) (Math.random() * 100 % stubSize)))); + } + + try { + Thread.sleep(100000000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + class TriggerTask implements Runnable { + + List addresses; + WalletGrpc.WalletBlockingStub stub; + + TriggerTask(List addresses, WalletGrpc.WalletBlockingStub stub) { + this.addresses = addresses; + this.stub = stub; + } + + @Override + public void run() { + triggerContact(this.addresses.toArray(new String[0]), stub); + } + } + + /** + * trigger. + */ + public void triggerContact(String[] testList, WalletGrpc.WalletBlockingStub stub) { + + final byte[] user001Address = fromAddress; + final String user001Key = testKey002; + + extCodeHashContractAddress = WalletClient + .decodeFromBase58Check("TJGYcUspHrwPgy72YeaVjD4Skep9Ji8Pnn"); + + final long feeLimit = 102471600; + count.getAndAdd(1); + if (count.get() % 100 == 0) { + long cost = (System.currentTimeMillis() - startTime) / 1000; + logger.info("Count:" + count.get() + ", cost:" + cost + + ", avg:" + count.get() / cost + ", errCount:" + errorCount); + } + + List addressList = new ArrayList<>(); + + for (int k = 0; k < testList.length; k++) { + addressList.add(WalletClient.decodeFromBase58Check(testList[k])); + } + triggerAndGetExtCodeHashList(addressList, user001Address, user001Key, feeLimit, stub); + } + + + @Test(enabled = true, description = "Trigger normal contract stress.") + public void test06TriggerNormalContract() throws FileNotFoundException { + + BufferedReader reader = null; + List addresses = new ArrayList<>(); + try { + reader = new BufferedReader(new FileReader( + "src/test/resources/address2")); + String line = reader.readLine(); + while (line != null) { + System.out.println(line); + // read next line + line = reader.readLine(); + addresses.add(line); + } + reader.close(); + } catch (IOException e) { + e.printStackTrace(); + } + ExecutorService pool = Executors.newFixedThreadPool(50); + int stubSize = 50; + List stubs = new ArrayList<>(); + for (int i = 0; i < stubSize; i++) { + stubs.add(WalletGrpc.newBlockingStub(channelFull)); + } + + int paramsSize = 50; + int trigger = 0; + for (int i = 0; i + paramsSize < addresses.size(); i += 1) { + System.err.println(trigger++); + System.err.println(i + " " + (i + paramsSize)); + pool.submit( + new TriggerNormalTask(addresses.subList(0, 0 + paramsSize), stubs.get( + (int) (Math.random() * 100 % stubSize)))); + } + + try { + Thread.sleep(100000000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + class TriggerNormalTask implements Runnable { + + List addresses; + WalletGrpc.WalletBlockingStub stub; + + TriggerNormalTask(List addresses, WalletGrpc.WalletBlockingStub stub) { + this.addresses = addresses; + this.stub = stub; + } + + @Override + public void run() { + triggerNormalContact(this.addresses.toArray(new String[0]), stub); + } + } + + /** + * trigger. + */ + public void triggerNormalContact(String[] testList, WalletGrpc.WalletBlockingStub stub) { + + final byte[] user001Address = fromAddress; + final String user001Key = testKey002; + + normalContractAddress = WalletClient + .decodeFromBase58Check("TFUSarvJtCSQhDifdRaioytThohLSLCjq4"); + + final long feeLimit = 51079600; + count.getAndAdd(1); + if (count.get() % 100 == 0) { + long cost = (System.currentTimeMillis() - startTime) / 1000; + logger.info("Count:" + count.get() + ", cost:" + cost + + ", avg:" + count.get() / cost + ", errCount:" + errorCount); + } + + List addressList = new ArrayList<>(); + + for (int k = 0; k < testList.length; k++) { + addressList.add(WalletClient.decodeFromBase58Check(testList[k])); + } + + triggerAndGetExtCodeHash(normalContractAddress, user001Address, + user001Key, feeLimit, stub); + } + + + /** + * constructor. + */ + @AfterClass + public void shutdown() throws InterruptedException { + if (channelFull != null) { + channelFull.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + } +} + + diff --git a/src/test/resources/soliditycode/AssertException002.sol b/src/test/resources/soliditycode/AssertException002.sol new file mode 100644 index 00000000000..2bff1dcec3e --- /dev/null +++ b/src/test/resources/soliditycode/AssertException002.sol @@ -0,0 +1,17 @@ +//pragma solidity ^0.4.0; + +contract AssertException{ + function divideIHaveArgsReturn(int x,int y) public returns (int z) { + return x / y; + } + function testAssert() public { + require(2==1); + } +} +contract C { + constructor() public payable { + assert(1==2); + } + function fun() public { + } +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/ClearAbi001.sol b/src/test/resources/soliditycode/ClearAbi001.sol new file mode 100644 index 00000000000..fccc59e14be --- /dev/null +++ b/src/test/resources/soliditycode/ClearAbi001.sol @@ -0,0 +1,7 @@ +//pragma solidity ^0.4.0; + +contract testConstantContract{ +function testPayable() public view returns (int z) { +return 1; +} +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/ClearAbi005.sol b/src/test/resources/soliditycode/ClearAbi005.sol new file mode 100644 index 00000000000..a3115398386 --- /dev/null +++ b/src/test/resources/soliditycode/ClearAbi005.sol @@ -0,0 +1,26 @@ +contract Factory { + event Deployed(address addr, uint256 salt, address sender); + function deploy(bytes memory code, uint256 salt) public returns(address){ + address addr; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + emit Deployed(addr, salt, msg.sender); + return addr; + } +} + + + +contract TestConstract { + uint public i=0; + constructor () public { + } + function plusOne() public returns(uint){ + i++; + return i; + } +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/Create2Test023.sol b/src/test/resources/soliditycode/Create2Test023.sol new file mode 100644 index 00000000000..4c3f8af9f2b --- /dev/null +++ b/src/test/resources/soliditycode/Create2Test023.sol @@ -0,0 +1,31 @@ +contract factory { + constructor() payable public { + } + + function deploy(bytes memory code, uint256 salt) public returns(address){ + Caller addr; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + return address(addr); + } + + function testCreate() payable public returns (address){ + Caller add = (new Caller).value(0)(); + return address(add); + } + + function kill( ) payable public{ + selfdestruct(msg.sender); + } +} + + + +contract Caller { + constructor() payable public {} + function test() payable public returns (uint256){return 1;} +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/Create2Test024.sol b/src/test/resources/soliditycode/Create2Test024.sol new file mode 100644 index 00000000000..f5a9d032cff --- /dev/null +++ b/src/test/resources/soliditycode/Create2Test024.sol @@ -0,0 +1,56 @@ +contract Factory { + event Deployed(address addr, uint256 salt, address sender); + function deploy(bytes memory code, uint256 salt) public returns(address){ + TestConstract addr; + TestConstract addr1; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + + addr.testSuicideNonexistentTarget(msg.sender); + addr.set(); + emit Deployed(address(addr), salt, msg.sender); + return address(addr); + } + + function deploy2(bytes memory code, uint256 salt) public returns(address){ + TestConstract addr; + TestConstract addr1; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + + //addr.testSuicideNonexistentTarget(msg.sender); + //addr.set(); + + assembly { + addr1 := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + emit Deployed(address(addr), salt, msg.sender); + return address(addr); + } +} + + + +contract TestConstract { + uint public i=1; + constructor () public { + } + + function set() public{ + i=9; + } + function testSuicideNonexistentTarget(address payable nonexistentTarget) payable public { + selfdestruct(nonexistentTarget); + } +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/Create2Test025.sol b/src/test/resources/soliditycode/Create2Test025.sol new file mode 100644 index 00000000000..87aef52b0c7 --- /dev/null +++ b/src/test/resources/soliditycode/Create2Test025.sol @@ -0,0 +1,27 @@ +contract Factory { + event Deployed(address addr, uint256 salt, address sender); + constructor() public { + } + + function create2(bytes memory code, uint256 salt) public returns(address){ + address addr; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + emit Deployed(addr, salt, msg.sender); + return addr; + } +} + +contract TestContract{ + uint256 public num; + constructor(uint256 j) public{ + num = j; + } + function getNum() public returns (uint256){ + return num; + } +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/ExtCodeHashTest010.sol b/src/test/resources/soliditycode/ExtCodeHashTest010.sol new file mode 100644 index 00000000000..bfa8a7fa0d8 --- /dev/null +++ b/src/test/resources/soliditycode/ExtCodeHashTest010.sol @@ -0,0 +1,46 @@ +contract Counter { + uint count = 0; + address payable owner; + event LogResult(bytes32 _hashBefore, bytes32 _hashAfter); + constructor() public{ + owner = msg.sender; + } + function getCodeHashSuicide(address addr) public returns (bytes32 _hashBefore){ + assembly{ + _hashBefore := extcodehash(addr) + } + selfdestruct(owner); + return _hashBefore; + } + + function getCodeHashRevert() public returns (bytes32 _hashBefore, bytes32 _hashAfter) { + address addr = address(this); + assembly { + _hashBefore := extcodehash(addr) + } + if (owner == msg.sender) { + selfdestruct(owner); + } + assembly { + _hashAfter := extcodehash(addr) + } + revert(); + emit LogResult(_hashBefore, _hashAfter); + } + + function getCodeHashCreate() public returns (bytes32 _hashBefore){ + TestContract A = (new TestContract).value(0)(); + address addr = address(A); + assembly{ + _hashBefore := extcodehash(addr) + } + revert(); + return _hashBefore; + } +} + +contract TestContract{ + uint256 count = 1; + constructor() public payable{ + } +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/ShiftCommand001.sol b/src/test/resources/soliditycode/ShiftCommand001.sol new file mode 100644 index 00000000000..574ee2b571b --- /dev/null +++ b/src/test/resources/soliditycode/ShiftCommand001.sol @@ -0,0 +1,18 @@ +contract TestBitwiseShift { + + function shlTest(uint256 num, uint256 input) public returns (bytes32 out) { + assembly { + out := shl(num, input) + } + } + function shrTest(uint256 num, uint256 input) public returns (bytes32 out) { + assembly { + out := shr(num, input) + } + } + function sarTest(uint256 num, uint256 input) public returns (bytes32 out) { + assembly { + out := sar(num, input) + } + } + } \ No newline at end of file diff --git a/src/test/resources/soliditycode/TransferFailed001.sol b/src/test/resources/soliditycode/TransferFailed001.sol new file mode 100644 index 00000000000..0a59abfde60 --- /dev/null +++ b/src/test/resources/soliditycode/TransferFailed001.sol @@ -0,0 +1,127 @@ +contract EnergyOfTransferFailedTest { + constructor() payable public { + + } + + function testTransferTokenCompiledLongMax() payable public{ + address(0x1).transferToken(1,9223372036855775827); + } + + function testTransferTokenCompiled() payable public{ + address(0x1).transferToken(1,1); + } + + function testTransferTokenCompiledLongMin() payable public{ + //address(0x1).transferToken(1,-9223372036855775828); + } + + function testTransferTokenCompiledLongMin1() payable public returns(uint256){ + return address(0x2).tokenBalance(trcToken(-9223372036855775828)); + } + + function testTransferTokenCompiled1() payable public returns(uint256){ + return address(0x1).tokenBalance(trcToken(1)); + } + + function testTransferTokenCompiledLongMax1() payable public returns(uint256){ + return address(0x2).tokenBalance(trcToken(9223372036855775827)); + } + + function testTransferTokenCompiledTokenId(uint256 tokenid) payable public returns(uint256){ + return address(0x1).tokenBalance(trcToken(tokenid)); + } + + function testTransferTokenTest(address addr ,uint256 tokenid) payable public returns(uint256){ + return addr.tokenBalance(trcToken(tokenid)); + } + + // InsufficientBalance + function testTransferTrxInsufficientBalance(uint256 i) payable public{ + msg.sender.transfer(i); + } + + function testSendTrxInsufficientBalance(uint256 i) payable public{ + msg.sender.send(i); + } + + function testTransferTokenInsufficientBalance(uint256 i,trcToken tokenId) payable public{ + msg.sender.transferToken(i, tokenId); + } + + function testCallTrxInsufficientBalance(uint256 i,address payable caller) public { + caller.call.value(i)(abi.encodeWithSignature("test()")); + } + + function testCreateTrxInsufficientBalance(uint256 i) payable public { + (new Caller).value(i)(); + } + + // NonexistentTarget + + function testSendTrxNonexistentTarget(uint256 i,address payable nonexistentTarget) payable public { + nonexistentTarget.send(i); + } + + function testTransferTrxNonexistentTarget(uint256 i,address payable nonexistentTarget) payable public { + nonexistentTarget.transfer(i); + } + + function testTransferTokenNonexistentTarget(uint256 i,address payable nonexistentTarget, trcToken tokenId) payable public { + nonexistentTarget.transferToken(i, tokenId); + } + + function testCallTrxNonexistentTarget(uint256 i,address payable nonexistentTarget) payable public { + nonexistentTarget.call.value(i)(abi.encodeWithSignature("test()")); + } + + function testSuicideNonexistentTarget(address payable nonexistentTarget) payable public { + selfdestruct(nonexistentTarget); + } + + // target is self + function testTransferTrxSelf(uint256 i) payable public{ + address payable self = address(uint160(address(this))); + self.transfer(i); + } + + function testSendTrxSelf(uint256 i) payable public{ + address payable self = address(uint160(address(this))); + self.send(i); + } + + function testTransferTokenSelf(uint256 i,trcToken tokenId) payable public{ + address payable self = address(uint160(address(this))); + self.transferToken(i, tokenId); + } + + event Deployed(address addr, uint256 salt, address sender); + function deploy(bytes memory code, uint256 salt) public returns(address){ + address addr; + assembly { + addr := create2(10, add(code, 0x20), mload(code), salt) + //if iszero(extcodesize(addr)) { + // revert(0, 0) + //} + } + //emit Deployed(addr, salt, msg.sender); + return addr; + } + function deploy2(bytes memory code, uint256 salt) public returns(address){ + address addr; + assembly { + addr := create2(300, add(code, 0x20), mload(code), salt) + //if iszero(extcodesize(addr)) { + // revert(0, 0) + //} + } + //emit Deployed(addr, salt, msg.sender); + return addr; + } +} + + + +contract Caller { + constructor() payable public {} + function test() payable public {} +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/TransferFailed005.sol b/src/test/resources/soliditycode/TransferFailed005.sol new file mode 100644 index 00000000000..aa39aafa152 --- /dev/null +++ b/src/test/resources/soliditycode/TransferFailed005.sol @@ -0,0 +1,90 @@ +contract EnergyOfTransferFailedTest { + constructor() payable public { + + } + // InsufficientBalance + function testTransferTrxInsufficientBalance(uint256 i) payable public{ + msg.sender.transfer(i); + } + + function testSendTrxInsufficientBalance(uint256 i) payable public{ + msg.sender.send(i); + } + + function testTransferTokenInsufficientBalance(uint256 i,trcToken tokenId) payable public{ + msg.sender.transferToken(i, tokenId); + } + + function testCallTrxInsufficientBalance(uint256 i,address payable caller) public returns (bool,bytes memory){ + return caller.call.value(i)(abi.encodeWithSignature("test()")); + } + + function testCreateTrxInsufficientBalance(uint256 i) payable public { + (new Caller).value(i)(); + } + + // NonexistentTarget + + function testSendTrxNonexistentTarget(uint256 i,address payable nonexistentTarget) payable public { + require(address(this).balance >= i); + nonexistentTarget.send(i); + } + + function testTransferTrxNonexistentTarget(uint256 i,address payable nonexistentTarget) payable public { + require(address(this).balance >= i); + nonexistentTarget.transfer(i); + } + + function testTransferTokenNonexistentTarget(uint256 i,address payable nonexistentTarget, trcToken tokenId) payable public { + require(address(this).balance >= i); + nonexistentTarget.transferToken(i, tokenId); + } + + function testCallTrxNonexistentTarget(uint256 i,address payable nonexistentTarget) payable public { + require(address(this).balance >= i); + nonexistentTarget.call.value(i)(abi.encodeWithSignature("test()")); + } + + function testSuicideNonexistentTarget(address payable nonexistentTarget) payable public { + selfdestruct(nonexistentTarget); + } + + // target is self + function testTransferTrxSelf(uint256 i) payable public{ + require(address(this).balance >= i); + address payable self = address(uint160(address(this))); + self.transfer(i); + } + + function testSendTrxSelf(uint256 i) payable public{ + require(address(this).balance >= i); + address payable self = address(uint160(address(this))); + self.send(i); + } + + function testTransferTokenSelf(uint256 i,trcToken tokenId) payable public{ + require(address(this).balance >= i); + address payable self = address(uint160(address(this))); + self.transferToken(i, tokenId); + } + + event Deployed(address addr, uint256 salt, address sender); + function deploy(bytes memory code, uint256 salt) public returns(address){ + address addr; + assembly { + addr := create2(10, add(code, 0x20), mload(code), salt) + //if iszero(extcodesize(addr)) { + // revert(0, 0) + //} + } + //emit Deployed(addr, salt, msg.sender); + return addr; + } +} + + + +contract Caller { + constructor() payable public {} + function test() payable public returns (uint256 ){return 1;} +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/TransferFailed006.sol b/src/test/resources/soliditycode/TransferFailed006.sol new file mode 100644 index 00000000000..aa39aafa152 --- /dev/null +++ b/src/test/resources/soliditycode/TransferFailed006.sol @@ -0,0 +1,90 @@ +contract EnergyOfTransferFailedTest { + constructor() payable public { + + } + // InsufficientBalance + function testTransferTrxInsufficientBalance(uint256 i) payable public{ + msg.sender.transfer(i); + } + + function testSendTrxInsufficientBalance(uint256 i) payable public{ + msg.sender.send(i); + } + + function testTransferTokenInsufficientBalance(uint256 i,trcToken tokenId) payable public{ + msg.sender.transferToken(i, tokenId); + } + + function testCallTrxInsufficientBalance(uint256 i,address payable caller) public returns (bool,bytes memory){ + return caller.call.value(i)(abi.encodeWithSignature("test()")); + } + + function testCreateTrxInsufficientBalance(uint256 i) payable public { + (new Caller).value(i)(); + } + + // NonexistentTarget + + function testSendTrxNonexistentTarget(uint256 i,address payable nonexistentTarget) payable public { + require(address(this).balance >= i); + nonexistentTarget.send(i); + } + + function testTransferTrxNonexistentTarget(uint256 i,address payable nonexistentTarget) payable public { + require(address(this).balance >= i); + nonexistentTarget.transfer(i); + } + + function testTransferTokenNonexistentTarget(uint256 i,address payable nonexistentTarget, trcToken tokenId) payable public { + require(address(this).balance >= i); + nonexistentTarget.transferToken(i, tokenId); + } + + function testCallTrxNonexistentTarget(uint256 i,address payable nonexistentTarget) payable public { + require(address(this).balance >= i); + nonexistentTarget.call.value(i)(abi.encodeWithSignature("test()")); + } + + function testSuicideNonexistentTarget(address payable nonexistentTarget) payable public { + selfdestruct(nonexistentTarget); + } + + // target is self + function testTransferTrxSelf(uint256 i) payable public{ + require(address(this).balance >= i); + address payable self = address(uint160(address(this))); + self.transfer(i); + } + + function testSendTrxSelf(uint256 i) payable public{ + require(address(this).balance >= i); + address payable self = address(uint160(address(this))); + self.send(i); + } + + function testTransferTokenSelf(uint256 i,trcToken tokenId) payable public{ + require(address(this).balance >= i); + address payable self = address(uint160(address(this))); + self.transferToken(i, tokenId); + } + + event Deployed(address addr, uint256 salt, address sender); + function deploy(bytes memory code, uint256 salt) public returns(address){ + address addr; + assembly { + addr := create2(10, add(code, 0x20), mload(code), salt) + //if iszero(extcodesize(addr)) { + // revert(0, 0) + //} + } + //emit Deployed(addr, salt, msg.sender); + return addr; + } +} + + + +contract Caller { + constructor() payable public {} + function test() payable public returns (uint256 ){return 1;} +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/TransferFailed007.sol b/src/test/resources/soliditycode/TransferFailed007.sol new file mode 100644 index 00000000000..aa39aafa152 --- /dev/null +++ b/src/test/resources/soliditycode/TransferFailed007.sol @@ -0,0 +1,90 @@ +contract EnergyOfTransferFailedTest { + constructor() payable public { + + } + // InsufficientBalance + function testTransferTrxInsufficientBalance(uint256 i) payable public{ + msg.sender.transfer(i); + } + + function testSendTrxInsufficientBalance(uint256 i) payable public{ + msg.sender.send(i); + } + + function testTransferTokenInsufficientBalance(uint256 i,trcToken tokenId) payable public{ + msg.sender.transferToken(i, tokenId); + } + + function testCallTrxInsufficientBalance(uint256 i,address payable caller) public returns (bool,bytes memory){ + return caller.call.value(i)(abi.encodeWithSignature("test()")); + } + + function testCreateTrxInsufficientBalance(uint256 i) payable public { + (new Caller).value(i)(); + } + + // NonexistentTarget + + function testSendTrxNonexistentTarget(uint256 i,address payable nonexistentTarget) payable public { + require(address(this).balance >= i); + nonexistentTarget.send(i); + } + + function testTransferTrxNonexistentTarget(uint256 i,address payable nonexistentTarget) payable public { + require(address(this).balance >= i); + nonexistentTarget.transfer(i); + } + + function testTransferTokenNonexistentTarget(uint256 i,address payable nonexistentTarget, trcToken tokenId) payable public { + require(address(this).balance >= i); + nonexistentTarget.transferToken(i, tokenId); + } + + function testCallTrxNonexistentTarget(uint256 i,address payable nonexistentTarget) payable public { + require(address(this).balance >= i); + nonexistentTarget.call.value(i)(abi.encodeWithSignature("test()")); + } + + function testSuicideNonexistentTarget(address payable nonexistentTarget) payable public { + selfdestruct(nonexistentTarget); + } + + // target is self + function testTransferTrxSelf(uint256 i) payable public{ + require(address(this).balance >= i); + address payable self = address(uint160(address(this))); + self.transfer(i); + } + + function testSendTrxSelf(uint256 i) payable public{ + require(address(this).balance >= i); + address payable self = address(uint160(address(this))); + self.send(i); + } + + function testTransferTokenSelf(uint256 i,trcToken tokenId) payable public{ + require(address(this).balance >= i); + address payable self = address(uint160(address(this))); + self.transferToken(i, tokenId); + } + + event Deployed(address addr, uint256 salt, address sender); + function deploy(bytes memory code, uint256 salt) public returns(address){ + address addr; + assembly { + addr := create2(10, add(code, 0x20), mload(code), salt) + //if iszero(extcodesize(addr)) { + // revert(0, 0) + //} + } + //emit Deployed(addr, salt, msg.sender); + return addr; + } +} + + + +contract Caller { + constructor() payable public {} + function test() payable public returns (uint256 ){return 1;} +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/TriggerConstant001.sol b/src/test/resources/soliditycode/TriggerConstant001.sol new file mode 100644 index 00000000000..515b9e07724 --- /dev/null +++ b/src/test/resources/soliditycode/TriggerConstant001.sol @@ -0,0 +1,28 @@ +//pragma solidity ^0.4.0; + +contract testConstantContract{ + uint256 public i; + function testPayable() public payable returns (uint256 z) { + i=1; + z=i; + return z; + } + function testNoPayable() public returns (uint256 z) { + i=1; + z=i; + return z; + } + function testView() public view returns (uint256 z) { + uint256 i=1; + return i; + } + function testPure() public pure returns (uint256 z) { + uint256 i=1; + return i; + } + function testView2() public view returns (uint256 z) { + uint256 i=1; + revert(); + return i; + } +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/TriggerConstant002.sol b/src/test/resources/soliditycode/TriggerConstant002.sol new file mode 100644 index 00000000000..44332e58c51 --- /dev/null +++ b/src/test/resources/soliditycode/TriggerConstant002.sol @@ -0,0 +1,10 @@ +//pragma solidity ^0.4.0; + +contract testConstantContract{ + uint256 public i; + function testNoPayable() public returns (uint256 z) { + i=1; + z=i; + return z; + } + } \ No newline at end of file diff --git a/src/test/resources/soliditycode/TriggerConstant003.sol b/src/test/resources/soliditycode/TriggerConstant003.sol new file mode 100644 index 00000000000..0bc41cc3751 --- /dev/null +++ b/src/test/resources/soliditycode/TriggerConstant003.sol @@ -0,0 +1,12 @@ +//pragma solidity ^0.4.0; + +contract testConstantContract{ +function testView() public view returns (uint256 z) { +uint256 i=1; +return i; +} +function testPayable() public payable returns (uint256 z) { +uint256 i=1; +return i; +} +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/TriggerConstant004.sol b/src/test/resources/soliditycode/TriggerConstant004.sol new file mode 100644 index 00000000000..fce77178ca7 --- /dev/null +++ b/src/test/resources/soliditycode/TriggerConstant004.sol @@ -0,0 +1,8 @@ +//pragma solidity ^0.4.0; + +contract testConstantContract{ +function testPure() public pure returns (uint256 z) { +uint256 i=1; +return i; +} +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/TriggerConstant015.sol b/src/test/resources/soliditycode/TriggerConstant015.sol new file mode 100644 index 00000000000..d926c43c824 --- /dev/null +++ b/src/test/resources/soliditycode/TriggerConstant015.sol @@ -0,0 +1,24 @@ +contract Factory { + event Deployed(address addr, uint256 salt, address sender); + function deploy(bytes memory code, uint256 salt) public returns(address){ + address addr; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + emit Deployed(addr, salt, msg.sender); + return addr; + } +} + + + +contract TestConstract { + constructor () public { + } + function plusOne() public returns(uint){ + return 1; + } +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/TriggerConstant024.sol b/src/test/resources/soliditycode/TriggerConstant024.sol new file mode 100644 index 00000000000..287b0fc9782 --- /dev/null +++ b/src/test/resources/soliditycode/TriggerConstant024.sol @@ -0,0 +1,9 @@ +//pragma solidity ^0.4.0; + +contract testConstantContract{ +function testView() public view returns (uint256 z) { +uint256 i=1; +revert(); +return i; +} +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/TvmNewCommand043.sol b/src/test/resources/soliditycode/TvmNewCommand043.sol new file mode 100644 index 00000000000..04d9f7dde28 --- /dev/null +++ b/src/test/resources/soliditycode/TvmNewCommand043.sol @@ -0,0 +1,18 @@ +contract TestBitwiseShift { + + function shlTest(int256 num, int256 input) public returns (bytes32 out) { + assembly { + out := shl(num, input) + } + } + function shrTest(int256 num, int256 input) public returns (bytes32 out) { + assembly { + out := shr(num, input) + } + } + function sarTest(int256 num, int256 input) public returns (bytes32 out) { + assembly { + out := sar(num, input) + } + } + } \ No newline at end of file diff --git a/src/test/resources/soliditycode/TvmNewCommand103.sol b/src/test/resources/soliditycode/TvmNewCommand103.sol new file mode 100644 index 00000000000..7ad130c87c6 --- /dev/null +++ b/src/test/resources/soliditycode/TvmNewCommand103.sol @@ -0,0 +1,8 @@ +//pragma solidity ^0.4.0; + +contract testConstantContract{ +function testView() public constant returns (uint256 z) { +uint256 i=1; +return i; +} +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/TvmNewCommand107.sol b/src/test/resources/soliditycode/TvmNewCommand107.sol new file mode 100644 index 00000000000..4dcd33ad7b0 --- /dev/null +++ b/src/test/resources/soliditycode/TvmNewCommand107.sol @@ -0,0 +1,9 @@ +//pragma solidity ^0.4.0; + + contract testConstantContract{ + int256 public i; + function testPayable() public returns (int z) { + z=1+1; + return z; + } + } \ No newline at end of file diff --git a/src/test/resources/soliditycode/TvmNewCommand108.sol b/src/test/resources/soliditycode/TvmNewCommand108.sol new file mode 100644 index 00000000000..b44d5c82731 --- /dev/null +++ b/src/test/resources/soliditycode/TvmNewCommand108.sol @@ -0,0 +1,7 @@ +//pragma solidity ^0.4.0; + + contract testConstantContract{ + function test() pure public returns (int z) { + return 1; + } + } \ No newline at end of file diff --git a/src/test/resources/soliditycode/TvmNewCommand109.sol b/src/test/resources/soliditycode/TvmNewCommand109.sol new file mode 100644 index 00000000000..864f01f7fb4 --- /dev/null +++ b/src/test/resources/soliditycode/TvmNewCommand109.sol @@ -0,0 +1,7 @@ +//pragma solidity ^0.4.0; + + contract testConstantContract{ + function test() view public returns (int z) { + return 1; + } + } \ No newline at end of file diff --git a/src/test/resources/soliditycode/TvmOldCommand001.sol b/src/test/resources/soliditycode/TvmOldCommand001.sol new file mode 100644 index 00000000000..9f3cf079ea1 --- /dev/null +++ b/src/test/resources/soliditycode/TvmOldCommand001.sol @@ -0,0 +1,11 @@ +//pragma solidity ^0.4.0; + +contract binaryRightContract{ + function binaryMoveR(int i)public returns (int z) { + return z = 5 >> i; + } + function binaryLiftR(int i)public returns (int z) { + return z = 5 << i; + } + +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/create2CallContract.sol b/src/test/resources/soliditycode/create2CallContract.sol new file mode 100644 index 00000000000..f2de1c7ee13 --- /dev/null +++ b/src/test/resources/soliditycode/create2CallContract.sol @@ -0,0 +1,37 @@ +contract callerContract { + constructor() payable public{} + function() payable external{} + function delegateCallCreate2(address called_address, bytes memory code, uint256 salt) public { + called_address.delegatecall(abi.encodeWithSignature("deploy(bytes,uint256)",code,salt)); + } + function callCreate2(address called_address,bytes memory code, uint256 salt) public returns(bool,bytes memory){ + return called_address.call(abi.encodeWithSignature("deploy(bytes,uint256)",code,salt)); + } +} + + +contract Factory { + event Deployed(address addr, uint256 salt, address sender); + function deploy(bytes memory code, uint256 salt) public returns(address){ + address addr; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + emit Deployed(addr, salt, msg.sender); + return addr; + } +} + + +contract TestConstract { + uint public i; + constructor () public { + } + function plusOne() public returns(uint){ + i++; + return i; + } +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/create2contract.sol b/src/test/resources/soliditycode/create2contract.sol new file mode 100644 index 00000000000..0171f4d5486 --- /dev/null +++ b/src/test/resources/soliditycode/create2contract.sol @@ -0,0 +1,52 @@ +contract Factory { + event Deployed(address addr, uint256 salt, address sender); + function deploy(bytes memory code, uint256 salt) public returns(address){ + address addr; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + emit Deployed(addr, salt, msg.sender); + return addr; + } + + event Deployed(address addr, bytes32 salt, address sender); + function deploy(bytes memory code, bytes32 salt) public returns(address){ + address addr; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + emit Deployed(addr, salt, msg.sender); + return addr; + } +} + +contract FactoryBytes { + event Deployed(address addr, bytes32 salt, address sender); + function deploy(bytes memory code, bytes32 salt) public returns(address){ + address addr; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + emit Deployed(addr, salt, msg.sender); + return addr; + } +} + +contract TestConstract { + uint public i; + constructor () public { + } + function plusOne() public returns(uint){ + i++; + return i; + } +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/create2contract22.sol b/src/test/resources/soliditycode/create2contract22.sol new file mode 100644 index 00000000000..c33cb08edc3 --- /dev/null +++ b/src/test/resources/soliditycode/create2contract22.sol @@ -0,0 +1,109 @@ +contract Factory { + event Deployed(address addr, trcToken salt, address sender); + event Deployed1(address addr, uint8 salt, address sender); + event Deployed2(address addr, address salt, address sender); + event Deployed3(address addr, string salt, address sender); + + + function deploy(bytes memory code, trcToken salt) public returns(address){ + address addr; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + emit Deployed(addr, salt, msg.sender); + return addr; + } + + function deploy1(bytes memory code, uint8 salt) public returns(address){ + address addr; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + emit Deployed1(addr, salt, msg.sender); + return addr; + } + + function deploy2(bytes memory code, address salt) public returns(address){ + address addr; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + emit Deployed2(addr, salt, msg.sender); + return addr; + } + + function deploy3(bytes memory code, string memory salt) public returns(address){ + address addr; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + emit Deployed3(addr, salt, msg.sender); + return addr; + } + +} + + +contract TestConstract { + uint public i=1; + function testTransfer(uint256 i) payable public{ + msg.sender.transfer(i); + } + function testTransferToken(uint256 i,trcToken tokenId) payable public{ + msg.sender.transferToken(i, tokenId); + } + function testSuicideNonexistentTarget(address payable nonexistentTarget) payable public { + selfdestruct(nonexistentTarget); + } +} + +contract TestConstract1 { + uint public i=2; + function testTransfer(uint256 i) payable public{ + msg.sender.transfer(i); + } + function testTransferToken(uint256 i,trcToken tokenId) payable public{ + msg.sender.transferToken(i, tokenId); + } + function testSuicideNonexistentTarget(address payable nonexistentTarget) payable public { + selfdestruct(nonexistentTarget); + } +} + +contract TestConstract2 { + uint public i=3; + function testTransfer(uint256 i) payable public{ + msg.sender.transfer(i); + } + function testTransferToken(uint256 i,trcToken tokenId) payable public{ + msg.sender.transferToken(i, tokenId); + } + function testSuicideNonexistentTarget(address payable nonexistentTarget) payable public { + selfdestruct(nonexistentTarget); + } +} + +contract TestConstract3 { + uint public i=4; + function testTransfer(uint256 i) payable public{ + msg.sender.transfer(i); + } + function testTransferToken(uint256 i,trcToken tokenId) payable public{ + msg.sender.transferToken(i, tokenId); + } + function testSuicideNonexistentTarget(address payable nonexistentTarget) payable public { + selfdestruct(nonexistentTarget); + } +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/create2contractn.sol b/src/test/resources/soliditycode/create2contractn.sol new file mode 100644 index 00000000000..e0e3ae64c16 --- /dev/null +++ b/src/test/resources/soliditycode/create2contractn.sol @@ -0,0 +1,29 @@ +contract Factory { + event Deployed(address addr, uint256 salt, address sender); + function deploy(bytes memory code, uint256 salt) public returns(address){ + address addr; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + emit Deployed(addr, salt, msg.sender); + return addr; + } +} + + + +contract TestConstract { + uint public i=1; + function testTransfer(uint256 i) payable public{ + msg.sender.transfer(i); + } + function testTransferToken(uint256 i,trcToken tokenId) payable public{ + msg.sender.transferToken(i, tokenId); + } + function testSuicideNonexistentTarget(address payable nonexistentTarget) payable public { + selfdestruct(nonexistentTarget); + } +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/create2contractn2.sol b/src/test/resources/soliditycode/create2contractn2.sol new file mode 100644 index 00000000000..626988c4e04 --- /dev/null +++ b/src/test/resources/soliditycode/create2contractn2.sol @@ -0,0 +1,26 @@ +contract Factory { + event Deployed(address addr, uint256 salt, address sender); + function deploy(bytes memory code, uint256 salt) public returns(address){ + address addr; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + emit Deployed(addr, salt, msg.sender); + return addr; + } +} + + + +contract TestConstract { + uint public i=1; + function set() payable public { + i=5; + } + function testSuicideNonexistentTarget(address payable nonexistentTarget) payable public { + selfdestruct(nonexistentTarget); + } +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/demo.sol b/src/test/resources/soliditycode/demo.sol new file mode 100644 index 00000000000..c7f6d0d4da9 --- /dev/null +++ b/src/test/resources/soliditycode/demo.sol @@ -0,0 +1,73 @@ +//pragma solidity ^0.4.24; + + contract tokenTest{ + uint256 codesize; + constructor() payable public{ + uint256 m; + address addr = address(this); + assembly { + m := extcodesize(addr) + } + codesize = m; + } + + // positive case + function pulsone() public payable{ + uint256 j = 0; + uint i = 100; + for (; i < i; i++) { + j++; + } + } + + + function getCodeSize() public returns (uint256){ + return codesize; + } + + } + + contract confirmTest{ + + uint256 codesize; + constructor() payable public{ + uint256 m; + address addr = address(this); + assembly { + m := extcodesize(addr) + + } + codesize = m; + } + + function getCodeSize() public returns (uint256){ + return codesize; + } + + function confirm(address addr) public returns (uint256){ + uint256 j; + assembly { + j := extcodesize(addr) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + return j; + } + + function at(address _addr) public returns (bytes memory o_code) { + assembly { + // retrieve the size of the code, this needs assembly + let size := extcodesize(_addr) + // allocate output byte array - this could also be done without assembly + // by using o_code = new bytes(size) + o_code := mload(0x40) + // new "memory end" including padding + mstore(0x40, add(o_code, and(add(add(size, 0x20), 0x1f), not(0x1f)))) + // store length in memory + mstore(o_code, size) + // actually retrieve the code, this needs assembly + extcodecopy(_addr, add(o_code, 0x20), 0, size) + } + } + } \ No newline at end of file diff --git a/src/test/resources/soliditycode/event001.sol b/src/test/resources/soliditycode/event001.sol new file mode 100644 index 00000000000..7662df3a5c6 --- /dev/null +++ b/src/test/resources/soliditycode/event001.sol @@ -0,0 +1,10 @@ +contract Event { + event xixi(uint256 id) ; + event log2(uint256,uint256,uint256); + constructor() public payable{} + function messageI() payable public returns (uint ret) { + //emit log2(1,2,3); + emit xixi(1); + return 1; + } +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/event002.sol b/src/test/resources/soliditycode/event002.sol new file mode 100644 index 00000000000..70a5275521c --- /dev/null +++ b/src/test/resources/soliditycode/event002.sol @@ -0,0 +1,52 @@ +pragma solidity >=0.4.0 <0.7.0; + +contract Event { + + event _0(); + event a_0() anonymous; + event a_4i(uint256 indexed x1, uint256 indexed x2 , uint256 indexed x3, uint256 indexed x4, uint256 x5)anonymous ; + event _3i(uint256 x1, uint256 indexed x2 , uint256 indexed x3, uint256 x4, uint256 x5) ; + event _1i(uint256 indexed x1, uint256, uint256 indexed, uint256 x4) ; + event a_1i(uint256) anonymous; + event _ai(uint8[2], uint8) ; + event a_ai(uint8[2], uint8) anonymous; + event _a1i(uint8[2] indexed, uint8) ; + event a_a1i(uint8[2] indexed, uint8) anonymous; + + constructor () public { + // emit a_0(); + // emit a_1i(123); + // emit a_4i(1,2,3,5,16); + // emit _0(); + emit _3i(1,2,3,5,16); + // emit _1i(1,2,3,5); + // emit _ai([1,2], 3); + // emit a_ai([3,4], 5); + // emit _a1i([1,2], 3); + // emit a_a1i([3,4], 5); + } + + function e() public { + emit _1i(1,2,3,4); + } + + function l() public { + emit a_1i(1); + } + + function k() public{ + emit a_4i(2,3,4,5,17); + emit _3i(2,3,4,5,16); + emit _1i(2,3,4,5); + emit a_1i(128); + emit _0(); + emit a_0(); + //selfdestruct(msg.sender); + //emit a_4i(1,2,3,5,16); + //emit _3i(1,2,3,5,16); + //emit _1i(1,2,3,5); + //emit a_1i(123); + //emit _0(); + //emit a_0(); + } +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/extCodeHash.sol b/src/test/resources/soliditycode/extCodeHash.sol new file mode 100644 index 00000000000..d6209770682 --- /dev/null +++ b/src/test/resources/soliditycode/extCodeHash.sol @@ -0,0 +1,13 @@ +contract TestExtCodeHash { + + function getCodeHashByAddr(address _addr) public returns (bytes32 _hash) { + assembly { + _hash := extcodehash(_addr) + } + } + function getCodeHashByUint(uint256 _addr) public returns (bytes32 _hash) { + assembly { + _hash := extcodehash(_addr) + } + } +} diff --git a/src/test/resources/soliditycode/extCodeHash11.sol b/src/test/resources/soliditycode/extCodeHash11.sol new file mode 100644 index 00000000000..ad59f6cce1c --- /dev/null +++ b/src/test/resources/soliditycode/extCodeHash11.sol @@ -0,0 +1,103 @@ +contract Counter { +uint count = 0; +address payable owner; +event LogResult(bytes32 _hashBefore, bytes32 _hashAfter); +constructor() public{ +owner = msg.sender; +} +function getCodeHashByAddr() public returns (bytes32 _hashBefore, bytes32 _hashAfter) { +address addr = address(this); +assembly { +_hashBefore := extcodehash(addr) +} +if (owner == msg.sender) { +selfdestruct(owner); +} +assembly { +_hashAfter := extcodehash(addr) +} +revert(); +emit LogResult(_hashBefore, _hashAfter); +} +} + +contract Counter1 { +uint count = 0; +address payable owner; +event LogResult(bytes32 _hashBefore, bytes32 _hashAfter); +constructor() public{ +owner = msg.sender; +} +function getCodeHashByAddr() public returns (bytes32 _hashBefore, bytes32 _hashAfter) { +address addr = address(this); +assembly { +_hashBefore := extcodehash(addr) +} +if (owner == msg.sender) { +selfdestruct(owner); +} +assembly { +_hashAfter := extcodehash(addr) +} + +emit LogResult(_hashBefore, _hashAfter); +} +} + + +contract Counter2 { +uint count = 0; +address payable owner; +event LogResult(bytes32 _hashBefore, bytes32 _hashAfter); +constructor() public{ +owner = msg.sender; +} +function getCodeHashByAddr(address c) public returns (bytes32 _hashBefore, bytes32 _hashAfter) { + TestConstract t=new TestConstract(); +address addr = address(t); +assembly { +_hashBefore := extcodehash(addr) +} + addr.call(abi.encodeWithSignature("testSuicideNonexistentTarget(address)",c)); + + +assembly { +_hashAfter := extcodehash(addr) +} + +emit LogResult(_hashBefore, _hashAfter); +} +} + + +contract Counter3 { +uint count = 0; +address payable owner; +event LogResult(bytes32 _hashBefore, bytes32 _hashAfter); +constructor() public{ +owner = msg.sender; +} +function getCodeHashByAddr(address c) public returns (bytes32 _hashBefore, bytes32 _hashAfter) { + TestConstract t=new TestConstract(); +address addr = address(t); +assembly { +_hashBefore := extcodehash(addr) +} +if (owner == msg.sender) { +selfdestruct(owner); +} + +assembly { +_hashAfter := extcodehash(addr) +} + +emit LogResult(_hashBefore, _hashAfter); +} +} + +contract TestConstract { + uint public i=1; + function testSuicideNonexistentTarget(address payable nonexistentTarget) payable public { + selfdestruct(nonexistentTarget); + } +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/extCodeHashConstruct.sol b/src/test/resources/soliditycode/extCodeHashConstruct.sol new file mode 100644 index 00000000000..6bb91b3d3b1 --- /dev/null +++ b/src/test/resources/soliditycode/extCodeHashConstruct.sol @@ -0,0 +1,14 @@ +contract CounterConstruct { + uint count = 0; + address payable owner; + event LogResult(bytes32 _hashBefore); + constructor() public{ + owner = msg.sender; + address addr = address(this); + bytes32 _hashBefore; + assembly { + _hashBefore := extcodehash(addr) + } + emit LogResult(_hashBefore); + } + } \ No newline at end of file diff --git a/src/test/resources/soliditycode/extCodeHashStress.sol b/src/test/resources/soliditycode/extCodeHashStress.sol new file mode 100644 index 00000000000..0d8ceadf219 --- /dev/null +++ b/src/test/resources/soliditycode/extCodeHashStress.sol @@ -0,0 +1,45 @@ +contract Trigger { + function test(address addr) public returns(uint i) { + bytes32 hash; + while (gasleft() > 1000) { + assembly { + hash := extcodehash(addr) + } + i++; + } + } + + function test(address[] memory addrs) public returns(uint i) { + bytes32 hash; + uint i = 0; + for (; i < addrs.length; i++) { + address addr = addrs[i]; + assembly { + hash := extcodehash(addr) + } + } + return i; + } + } + + + + contract TriggerNormal { + function test(address addr) public returns(uint i) { + i = 0; + while (gasleft() > 100000) { + i++; + } + } + } + + contract TriggerNormal { + function test(address[] memory addrs) public returns(uint i) { + bytes32 hash; + uint i = 0; + for (; i < addrs.length; i++) { + address addr = addrs[i]; + addr.balance; + } + } + } \ No newline at end of file diff --git a/src/test/resources/soliditycode/extCodeHashTestNoPayable.sol b/src/test/resources/soliditycode/extCodeHashTestNoPayable.sol new file mode 100644 index 00000000000..c3a2ad8c6ae --- /dev/null +++ b/src/test/resources/soliditycode/extCodeHashTestNoPayable.sol @@ -0,0 +1,8 @@ +contract testConstantContract{ +uint256 public i; +function testNoPayable() public returns (uint256 z) { +i=1; +z=i; +return z; +} +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/suicide001.sol b/src/test/resources/soliditycode/suicide001.sol new file mode 100644 index 00000000000..3544f8bf84a --- /dev/null +++ b/src/test/resources/soliditycode/suicide001.sol @@ -0,0 +1,32 @@ +contract factory { + constructor() payable public { + } + + function create1() payable public returns (address){ + Caller add = (new Caller).value(0)(); + return address(add); + } + + function kill() payable public{ + selfdestruct(msg.sender); + } + + function create2(bytes memory code, uint256 salt) public returns(address){ + Caller addr; + Caller addr1; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + return address(addr); + } +} + + + +contract Caller { + constructor() payable public {} + function test() payable public returns (uint256){return 1;} +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/suicide002.sol b/src/test/resources/soliditycode/suicide002.sol new file mode 100644 index 00000000000..160ab64f320 --- /dev/null +++ b/src/test/resources/soliditycode/suicide002.sol @@ -0,0 +1,43 @@ +contract Factory { + uint256 public num; + event Deployed(address addr, uint256 salt, address sender); + constructor() public { + } + function deploy(bytes memory code, uint256 salt) public returns(address){ + TestConstract addr; + TestConstract addr1; + assembly { + addr := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + + addr.testSuicideNonexistentTarget(msg.sender); + addr.set(); + + assembly { + addr1 := create2(0, add(code, 0x20), mload(code), salt) + if iszero(extcodesize(addr)) { + revert(0, 0) + } + } + emit Deployed(address(addr), salt, msg.sender); + return address(addr); + } +} + + + +contract TestConstract { + uint public i=1; + constructor () public { + } + + function set() public{ + i=9; + } + function testSuicideNonexistentTarget(address payable nonexistentTarget) payable public { + selfdestruct(nonexistentTarget); + } +} \ No newline at end of file diff --git a/src/test/resources/soliditycode/testOutOfMem.sol b/src/test/resources/soliditycode/testOutOfMem.sol new file mode 100644 index 00000000000..8d285b28b7d --- /dev/null +++ b/src/test/resources/soliditycode/testOutOfMem.sol @@ -0,0 +1,7 @@ +contract Test { + function testOutOfMem(uint256 x) public returns(bytes32 r) { + uint[] memory memVar; + memVar = new uint[](x); + } + +} \ No newline at end of file diff --git a/src/test/resources/soliditycode_v0.4.25/TransferFailed001.sol b/src/test/resources/soliditycode_v0.4.25/TransferFailed001.sol new file mode 100644 index 00000000000..e69de29bb2d diff --git a/src/test/resources/soliditycode_v0.4.25/TransferFailed005.sol b/src/test/resources/soliditycode_v0.4.25/TransferFailed005.sol new file mode 100644 index 00000000000..d3179a30191 --- /dev/null +++ b/src/test/resources/soliditycode_v0.4.25/TransferFailed005.sol @@ -0,0 +1,106 @@ +contract EnergyOfTransferFailedTest { + constructor() payable public { + + } + function testTransferTokenCompiledLongMax() payable public{ + address(0x1).transferToken(1,9223372036855775827); + } + + function testTransferTokenCompiledLongMin() payable public{ + //address(0x1).transferToken(1,-9223372036855775828); + } + + function testTransferTokenCompiledLongMin1() payable public{ + address(0x1).tokenBalance(trcToken(-9223372036855775828)); + } + + function testTransferTokenCompiledLongMax1() payable public{ + address(0x1).tokenBalance(trcToken(9223372036855775827)); + } + + // InsufficientBalance + function testTransferTrxInsufficientBalance(uint256 i) payable public{ + msg.sender.transfer(i); + } + + function testSendTrxInsufficientBalance(uint256 i) payable public{ + msg.sender.send(i); + } + + function testTransferTokenInsufficientBalance(uint256 i,trcToken tokenId) payable public{ + msg.sender.transferToken(i, tokenId); + } + + function testCallTrxInsufficientBalance(uint256 i,address caller) public returns (bool){ + return caller.call.value(i)(abi.encodeWithSignature("test()")); + } + + function testCreateTrxInsufficientBalance(uint256 i) payable public { + (new Caller).value(i)(); + } + + // NonexistentTarget + + function testSendTrxNonexistentTarget(uint256 i,address nonexistentTarget) payable public { + require(address(this).balance >= i); + nonexistentTarget.send(i); + } + + function testTransferTrxNonexistentTarget(uint256 i,address nonexistentTarget) payable public { + require(address(this).balance >= i); + nonexistentTarget.transfer(i); + } + + function testTransferTokenNonexistentTarget(uint256 i,address nonexistentTarget, trcToken tokenId) payable public { + require(address(this).balance >= i); + nonexistentTarget.transferToken(i, tokenId); + } + + function testCallTrxNonexistentTarget(uint256 i,address nonexistentTarget) payable public { + require(address(this).balance >= i); + nonexistentTarget.call.value(i)(abi.encodeWithSignature("test()")); + } + + function testSuicideNonexistentTarget(address nonexistentTarget) payable public { + selfdestruct(nonexistentTarget); + } + + // target is self + function testTransferTrxSelf(uint256 i) payable public{ + require(address(this).balance >= i); + address self = address(uint160(address(this))); + self.transfer(i); + } + + function testSendTrxSelf(uint256 i) payable public{ + require(address(this).balance >= i); + address self = address(uint160(address(this))); + self.send(i); + } + + function testTransferTokenSelf(uint256 i,trcToken tokenId) payable public{ + require(address(this).balance >= i); + address self = address(uint160(address(this))); + self.transferToken(i, tokenId); + } + + event Deployed(address addr, uint256 salt, address sender); + function deploy(bytes memory code, uint256 salt) public returns(address){ + address addr; + assembly { + addr := create2(10, add(code, 0x20), mload(code), salt) + //if iszero(extcodesize(addr)) { + // revert(0, 0) + //} + } + //emit Deployed(addr, salt, msg.sender); + return addr; + } +} + + + +contract Caller { + constructor() payable public {} + function test() payable public returns (uint256 ){return 1;} +} \ No newline at end of file diff --git a/src/test/resources/soliditycode_v0.4.25/TransferFailed007.sol b/src/test/resources/soliditycode_v0.4.25/TransferFailed007.sol new file mode 100644 index 00000000000..ffd6f10c486 --- /dev/null +++ b/src/test/resources/soliditycode_v0.4.25/TransferFailed007.sol @@ -0,0 +1,90 @@ +contract EnergyOfTransferFailedTest { + constructor() payable public { + + } + // InsufficientBalance + function testTransferTrxInsufficientBalance(uint256 i) payable public{ + msg.sender.transfer(i); + } + + function testSendTrxInsufficientBalance(uint256 i) payable public{ + msg.sender.send(i); + } + + function testTransferTokenInsufficientBalance(uint256 i,trcToken tokenId) payable public{ + msg.sender.transferToken(i, tokenId); + } + + function testCallTrxInsufficientBalance(uint256 i,address caller) public returns (bool){ + return caller.call.value(i)(abi.encodeWithSignature("test()")); + } + + function testCreateTrxInsufficientBalance(uint256 i) payable public { + (new Caller).value(i)(); + } + + // NonexistentTarget + + function testSendTrxNonexistentTarget(uint256 i,address nonexistentTarget) payable public { + require(address(this).balance >= i); + nonexistentTarget.send(i); + } + + function testTransferTrxNonexistentTarget(uint256 i,address nonexistentTarget) payable public { + require(address(this).balance >= i); + nonexistentTarget.transfer(i); + } + + function testTransferTokenNonexistentTarget(uint256 i,address nonexistentTarget, trcToken tokenId) payable public { + require(address(this).balance >= i); + nonexistentTarget.transferToken(i, tokenId); + } + + function testCallTrxNonexistentTarget(uint256 i,address nonexistentTarget) payable public { + require(address(this).balance >= i); + nonexistentTarget.call.value(i)(abi.encodeWithSignature("test()")); + } + + function testSuicideNonexistentTarget(address nonexistentTarget) payable public { + selfdestruct(nonexistentTarget); + } + + // target is self + function testTransferTrxSelf(uint256 i) payable public{ + require(address(this).balance >= i); + address self = address(uint160(address(this))); + self.transfer(i); + } + + function testSendTrxSelf(uint256 i) payable public{ + require(address(this).balance >= i); + address self = address(uint160(address(this))); + self.send(i); + } + + function testTransferTokenSelf(uint256 i,trcToken tokenId) payable public{ + require(address(this).balance >= i); + address self = address(uint160(address(this))); + self.transferToken(i, tokenId); + } + + event Deployed(address addr, uint256 salt, address sender); + function deploy(bytes memory code, uint256 salt) public returns(address){ + address addr; + assembly { + addr := create2(10, add(code, 0x20), mload(code), salt) + //if iszero(extcodesize(addr)) { + // revert(0, 0) + //} + } + //emit Deployed(addr, salt, msg.sender); + return addr; + } +} + + + +contract Caller { + constructor() payable public {} + function test() payable public returns (uint256 ){return 1;} +} \ No newline at end of file diff --git a/src/test/resources/testng.conf b/src/test/resources/testng.conf index 3566037bfd9..ce61b5a04d7 100644 --- a/src/test/resources/testng.conf +++ b/src/test/resources/testng.conf @@ -20,10 +20,13 @@ fullnode = { #Replay env #"47.94.239.172:50051", #"39.105.89.183:50051", + #New beat1 + #"39.106.145.222:50052", + #"101.200.46.37:50052", #New beta1 - "47.94.197.215:50051", - "101.200.52.146:50051", + #"47.94.197.215:50051", + #"101.200.52.146:50051", #New beta2 @@ -51,15 +54,19 @@ solidityNode = { #"47.94.135.251:50051", #"47.94.9.222:50061", #new beta1 - #"47.94.197.215:18895", - #new beta2 - #"101.200.52.146:18895", + #"101.200.46.37:50053", + #"101.200.46.37:50062", + #new beta2 + "101.200.52.146:18895", ] } httpnode = { ip.list = [ + #"101.200.46.37:50191", + #"39.106.145.222:50093", + #"101.200.46.37:50094", #"39.105.89.183:8090", #"39.107.248.113:8090", #"39.105.89.183:8091", @@ -69,9 +76,9 @@ httpnode = { "127.0.0.1:8093", "127.0.0.1:8097", - "47.94.197.215:8091", - "101.200.52.146:8091", - "47.94.197.215:8097", + #"47.94.197.215:8091", + #"101.200.52.146:8091", + #"47.94.197.215:8097", ] } @@ -81,12 +88,11 @@ foundationAccount = { key1 = FC8BF0238748587B9617EB6D15D47A66C0E07C1A1959033CF249C6532DC29FE6 key2 = 6815B367FDDE637E53E9ADC8E69424E07724333C9A2B973CFA469975E20753FC #Main_in_mock_foundationAccount_key - + #key1 = 7c4977817417495f4ca0c35ab3d5a25e247355d68f89f593f3fea2ab62c8644f + #key2 = 1fe1d91bbe3ac4ac5dc9866c157ef7615ec248e3fd4f7d2b49b0428da5e046b2 #key1 = 324a2052e491e99026442d81df4d2777292840c1b3949e20696c49096c6bacb8 #key2 = 2925e186bb1e88988855f11ebf20ea3a6e19ed92328b0ffb576122e769d45b68 - - } @@ -155,11 +161,14 @@ defaultParameter = { httpConnectionTimeout = 2000 httpSoTimeout = 2000 createWitnessAmount = 9999000000 - operations = 7fff1fc0037e0000000000000000000000000000000000000000000000000000 + operations = 7fff1fc0037e0100000000000000000000000000000000000000000000000000 delayTransactionFee = 100000 cancleDelayTransactionFee = 50000 solidityCompilerVersion = "v5" solidityCompile = "solcDIR/solc" + zenTokenOwnerKey = 2925e186bb1e88988855f11ebf20ea3a6e19ed92328b0ffb576122e769d45b68 + zenTokenId = 1000001 + zenTokenFee = 10000000 } @@ -324,6 +333,7 @@ code = { code_ContractTrcToken078_AddressTest4 = "6080604052610264806100136000396000f30060806040526004361061003d5763ffffffff60e060020a600035041663648efe8b811461003f578063b45f578b14610059578063d818452114610073575b005b61003d600160a060020a036004358116906024351661008d565b61003d600160a060020a036004358116906024351661011c565b61003d600160a060020a03600435811690602435166101a9565b81600160a060020a031660405180807f7472616e73666572546f286164647265737329000000000000000000000000008152506013019050604051809103902060e060020a9004826040518263ffffffff1660e060020a0281526004018082600160a060020a0316600160a060020a031681526020019150506000604051808303816000875af2505050505050565b81600160a060020a031660405180807f7472616e73666572546f286164647265737329000000000000000000000000008152506013019050604051809103902060e060020a9004826040518263ffffffff1660e060020a0281526004018082600160a060020a0316600160a060020a03168152602001915050600060405180830381865af4505050505050565b81600160a060020a031660405180807f7472616e73666572546f286164647265737329000000000000000000000000008152506013019050604051809103902060e060020a9004826040518263ffffffff1660e060020a0281526004018082600160a060020a0316600160a060020a031681526020019150506000604051808303816000875af15050505050505600a165627a7a7230582068a85b5cb5a41f10a7ba8250baed5adf37129ff04399bccae69e483fc85448a90029" code_ContractTrcToken078_AddressTest5 = "6080604052610166806100136000396000f3006080604052600436106100325763ffffffff60e060020a6000350416630223024e8114610034578063a03fa7e314610055575b005b61003273ffffffffffffffffffffffffffffffffffffffff60043516610076565b61003273ffffffffffffffffffffffffffffffffffffffff600435166100f7565b8073ffffffffffffffffffffffffffffffffffffffff16600560405180807f73657449282900000000000000000000000000000000000000000000000000008152506006019050604051809103902060e060020a9004906040518263ffffffff1660e060020a02815260040160006040518083038185885af1505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff82169060009060059082818181858883f19350505050158015610136573d6000803e3d6000fd5b50505600a165627a7a72305820ede28ac9884104396c5d52bbf3f480cb637f61bc331c2dc561670e6d2700ad630029" code_ContractTrcToken078_AddressTest6 = "6080604052610172806100136000396000f30060806040526004361061004b5763ffffffff7c010000000000000000000000000000000000000000000000000000000060003504166367e404ce8114610087578063938b5f32146100df575b6040805132815233602082015281517fdaf0d4aa9a5679e832ac921da67b43572b4326ee2565442d3ed255b48cfb5161929181900390910190a1005b34801561009357600080fd5b50d380156100a057600080fd5b50d280156100ad57600080fd5b506100b661010e565b6040805173ffffffffffffffffffffffffffffffffffffffff9092168252519081900360200190f35b3480156100eb57600080fd5b50d380156100f857600080fd5b50d2801561010557600080fd5b506100b661012a565b60015473ffffffffffffffffffffffffffffffffffffffff1681565b60005473ffffffffffffffffffffffffffffffffffffffff16815600a165627a7a7230582084426e82a8fde9cefb0ae9f1561ce743354adada27d217c8614c28829eecbcda0029" + code_veryLarge = "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" code_Scenario015_TRC20_TRON = "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" } @@ -498,5 +508,6 @@ abi = { abi_ContractTrcToken078_AddressTest5 = "[{\"constant\":false,\"inputs\":[{\"name\":\"c\",\"type\":\"address\"}],\"name\":\"setIinC\",\"outputs\":[],\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"toAddress\",\"type\":\"address\"}],\"name\":\"transferTo\",\"outputs\":[],\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"fallback\"}]" abi_ContractTrcToken078_AddressTest6 = "[{\"constant\":true,\"inputs\":[],\"name\":\"sender\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"origin\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"\",\"type\":\"address\"}],\"name\":\"log\",\"type\":\"event\"}]" + abi_veryLarge = "[{\"constant\":false,\"inputs\":[],\"name\":\"getBalance\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"Address\",\"type\":\"address\"}],\"name\":\"transfer\",\"outputs\":[],\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"num\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"constructor\"}]" } \ No newline at end of file diff --git a/start.sh b/start.sh index 657b88ed320..849d18450fc 100644 --- a/start.sh +++ b/start.sh @@ -1,3 +1,46 @@ #!/bin/bash -kill -9 `cat /home/tron/pid.txt` -nohup java -jar /home/tron/java-tron/java-tron.jar -p $LOCAL_WITNESS_PRIVATE_KEY --witness -c /home/tron/config.conf > /home/tron/tron-shell.log 2>&1 & echo $! >/home/tron/pid.txt \ No newline at end of file +APP=$1 +APP=${APP:-"FullNode"} +START_OPT=`echo ${@:2}` +JAR_NAME="$APP.jar" +MAX_STOP_TIME=60 + +checkpid() { + pid=`ps -ef | grep $JAR_NAME |grep -v grep | awk '{print $2}'` + return $pid +} + +stopService() { + count=1 + while [ $count -le $MAX_STOP_TIME ]; do + checkpid + if [ $pid ]; then + kill -15 $pid + sleep 1 + else + echo "java-tron stop" + return + fi + count=$[$count+1] + if [ $count -eq $MAX_STOP_TIME ]; then + kill -9 $pid + sleep 1 + fi + done +} + +startService() { + echo `date` >> start.log + total=`cat /proc/meminfo |grep MemTotal |awk -F ' ' '{print $2}'` + xmx=`echo "$total/1024/1024*0.8" | bc |awk -F. '{print $1"g"}'` + logtime=`date +%Y-%m-%d_%H-%M-%S` + nohup java -Xmx$xmx -XX:+UseConcMarkSweepGC -XX:+PrintGCDetails -Xloggc:./gc.log\ + -XX:+PrintGCDateStamps -XX:+CMSParallelRemarkEnabled -XX:ReservedCodeCacheSize=256m\ + -XX:+CMSScavengeBeforeRemark -jar $JAR_NAME $START_OPT -c config.conf >> start.log 2>&1 & + + pid=`ps -ef |grep $JAR_NAME |grep -v grep |awk '{print $2}'` + echo "start java-tron with pid $pid on $HOSTNAME" +} + +stopService +startService