bl

Author: Yrp

src/main/java/org/tron/core/actuator/TransferActuator.java

@@ -14,6 +14,8 @@
 import org.tron.core.exception.BalanceInsufficientException;
 import org.tron.core.exception.ContractExeException;
 import org.tron.core.exception.ContractValidateException;
+import org.tron.core.exception.WhitelistException;
+import org.tron.core.services.WhitelistService;
 import org.tron.protos.Contract.TransferContract;
 import org.tron.protos.Protocol.AccountType;
 import org.tron.protos.Protocol.Transaction.Result.code;
@@ -115,7 +117,6 @@ public boolean validate() throws ContractValidateException {
     }
 
     try {
-
       AccountCapsule toAccount = dbManager.getAccountStore().get(toAddress);
       if (toAccount == null) {
         fee = fee + dbManager.getDynamicPropertiesStore().getCreateNewAccountFeeInSystemContract();

src/main/java/org/tron/core/config/args/Args.java

@@ -2,6 +2,7 @@
 
 import com.beust.jcommander.JCommander;
 import com.beust.jcommander.Parameter;
+import com.google.common.collect.Maps;
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigObject;
 import io.grpc.internal.GrpcUtil;
@@ -19,7 +20,9 @@
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Properties;
@@ -915,6 +918,21 @@ public String getOutputDirectory() {
     return this.outputDirectory;
   }
 
+  public Map<String, String> getBlacklist() {
+    Config config = Configuration.getByFileName(INSTANCE.shellConfFileName, Constant.TESTNET_CONF);
+    if (!config.hasPath("blacklist")) {
+      return Collections.emptyMap();
+    }
+
+    return config.getObjectList("blacklist").stream()
+        .map((ConfigObject e) -> Maps.immutableEntry(
+            e.get("from") == null ? "" : e.get("from").unwrapped().toString(),
+            e.get("to") == null ? "" : e.get("to").unwrapped().toString()))
+        .filter(e -> e.getKey() != null)
+        .filter(e -> e.getValue() != null)
+        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (k1, k2) -> k2));
+  }
+
   private static List<Node> getNodes(final com.typesafe.config.Config config, String path) {
     if (!config.hasPath(path)) {
       return Collections.emptyList();

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

@@ -101,6 +101,8 @@
 import org.tron.core.exception.VMIllegalException;
 import org.tron.core.exception.ValidateScheduleException;
 import org.tron.core.exception.ValidateSignatureException;
+import org.tron.core.exception.WhitelistException;
+import org.tron.core.services.WhitelistService;
 import org.tron.core.services.WitnessService;
 import org.tron.core.witness.ProposalController;
 import org.tron.core.witness.WitnessController;
@@ -1206,6 +1208,13 @@ public boolean processTransaction(final TransactionCapsule trxCap, BlockCapsule
       throw new ValidateSignatureException("trans sig validate failed");
     }
 
+    try {
+      WhitelistService.check(trxCap);
+    } catch (WhitelistException e) {
+      logger.debug(e.getMessage());
+      throw new ContractValidateException(e.getMessage(), e);
+    }
+
     TransactionTrace trace = new TransactionTrace(trxCap, this);
     trxCap.setTrxTrace(trace);
 

src/main/java/org/tron/core/exception/ContractValidateException.java

@@ -9,4 +9,8 @@ public ContractValidateException() {
   public ContractValidateException(String message) {
     super(message);
   }
+
+  public ContractValidateException(String message, Throwable throwable) {
+    super(message, throwable);
+  }
 }

src/main/java/org/tron/core/exception/WhitelistException.java

@@ -0,0 +1,17 @@
+package org.tron.core.exception;
+
+public class WhitelistException extends TronException {
+
+  public WhitelistException() {
+    super();
+  }
+
+  public WhitelistException(String message) {
+    super(message);
+  }
+
+  public WhitelistException(String message, Throwable cause) {
+    super(message, cause);
+  }
+
+}

src/main/java/org/tron/core/services/WhitelistService.java

@@ -0,0 +1,73 @@
+package org.tron.core.services;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import javax.annotation.PostConstruct;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.MapUtils;
+import org.springframework.stereotype.Component;
+import org.tron.common.utils.ByteArray;
+import org.tron.common.utils.ForkController;
+import org.tron.core.Wallet;
+import org.tron.core.capsule.TransactionCapsule;
+import org.tron.core.config.Parameter.ForkBlockVersionEnum;
+import org.tron.core.config.args.Args;
+import org.tron.core.db.common.WrappedByteArray;
+import org.tron.core.exception.WhitelistException;
+import org.tron.protos.Protocol.Transaction.Contract;
+import org.tron.protos.Protocol.Transaction.Contract.ContractType;
+
+// TODO
+@Component
+@Slf4j
+public class WhitelistService {
+  private final static String TEST_FROM = "41ceee995c01c9bb7d720f9013336363cdc7c8c4d8";
+  private final static String TEST_TO = "41216352a10649ffc3e37ba492feb0c35b3b6258e0";
+  private static Map<WrappedByteArray, WrappedByteArray> whitelist = new HashMap<>();
+
+  public WhitelistService() {
+    // test
+    whitelist.put(WrappedByteArray.of(ByteArray.fromHexString(TEST_FROM)),
+        WrappedByteArray.of(ByteArray.fromHexString(TEST_TO)));
+  }
+
+  // TODO
+  @PostConstruct
+  public void loadFromConfig() {
+//    Args.getInstance().getBlacklist().forEach((k, v) -> {
+//      WrappedByteArray key = WrappedByteArray.of(ByteArray.fromHexString(k));
+//      WrappedByteArray value = WrappedByteArray.of(ByteArray.fromHexString(v));
+//      whitelist.put(key, value);
+//    });
+  }
+
+  public static void check(TransactionCapsule transactionCapsule) throws WhitelistException {
+    if (!ForkController.instance().pass(ForkBlockVersionEnum.VERSION_3_5)) {
+      return;
+    }
+
+    if (MapUtils.isEmpty(whitelist)) {
+      return;
+    }
+
+    Contract contract = transactionCapsule.getInstance().getRawData().getContractList().get(0);
+    Contract.ContractType contractType = contract.getType();
+    if (contractType == ContractType.UnfreezeBalanceContract) {
+      return;
+    }
+
+    byte[] fromAddress = TransactionCapsule.getOwner(contract);
+    byte[] toAddress = TransactionCapsule.getToAddress(contract);
+    WrappedByteArray from = WrappedByteArray.of(fromAddress);
+    WrappedByteArray to = WrappedByteArray.of(toAddress);
+    WrappedByteArray value = whitelist.get(from);
+    if (Objects.nonNull(value) && (contractType != ContractType.TransferContract || !value.equals(to))) {
+      throw new WhitelistException("Not the specified address. "
+          + "contractType: " + contractType
+          + ", from:" + Wallet.encode58Check(fromAddress)
+          + ", to:" + (toAddress == null ? null : Wallet.encode58Check(toAddress)));
+    }
+  }
+}

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

@@ -2,7 +2,7 @@
 
 public class Version {
 
-  private static final String version = "3.2.4";
+  private static final String version = "3.5";
 
   public static String getVersion() {
     return version;

src/test/java/org/tron/core/services/WhitelistServiceTest.java

@@ -0,0 +1,5 @@
+package org.tron.core.services;
+
+public class WhitelistServiceTest {
+
+}