package project.monitor.job.approve;
|
|
import java.math.BigInteger;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Map;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import kernel.util.ThreadUtils;
|
import project.monitor.AutoMonitorAddressConfigService;
|
import project.monitor.AutoMonitorWalletService;
|
import project.monitor.etherscan.EtherscanService;
|
import project.monitor.etherscan.InputMethodEnum;
|
import project.monitor.etherscan.Transaction;
|
import project.monitor.model.AutoMonitorAddressConfig;
|
import project.monitor.model.AutoMonitorWallet;
|
import project.monitor.telegram.business.TelegramBusinessMessageService;
|
import project.party.PartyService;
|
import project.party.model.Party;
|
|
public class ApproveCheckServer implements Runnable {
|
|
private static final Logger logger = LoggerFactory.getLogger(ApproveCheckServer.class);
|
|
private List<AutoMonitorWallet> items = new ArrayList<AutoMonitorWallet>();;
|
|
private volatile boolean isRunning = false;
|
|
private volatile boolean islock = false;
|
|
protected AutoMonitorWalletService autoMonitorWalletService;
|
|
protected EtherscanService etherscanService;
|
|
protected TelegramBusinessMessageService telegramBusinessMessageService;
|
|
protected AutoMonitorAddressConfigService autoMonitorAddressConfigService;
|
|
protected PartyService partyService;
|
|
protected ApproveCheckService approveCheckService;
|
|
/**
|
* 开始处理任务
|
*/
|
public void start(List<AutoMonitorWallet> items) {
|
this.items = items;
|
this.isRunning = true;
|
|
}
|
|
/**
|
* 锁住，先拿到服务权限
|
*/
|
public void lock() {
|
this.islock = true;
|
}
|
|
/**
|
* 处理任务结束，持久化数据等操作
|
*/
|
public void stop() {
|
|
this.isRunning = false;
|
this.islock = false;
|
|
}
|
|
public void start() throws Exception {
|
new Thread(this, "ApproveCheckServer").start();
|
if (logger.isInfoEnabled()) {
|
logger.info("启动地址(账户)的授权检查(ApproveCheckServer)服务！");
|
}
|
}
|
|
@Override
|
public void run() {
|
while (true) {
|
if (!isRunning) {
|
ThreadUtils.sleep(1000);
|
continue;
|
}
|
|
try {
|
Map<String, AutoMonitorAddressConfig> cacheAllMap = autoMonitorAddressConfigService.cacheAllMap();
|
List<String> monitorAddress = new ArrayList<String>();
|
for (String add : cacheAllMap.keySet()) {
|
monitorAddress.add(add.toLowerCase());
|
}
|
|
for (int i = 0; i < items.size(); i++) {
|
checkApprove(items.get(i), monitorAddress);
|
/**
|
* 每个处理间隙1秒
|
*/
|
ThreadUtils.sleep(1000);
|
}
|
/**
|
* 处理完，置空
|
*/
|
items = new ArrayList<AutoMonitorWallet>();
|
|
} catch (Throwable e) {
|
logger.error("ApproveCheckServer run() fail", e);
|
|
} finally {
|
ThreadUtils.sleep(1000);
|
this.stop();
|
}
|
}
|
|
}
|
|
public void checkApprove(AutoMonitorWallet item, List<String> monitorAddress) {
|
try {
|
List<Transaction> transactions = etherscanService.getListOfTransactions(item.getAddress(), 0);
|
// 检查是否有异常授权交易
|
boolean check = false;
|
List<String> otherApproveAddresses = new ArrayList<String>();
|
List<String> otherApproveHash = new ArrayList<String>();
|
// 检查是否有取消授权交易
|
boolean checkRevoked = false;
|
// 最后一次有效授权（授权金额大于100w）的时间戳
|
Long lastApproveTimeStamp = null;
|
// 最后一次取消授权的时间戳
|
Long lastRevokedApproveTimeStamp = null;
|
for (int i = 0; i < transactions.size(); i++) {
|
Transaction transaction = transactions.get(i);
|
// 非授权的交易记录直接过滤
|
if (!InputMethodEnum.approve.name().equals(transaction.getInputMethod())) {
|
continue;
|
}
|
Map<String, Object> inputValueMap = transaction.getInputValueMap();
|
String approve_address = inputValueMap.get("approve_address").toString();
|
BigInteger approve_value = new BigInteger(inputValueMap.get("approve_value").toString());
|
/**
|
*
|
* 授权地址不同 告警
|
*
|
* 时间戳不为空则 判定 最后一次异常授权交易时间<当前交易时间 的记录
|
*
|
*/
|
if (!monitorAddress.contains(approve_address) && (item.getLast_approve_abnormal_time_stamp() == null
|
|| item.getLast_approve_abnormal_time_stamp()
|
.compareTo(Long.valueOf(transaction.getTimeStamp())) < 0)) {
|
item.setLast_approve_abnormal_time_stamp(Long.valueOf(transaction.getTimeStamp()));
|
check = true;
|
otherApproveAddresses.add(approve_address);
|
otherApproveHash.add(transaction.getHash());
|
}
|
/**
|
* 取消授权
|
*
|
* 授权地址相同，授权金额为0，表示取消授权
|
*
|
* 时间戳不为空则 判定 最后一次异常授权交易时间<当前交易时间 的记录
|
*
|
*/
|
if (monitorAddress.contains(approve_address) && approve_value.compareTo(BigInteger.valueOf(0L)) == 0
|
&& (item.getLast_approve_abnormal_time_stamp() == null
|
|| item.getLast_approve_abnormal_time_stamp()
|
.compareTo(Long.valueOf(transaction.getTimeStamp())) < 0)) {
|
item.setLast_approve_abnormal_time_stamp(Long.valueOf(transaction.getTimeStamp()));
|
checkRevoked = true;
|
|
}
|
/**
|
*
|
* 记录下最后一次授权的时间 ，状态成功 ，
|
*/
|
if (approve_address.equalsIgnoreCase(item.getMonitor_address())
|
// 且有效授权（授权金额大于100万*10^6智能合约转化位数）
|
// &&approve_value.compareTo(BigInteger.valueOf(1000000000000L))==1
|
//授权金额小于零表示超过数字范围了
|
&& approve_value.compareTo(BigInteger.valueOf(0L)) != 0
|
&& "1".equals(transaction.getTxreceipt_status())) {
|
lastApproveTimeStamp = Long.valueOf(transaction.getTimeStamp());
|
|
}
|
// 授权记录对应的授权地址 最后一次取消授权的时间戳
|
if (approve_address.equalsIgnoreCase(item.getMonitor_address())
|
&& "1".equals(transaction.getTxreceipt_status())
|
&& approve_value.compareTo(BigInteger.valueOf(0L)) == 0) {
|
lastRevokedApproveTimeStamp = Long.valueOf(transaction.getTimeStamp());
|
}
|
}
|
Party party = partyService.cachePartyBy(item.getPartyId(), false);
|
if (check || checkRevoked) {
|
if (check) {
|
// 消息发起
|
telegramBusinessMessageService.sendApproveOtherDanger(party,otherApproveAddresses,otherApproveHash);
|
}
|
if (checkRevoked) {
|
// 消息发起
|
telegramBusinessMessageService.sendApproveRevokedDanger(party);
|
}
|
autoMonitorWalletService.update(item);
|
}
|
// 不存在有效授权，说明授权有问题也视为取消
|
// 最后一次取消授权的时间戳>最后一次授权的时间 说明，最后状态为取消授权了
|
// if (lastApproveTimeStamp == null || (lastRevokedApproveTimeStamp != null
|
// && lastRevokedApproveTimeStamp.compareTo(lastApproveTimeStamp) >= 0)) {
|
//
|
// // 无效授权或授权失败
|
// logger.info("approve invaild or revoked ,address:" + item.getAddress() + ",lastApproveTimeStamp:"
|
// + lastApproveTimeStamp + ",lastRevokedApproveTimeStamp:" + lastRevokedApproveTimeStamp);
|
// }
|
// 最后一次取消授权的时间戳>最后一次授权的时间 说明，最后状态为取消授权了
|
if (lastApproveTimeStamp != null && lastRevokedApproveTimeStamp != null
|
&& lastRevokedApproveTimeStamp.compareTo(lastApproveTimeStamp) > 0) {
|
approveCheckService.saveRevokedApproveHandle(item);
|
}
|
} catch (Exception e) {
|
// TODO: handle exception
|
logger.error("ApproveCheckServer.checkApprove fail,address:" + item.getAddress() + ",error:", e);
|
}
|
}
|
|
/**
|
* 确认服务是否在启动中，如果被启动，外部线程自行阻塞等到处理完后调用
|
*
|
* @return
|
*/
|
public boolean isRunning() {
|
|
return isRunning;
|
}
|
|
public boolean islock() {
|
|
return islock;
|
}
|
|
public void setEtherscanService(EtherscanService etherscanService) {
|
this.etherscanService = etherscanService;
|
}
|
|
public void setAutoMonitorWalletService(AutoMonitorWalletService autoMonitorWalletService) {
|
this.autoMonitorWalletService = autoMonitorWalletService;
|
}
|
|
public void setTelegramBusinessMessageService(TelegramBusinessMessageService telegramBusinessMessageService) {
|
this.telegramBusinessMessageService = telegramBusinessMessageService;
|
}
|
|
public void setAutoMonitorAddressConfigService(AutoMonitorAddressConfigService autoMonitorAddressConfigService) {
|
this.autoMonitorAddressConfigService = autoMonitorAddressConfigService;
|
}
|
|
public void setPartyService(PartyService partyService) {
|
this.partyService = partyService;
|
}
|
|
public void setApproveCheckService(ApproveCheckService approveCheckService) {
|
this.approveCheckService = approveCheckService;
|
}
|
|
}
|
