Merge branch 'master' into hotfix/v3.2.2_energy_limit

Author: nanfengpo

src/main/java/org/tron/core/config/Parameter.java

@@ -23,7 +23,7 @@ interface ChainConstant {
     int BLOCK_FILLED_SLOTS_NUMBER = 128;
     int MAX_VOTE_NUMBER = 30;
     int MAX_FROZEN_NUMBER = 1;
-    int BLOCK_VERSION = 5;
+    int BLOCK_VERSION = 6;
   }
 
   interface NodeConstant {

src/main/java/org/tron/core/db/Manager.java

@@ -1604,13 +1604,8 @@ public synchronized void preValidateTransactionSign(BlockCapsule block)
   }
 
   public void rePush(TransactionCapsule tx) {
-
-    try {
-      if (transactionStore.get(tx.getTransactionId().getBytes()) != null) {
-        return;
-      }
-    } catch (BadItemException e) {
-      // do nothing
+    if (transactionStore.has(tx.getTransactionId().getBytes())) {
+      return;
     }
 
     try {

src/main/java/org/tron/program/SolidityNode.java

@@ -25,7 +25,6 @@
 import org.tron.core.config.DefaultConfig;
 import org.tron.core.config.args.Args;
 import org.tron.core.db.Manager;
-import org.tron.core.net.message.BlockMessage;
 import org.tron.core.services.RpcApiService;
 import org.tron.core.services.http.solidity.SolidityNodeHttpApiService;
 import org.tron.protos.Protocol.Block;
@@ -51,7 +50,7 @@ public class SolidityNode {
 
   private AtomicLong lastSolidityBlockNum = new AtomicLong();
 
-  private long startTime = System.currentTimeMillis();
+  private int maxBlockCacheSize = 10_000;
 
   private volatile boolean syncFlag = true;
 
@@ -89,7 +88,7 @@ private void getSyncBlock() {
     long blockNum = getNextSyncBlockId();
     while (blockNum != 0) {
       try {
-        if (blockMap.size() > 10000) {
+        if (blockMap.size() > maxBlockCacheSize) {
           sleep(1000);
           continue;
         }
@@ -137,7 +136,7 @@ private void getAdvBlock() {
     long blockNum = ID.incrementAndGet();
     while (flag) {
       try {
-        if (blockNum > remoteLastSolidityBlockNum.get()) {
+        if (blockNum > remoteLastSolidityBlockNum.get() || blockMap.size() > maxBlockCacheSize) {
           sleep(3000);
           remoteLastSolidityBlockNum.set(getLastSolidityBlockNum());
           continue;
@@ -200,12 +199,11 @@ private void processBlock() {
         loopProcessBlock(block);
         blockBakQueue.put(block);
         logger.info(
-            "Success to process block: {}, blockMapSize: {}, blockQueueSize: {}, blockBakQueue: {}, cost {}.",
+            "Success to process block: {}, blockMapSize: {}, blockQueueSize: {}, blockBakQueue: {}.",
             block.getBlockHeader().getRawData().getNumber(),
             blockMap.size(),
             blockQueue.size(),
-            blockBakQueue.size(),
-            (System.currentTimeMillis() - startTime));
+            blockBakQueue.size());
       } catch (Exception e) {
         logger.error(e.getMessage());
         sleep(100);

src/test/java/org/tron/core/net/node/BroadTest.java

@@ -176,7 +176,7 @@ public void testConsumerAdvObjToFetch() throws InterruptedException {
         }
       }
     }
-    Assert.assertTrue(count >= 2);
+    Assert.assertTrue(count >= 1);
   }
 
   private static boolean go = false;

src/test/java/stest/tron/wallet/account/WalletTestAccount006.java

@@ -70,6 +70,9 @@ public void beforeClass() {
 
   @Test(enabled = true)
   public void testGetAccountNet() {
+    ecKey = new ECKey(Utils.getRandom());
+    account006Address = ecKey.getAddress();
+    account006Key = ByteArray.toHexString(ecKey.getPrivKeyBytes());
     //Sendcoin to this account
     ByteString addressBS1 = ByteString.copyFrom(account006Address);
     Account request1 = Account.newBuilder().setAddress(addressBS1).build();

src/test/java/stest/tron/wallet/account/WalletTestAccount011.java

@@ -1,5 +1,6 @@
 package stest.tron.wallet.account;
 
+import com.google.protobuf.ByteString;
 import io.grpc.ManagedChannel;
 import io.grpc.ManagedChannelBuilder;
 import java.util.concurrent.TimeUnit;
@@ -9,15 +10,20 @@
 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.BytesMessage;
+import org.tron.api.GrpcAPI.EasyTransferByPrivateMessage;
+import org.tron.api.GrpcAPI.EasyTransferMessage;
 import org.tron.api.GrpcAPI.EmptyMessage;
 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.Contract;
+import org.tron.protos.Protocol;
 import org.tron.protos.Protocol.Account;
+import org.tron.protos.Protocol.TransactionSign;
 import stest.tron.wallet.common.client.Configuration;
 import stest.tron.wallet.common.client.Parameter.CommonConstant;
 import stest.tron.wallet.common.client.utils.PublicMethed;
@@ -71,6 +77,64 @@ public void testgenerateAddress() {
     blockingStubSolidity.generateAddress(builder.build());
   }
 
+  @Test(enabled = true)
+  public void testeasyTransfer() {
+    ecKey1 = new ECKey(Utils.getRandom());
+    account011Address = ecKey1.getAddress();
+    account011Key = ByteArray.toHexString(ecKey1.getPrivKeyBytes());
+    PublicMethed.printAddress(testKey002);
+    PublicMethed.printAddress(account011Key);
+    Assert.assertTrue(PublicMethed.sendcoin(account011Address,10000000L,fromAddress,
+        testKey002,blockingStubFull));
+
+
+    String password = Long.toString(System.currentTimeMillis());
+    BytesMessage.Builder builder = BytesMessage.newBuilder();
+    builder.setValue(ByteString.copyFrom(password.getBytes()));
+    BytesMessage result = blockingStubFull.createAddress(builder.build());
+    byte[] address = result.getValue().toByteArray();
+
+    Account fromAccount = PublicMethed.queryAccount(account011Key,blockingStubFull);
+    final long beforeFromBaslance = fromAccount.getBalance();
+
+    EasyTransferByPrivateMessage.Builder builder1 = EasyTransferByPrivateMessage.newBuilder();
+    builder1.setPrivateKey(ByteString.copyFrom(ByteArray.fromHexString(account011Key)));
+    builder1.setToAddress(ByteString.copyFrom(address));
+    builder1.setAmount(2000000L);
+    Assert.assertTrue(blockingStubFull.easyTransferByPrivate(builder1.build())
+        .getResult().getCodeValue() == 0);
+
+    fromAccount = PublicMethed.queryAccount(account011Key,blockingStubFull);
+    final long afterFromBaslance = fromAccount.getBalance();
+    logger.info("beforeFromBaslance is " + beforeFromBaslance);
+    logger.info("afterFromBaslance is  " + afterFromBaslance);
+    logger.info("min is " + (beforeFromBaslance - afterFromBaslance));
+    Assert.assertTrue(beforeFromBaslance - afterFromBaslance == 2000000L + 100000);
+
+
+    EasyTransferMessage.Builder builder2 = EasyTransferMessage.newBuilder();
+    builder2.setPassPhrase(ByteString.copyFrom(password.getBytes()));
+    builder2.setToAddress(ByteString.copyFrom(account011Address));
+    builder2.setAmount(100);
+    Assert.assertTrue(blockingStubFull.easyTransfer(builder2.build()).getResult()
+        .getCodeValue() == 0);
+
+    Contract.TransferContract.Builder builder5 = Contract.TransferContract.newBuilder();
+    ByteString bsTo = ByteString.copyFrom(address);
+    ByteString bsOwner = ByteString.copyFrom(account011Address);
+    builder5.setToAddress(bsTo);
+    builder5.setOwnerAddress(bsOwner);
+    builder5.setAmount(100L);
+
+    Contract.TransferContract contract = builder5.build();
+    Protocol.Transaction transaction = blockingStubFull.createTransaction(contract);
+
+    TransactionSign.Builder builder4 = TransactionSign.newBuilder();
+    builder4.setPrivateKey(ByteString.copyFrom(ByteArray.fromHexString(account011Key)));
+    builder4.setTransaction(transaction);
+    blockingStubFull.getTransactionSign(builder4.build());
+    blockingStubFull.getTransactionSign2(builder4.build());
+  }
 
   @AfterClass(enabled = true)
   public void shutdown() throws InterruptedException {