feat(delegate): add test for delegate optimization

Author: zhang0125

chainbase/src/main/java/org/tron/core/store/DelegatedResourceAccountIndexStore.java

@@ -16,8 +16,8 @@
 public class DelegatedResourceAccountIndexStore extends
     TronStoreWithRevoking<DelegatedResourceAccountIndexCapsule> {
 
-  private static final byte[] fromPrefix = {0x01};
-  private static final byte[] toPrefix = {0x02};
+  private static final byte[] FROM_PREFIX = {0x01};
+  private static final byte[] TO_PREFIX = {0x02};
 
   @Autowired
   public DelegatedResourceAccountIndexStore(@Value("DelegatedResourceAccountIndex") String dbName) {
@@ -61,23 +61,23 @@ public void convert(byte[] address) {
   }
 
   public void delegate(byte[] from, byte[] to, long time) {
-    byte[] fromKey = createKey(fromPrefix, from, to);
+    byte[] fromKey = createKey(FROM_PREFIX, from, to);
     DelegatedResourceAccountIndexCapsule toIndexCapsule =
         new DelegatedResourceAccountIndexCapsule(ByteString.copyFrom(to));
     toIndexCapsule.setTimestamp(time);
     this.put(fromKey, toIndexCapsule);
 
-    byte[] toKey = createKey(toPrefix, to, from);
+    byte[] toKey = createKey(TO_PREFIX, to, from);
     DelegatedResourceAccountIndexCapsule fromIndexCapsule =
         new DelegatedResourceAccountIndexCapsule(ByteString.copyFrom(from));
     fromIndexCapsule.setTimestamp(time);
     this.put(toKey, fromIndexCapsule);
   }
 
   public void unDelegate(byte[] from, byte[] to) {
-    byte[] fromKey = createKey(fromPrefix, from, to);
+    byte[] fromKey = createKey(FROM_PREFIX, from, to);
     this.delete(fromKey);
-    byte[] toKey = createKey(toPrefix, to, from);
+    byte[] toKey = createKey(TO_PREFIX, to, from);
     this.delete(toKey);
   }
 
@@ -89,10 +89,10 @@ public DelegatedResourceAccountIndexCapsule getIndex(byte[] address) {
 
     DelegatedResourceAccountIndexCapsule tmpIndexCapsule =
         new DelegatedResourceAccountIndexCapsule(ByteString.copyFrom(address));
-    byte[] key = new byte[fromPrefix.length + address.length];
+    byte[] key = new byte[FROM_PREFIX.length + address.length];
 
-    System.arraycopy(fromPrefix, 0, key, 0, fromPrefix.length);
-    System.arraycopy(address, 0, key, fromPrefix.length, address.length);
+    System.arraycopy(FROM_PREFIX, 0, key, 0, FROM_PREFIX.length);
+    System.arraycopy(address, 0, key, FROM_PREFIX.length, address.length);
     List<DelegatedResourceAccountIndexCapsule> tmpToList =
         new ArrayList<>(this.prefixQuery(key).values());
 
@@ -101,8 +101,8 @@ public DelegatedResourceAccountIndexCapsule getIndex(byte[] address) {
         .map(DelegatedResourceAccountIndexCapsule::getAccount).collect(Collectors.toList());
     tmpIndexCapsule.setAllToAccounts(list);
 
-    System.arraycopy(toPrefix, 0, key, 0, toPrefix.length);
-    System.arraycopy(address, 0, key, toPrefix.length, address.length);
+    System.arraycopy(TO_PREFIX, 0, key, 0, TO_PREFIX.length);
+    System.arraycopy(address, 0, key, TO_PREFIX.length, address.length);
     List<DelegatedResourceAccountIndexCapsule> tmpFromList =
         new ArrayList<>(this.prefixQuery(key).values());
     tmpFromList.sort(Comparator.comparing(DelegatedResourceAccountIndexCapsule::getTimestamp));

framework/src/test/java/org/tron/core/actuator/FreezeBalanceActuatorTest.java

@@ -6,15 +6,18 @@
 import com.google.protobuf.Any;
 import com.google.protobuf.ByteString;
 import java.io.File;
+import java.util.List;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.AfterClass;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.tron.common.application.TronApplicationContext;
+import org.tron.common.crypto.ECKey;
 import org.tron.common.utils.ByteArray;
 import org.tron.common.utils.FileUtil;
+import org.tron.common.utils.Utils;
 import org.tron.core.ChainBaseManager;
 import org.tron.core.Constant;
 import org.tron.core.Wallet;
@@ -313,6 +316,70 @@ public void testFreezeDelegatedBalanceForBandwidth() {
     }
   }
 
+  @Test
+  public void testMultiFreezeDelegatedBalanceForBandwidth() {
+    dbManager.getDynamicPropertiesStore().saveAllowDelegateResource(1);
+    dbManager.getDynamicPropertiesStore().saveAllowDelegateOptimization(1L);
+    dbManager.getDynamicPropertiesStore().saveLatestBlockHeaderTimestamp(10000L);
+    long frozenBalance = 1_000_000_000L;
+    long duration = 3;
+    final int RECEIVE_COUNT = 100;
+    String[] RECEIVE_ADDRESSES = new String[RECEIVE_COUNT + 1];
+
+    DelegatedResourceAccountIndexCapsule ownerIndexCapsule =
+        new DelegatedResourceAccountIndexCapsule(
+            ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS)));
+    for (int i = 0; i < RECEIVE_COUNT + 1; i++) {
+      ECKey ecKey = new ECKey(Utils.getRandom());
+      RECEIVE_ADDRESSES[i] = ByteArray.toHexString(ecKey.getAddress());
+      if (i != RECEIVE_COUNT) {
+        ownerIndexCapsule.addToAccount(ByteString.copyFrom(ecKey.getAddress()));
+      }
+    }
+    dbManager.getDelegatedResourceAccountIndexStore().put(
+        ByteArray.fromHexString(OWNER_ADDRESS), ownerIndexCapsule);
+    AccountCapsule receiverCapsule =
+        new AccountCapsule(
+            ByteString.copyFromUtf8("receiver"),
+            ByteString.copyFrom(ByteArray.fromHexString(RECEIVE_ADDRESSES[RECEIVE_COUNT])),
+            AccountType.Normal,
+            initBalance);
+    dbManager.getAccountStore().put(receiverCapsule.getAddress().toByteArray(), receiverCapsule);
+
+    TransactionResultCapsule ret = new TransactionResultCapsule();
+    FreezeBalanceActuator actuator = new FreezeBalanceActuator();
+    actuator.setChainBaseManager(dbManager.getChainBaseManager())
+        .setAny(getDelegatedContractForBandwidth(
+            OWNER_ADDRESS, RECEIVE_ADDRESSES[RECEIVE_COUNT], frozenBalance, duration));
+    try {
+      ownerIndexCapsule = dbManager
+          .getDelegatedResourceAccountIndexStore().getIndex(ByteArray.fromHexString(OWNER_ADDRESS));
+      List<ByteString> beforeList = ownerIndexCapsule.getToAccountsList();
+      actuator.validate();
+      actuator.execute(ret);
+
+      //check DelegatedResourceAccountIndex convert
+      ownerIndexCapsule = dbManager
+          .getDelegatedResourceAccountIndexStore().get(ByteArray.fromHexString(OWNER_ADDRESS));
+      Assert.assertNull(ownerIndexCapsule);
+
+      ownerIndexCapsule = dbManager
+          .getDelegatedResourceAccountIndexStore().getIndex(ByteArray.fromHexString(OWNER_ADDRESS));
+      Assert.assertEquals(0, ownerIndexCapsule.getFromAccountsList().size());
+      List<ByteString> tmpList = ownerIndexCapsule.getToAccountsList();
+      Assert.assertEquals(RECEIVE_COUNT + 1, ownerIndexCapsule.getToAccountsList().size());
+      for (int i = 0; i < RECEIVE_COUNT; i++) {
+        Assert.assertEquals(beforeList.get(i), tmpList.get(i));
+      }
+      Assert.assertEquals(RECEIVE_ADDRESSES[RECEIVE_COUNT],
+          ByteArray.toHexString(tmpList.get(RECEIVE_COUNT).toByteArray()));
+    } catch (ContractValidateException | ContractExeException e) {
+      Assert.fail("con not reach here");
+    }
+    dbManager.getDynamicPropertiesStore().saveAllowDelegateOptimization(0L);
+    dbManager.getDynamicPropertiesStore().saveLatestBlockHeaderTimestamp(10000L);
+  }
+
   @Test
   public void testFreezeDelegatedBalanceForCpuSameNameTokenActive() {
     dbManager.getDynamicPropertiesStore().saveAllowDelegateResource(1);