sys-dapp.git - Gitblit

			@@ -1,40 +1,52 @@
			package cc.mrbird.febs.dapp.service.impl;

			import cc.mrbird.febs.common.contants.AppContants;
			import cc.mrbird.febs.common.exception.FebsException;
			import cc.mrbird.febs.common.tree.MatrixTree;
			import cc.mrbird.febs.common.tree.MemberNode;
			import cc.mrbird.febs.common.utils.LoginUserUtil;
			import cc.mrbird.febs.common.utils.RedisUtils;
			import cc.mrbird.febs.common.utils.SpringContextUtil;
			import cc.mrbird.febs.dapp.chain.ChainEnum;
			import cc.mrbird.febs.dapp.chain.ChainService;
			import cc.mrbird.febs.dapp.chain.ContractChainService;
			import cc.mrbird.febs.dapp.contract.ContractMain;
			import cc.mrbird.febs.dapp.dto.SystemDto;
			import cc.mrbird.febs.dapp.dto.TransferDto;
			import cc.mrbird.febs.dapp.entity.*;
			import cc.mrbird.febs.dapp.enumerate.*;
			import cc.mrbird.febs.dapp.mapper.*;
			import cc.mrbird.febs.dapp.service.DappSystemService;
			import cc.mrbird.febs.dapp.utils.OnlineTransferUtil;
			import cc.mrbird.febs.dapp.vo.RedisTransferPoolVo;
			import cc.mrbird.febs.dapp.vo.SlipSettingVo;
			import cc.mrbird.febs.job.SystemTradeJob;
			import cc.mrbird.febs.dapp.service.DappWalletService;
			import cc.mrbird.febs.dapp.service.IMatrixTreeNodeService;
			import cc.mrbird.febs.dapp.vo.AKLineLimitVo;
			import cc.mrbird.febs.rabbit.producer.ChainProducer;
			import cc.mrbird.febs.tree.TreeConstants;
			import cn.hutool.core.collection.CollUtil;
			import cn.hutool.core.date.DateTime;
			import cn.hutool.core.date.DateUnit;
			import cn.hutool.core.date.DateUtil;
			import cn.hutool.core.util.RandomUtil;
			import cn.hutool.core.date.Week;
			import cn.hutool.core.util.ObjectUtil;
			import cn.hutool.core.util.StrUtil;
			import cn.hutool.json.JSONUtil;
			import com.alibaba.fastjson.JSONObject;
			import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
			import lombok.RequiredArgsConstructor;
			import lombok.extern.slf4j.Slf4j;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.stereotype.Service;
			import org.springframework.transaction.annotation.Transactional;
			import org.web3j.utils.Convert;

			import java.math.BigDecimal;
			import java.math.BigInteger;
			import java.math.RoundingMode;
			import java.util.*;
			import java.util.concurrent.locks.Lock;
			import java.util.concurrent.locks.ReentrantLock;
			import java.util.stream.Collectors;

			/**
			* @author
			* @author
			* @date 2022-03-24
			**/
			@Slf4j
			@@ -43,470 +55,3676 @@
			public class DappSystemServiceImpl implements DappSystemService {

			private final DappSystemDao dappSystemDao;
			private final DappReturnRatioDao dappReturnRatioDao;
			private final RedisUtils redisUtils;
			private final DappFundFlowDao dappFundFlowDao;
			private final DappMemberDao dappMemberDao;

			private final DappAchieveTreeDao dappAchieveTreeDao;
			private final DappAchieveMemberTreeDao dappAchieveMemberTreeDao;
			private final DappWalletService dappWalletService;
			private final DataDictionaryCustomMapper dataDictionaryCustomMapper;
			private final DappOnlineTransferDao dappOnlineTransferDao;
			private final DappSystemProfitDao dappSystemProfitDao;
			private final ChainProducer chainProducer;
			private final ContractMain contractMain;

			private final DappMemberNodeMapper dappMemberNodeMapper;
			private final DappChargeUsdtMapper dappChargeUsdtMapper;
			private final DappUsdtPerkEntityMapper dappUsdtPerkEntityMapper;
			private final DappWalletCoinDao dappWalletCoinDao;
			private final DappWalletMineDao dappWalletMineDao;
			private final DappAKlineMapper dappAKlineMapper;

			private final MallOrderInfoMapper mallOrderInfoMapper;
			private final MallAchieveRecordMapper mallAchieveRecordMapper;
			private final DappAccountMoneyChangeDao dappAccountMoneyChangeDao;


			@Override
			public Map<String, Object> findTotalInComeAndList() {
			List<DappMemberEntity> addresses = dappMemberDao.selectList(null);
			DappMemberEntity mineAddress = dappMemberDao.selectByAddress(ChainEnum.BSC_TFC.getAddress(), null);
			BigDecimal coinCnt = dappMemberDao.selectAllBalance("normal");

			Map<String, Object> result = new HashMap<>();
			result.put("total", mineAddress.getBalance());
			result.put("addreessCnt", addresses.size());
			result.put("coinCnt", coinCnt);
			result.put("sourceTFC", ChainService.getInstance(ChainEnum.BSC_TFC.name()).balanceOf(ChainEnum.BSC_TFC_SOURCE.getAddress()));
			result.put("sourceUSDT", ChainService.getInstance(ChainEnum.BSC_USDT.name()).balanceOf(ChainEnum.BSC_USDT_SOURCE.getAddress()));
			return result;
			}

			@Override
			public Map<String, Object> globalSetting() {
			BigDecimal newPrice = (BigDecimal) redisUtils.get(AppContants.REDIS_KEY_ETH_NEW_PRICE);
			Integer changeFee = (Integer) redisUtils.get(AppContants.REDIS_KEY_CHANGE_FEE);

			List<DappReturnRatioEntity> ratios = dappReturnRatioDao.selectList(null);
			Map<String, Object> result = new HashMap<>();
			result.put("newPrice", newPrice);
			result.put("changeFee", changeFee);
			result.put("ratio", ratios);
			return result;
			}

			@Override
			public SystemDto system() {
			DappMemberEntity member = LoginUserUtil.getAppUser();

			SystemDto system = new SystemDto();
			String hasStart = redisUtils.getString(AppContants.SYSTEM_START_FLAG);
			// 启动未启动
			if (!"start".equals(hasStart)) {
			system.setFeeRatio(BigDecimal.TEN);
			system.setUsdtRemain(BigDecimal.ZERO);
			system.setUsdtTotal(BigDecimal.ZERO);
			system.setSaleRemain(BigDecimal.ZERO);
			system.setSaleTotal(BigDecimal.ZERO);
			Object makePoolObj = redisUtils.get(AppContants.REDIS_KEY_MAKE_POOL_CNT);
			BigDecimal balance;
			if (makePoolObj == null) {
			balance = ChainService.getInstance(ChainEnum.BSC_TFC_MAKE.name()).balanceOf(ChainEnum.BSC_TFC_MAKE.getAddress());
			redisUtils.set(AppContants.REDIS_KEY_MAKE_POOL_CNT, balance);
			} else {
			balance = (BigDecimal) makePoolObj;
			}
			system.setBuyRemain(balance);
			system.setBuyTotal(balance);

			return system;
			}

			RedisTransferPoolVo transferPool = (RedisTransferPoolVo) redisUtils.get(AppContants.REDIS_KEY_TRANSFER_POOL_VOL);
			BigDecimal poolRemain = (BigDecimal) redisUtils.get(AppContants.REDIS_KEY_TRANSFER_POOL_VOL_REMAIN);
			// 买币数量
			system.setBuyTotal(transferPool.getTodayVol());
			system.setBuyRemain(poolRemain);

			ContractChainService instance = ChainService.getInstance(ChainEnum.BSC_TFC.name());
			BigDecimal balance = instance.balanceOf(member.getAddress());

			Object o = redisUtils.get(AppContants.REDIS_KEY_COIN_REMAIN + member.getAddress());

			BigDecimal minLimit = new BigDecimal(50);
			BigDecimal coinTotal;
			if (balance.compareTo(minLimit) > 0) {
			coinTotal = balance.multiply(BigDecimal.valueOf(0.3)).setScale(instance.decimals(), RoundingMode.HALF_DOWN);
			} else {
			coinTotal = new BigDecimal(50);
			}

			BigDecimal remain;
			if (o == null) {
			DateTime tomorrow = DateUtil.beginOfDay(DateUtil.tomorrow());
			long time = DateUtil.between(new Date(), tomorrow, DateUnit.SECOND, true);

			remain = coinTotal;
			redisUtils.set(AppContants.REDIS_KEY_COIN_REMAIN + member.getAddress(), remain, time);
			} else {
			remain = (BigDecimal) o;
			}
			// 卖币数量
			system.setSaleTotal(coinTotal);
			system.setSaleRemain(remain);

			BigDecimal usdtRemain = (BigDecimal) redisUtils.get(AppContants.REDIS_KEY_USDT_OUT_LIMIT_REMAIN);
			BigDecimal usdtTotal = (BigDecimal) redisUtils.get(AppContants.REDIS_KEY_USDT_OUT_LIMIT);

			// usdt数量
			system.setUsdtTotal(usdtTotal);
			system.setUsdtRemain(usdtRemain);

			system.setFeeRatio(BigDecimal.TEN);
			system.setBuyAmount(new BigDecimal("100"));
			return system;
			}

			@Override
			@Transactional(rollbackFor = Exception.class)
			public void tradeProfitDistribute(Long id) {
			DappFundFlowEntity fundflow = dappFundFlowDao.selectById(id);
			String batchNo = RandomUtil.randomString(16) + id.toString();
			public void putIntoProfit(Long memberId, int isReIn) {
			DappMemberEntity member = dappMemberDao.selectById(memberId);
			DappMemberEntity parent = dappMemberDao.selectMemberInfoByInviteId(member.getRefererId());

			BigDecimal fee = fundflow.getFee();
			DappMemberEntity member = dappMemberDao.selectById(fundflow.getMemberId());
			if (parent != null) {
			BigDecimal directProfit = TreeConstants.PUT_IN_AMOUNT.multiply(new BigDecimal("0.1"));
			dappWalletService.updateWalletCoinWithLock(directProfit, parent.getId(), 1);

			List<DappMemberEntity> parents;
			if (StrUtil.isBlank(member.getRefererId()) \|\| "0".equals(member.getRefererId())) {
			parents = new ArrayList<>();
			} else {
			List<String> inviteIds = StrUtil.split(member.getRefererId(), ',');
			parents = dappMemberDao.selectParentsList(inviteIds, 6);;
			DappFundFlowEntity fundFlow = new DappFundFlowEntity();
			dappFundFlowDao.insert(fundFlow);
			}

			DataDictionaryCustom miniHoldCoin = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(AppContants.DIC_TYPE_SYSTEM_SETTING, AppContants.DIC_VALUE_MINI_HOLD_COIN_LIMIT);
			DataDictionaryCustom slipPointSetting = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(AppContants.DIC_TYPE_SLIP_POINT_SETTING, AppContants.DIC_TYPE_SLIP_POINT_SETTING);
			SlipSettingVo slipSetting = JSONObject.parseObject(slipPointSetting.getValue(), SlipSettingVo.class);
			// 如果是复投的，则需奖励
			if (isReIn == 1) {
			List<DappMemberEntity> directCnt = dappMemberDao.selectChildMemberDirectOrNot(member.getInviteId(), 1, 1);

			// 源池
			ContractChainService instance = ChainService.getInstance(ChainEnum.BSC_TFC_SOURCE.name());
			BigDecimal destroy = slipSetting.getDestroyPoint().divide(slipSetting.getAllPoint(), 2, RoundingMode.HALF_DOWN).multiply(fee);
			log.info("销毁数量:{}, 比例:{}", destroy, slipSetting.getDestroyPoint());
			/**
			* 复投后，推一个拿一轮，推两个拿两轮，推三个后终身有效。
			* 200u单。
			* 无直推则收益200U
			* 一人加一轮400u，二人二轮
			* 三人永久。
			*/
			if (directCnt.size() < 3 && member.getOutCnt() != 0 && member.getOutCnt() - 1 == directCnt.size()) {
			return;
			} else {
			BigDecimal amount = null;
			if (directCnt.size() < 1) {
			amount = TreeConstants.PUT_IN_AMOUNT;
			} else {
			amount = TreeConstants.FULL_PROFIT_AMOUNT;
			}

			// 销毁
			OnlineTransferUtil.addTransfer(AppContants.DESTROY_ADDRESS, destroy, fundflow.getType(), 3, ChainEnum.BSC_TFC_SOURCE.name(), AppContants.SYMBOL_COIN, batchNo);
			member.setOutCnt(member.getOutCnt() + 1);
			dappMemberDao.updateById(member);

			// 总分发金额
			BigDecimal distrbAmount = fee.subtract(destroy);
			// 技术金额
			BigDecimal techAmount = distrbAmount.multiply(slipSetting.getTechProp().divide(BigDecimal.valueOf(100), 2, RoundingMode.HALF_UP));
			// 节点金额
			BigDecimal nodeAmount = distrbAmount.subtract(techAmount);
			log.info("总分发金额:{}, 技术:{}, 节点:{}", distrbAmount, techAmount, nodeAmount);
			dappWalletService.updateWalletCoinWithLock(amount, member.getId(), 1);

			if (CollUtil.isNotEmpty(parents)) {
			int i = 1;
			for (DappMemberEntity parent : parents) {
			BigDecimal balance = instance.balanceOf(parent.getAddress());
			log.info("地址:{}, 余额:{}", parent.getAddress(), balance);
			DappFundFlowEntity matrixProfitFlow = new DappFundFlowEntity();
			dappFundFlowDao.insert(matrixProfitFlow);
			}

			// 若地址持币少了指定数量
			if (balance.compareTo(new BigDecimal(miniHoldCoin.getValue())) < 0) {
			DappFundFlowEntity rePutInFlow = new DappFundFlowEntity();
			dappFundFlowDao.insert(rePutInFlow);
			}
			}

			@Override
			public void tfcNewPrice(String data) {
			// redisUtils.set(AppContants.REDIS_KEY_TFC_NEW_PRICE, new BigDecimal(data));
			}

			@Override
			public void resetMatrix() {
			DappAchieveTreeEntity node = dappAchieveTreeDao.selectNewestTreeNode();
			if (node.getValidState() == 2) {
			return;
			}

			long days = DateUtil.between(node.getCreateTime(), new Date(), DateUnit.DAY);
			if (days < 7) {
			return;
			}
			DappMineDataEntity mineDataEntity = dappSystemDao.selectMineDataForOne();

			List<DappAchieveTreeEntity> list = dappAchieveTreeDao.selectLastCountTreeNode(500);
			if (CollUtil.isNotEmpty(list)) {
			BigDecimal preAmount = mineDataEntity.getSafePool().divide(new BigDecimal(list.size()), 2, RoundingMode.HALF_UP);

			list.forEach(item -> {
			dappWalletService.updateWalletCoinWithLock(preAmount, item.getMidNode(), 1);
			DappFundFlowEntity flow = new DappFundFlowEntity();
			dappFundFlowDao.insert(flow);
			});
			}

			mineDataEntity.setSafePool(BigDecimal.ZERO);
			dappSystemDao.updateMineData(mineDataEntity);

			dappAchieveTreeDao.updateNodeValidState();
			dappAchieveMemberTreeDao.emptyTable();
			dappMemberDao.updateMemberActive();
			}

			@Override
			public void feeDistribute(String data) {
			if (StrUtil.isBlank(data)) {
			return;
			}

			Long flowId = Long.parseLong(data);
			DappFundFlowEntity fundFlow = dappFundFlowDao.selectById(flowId);
			if (fundFlow == null) {
			return;
			}

			// DataDictionaryCustom memberFeeDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(DataDictionaryEnum.MEMBER_FEE.getType(), DataDictionaryEnum.MEMBER_FEE.getCode());
			// if (memberFeeDic == null) {
			// log.info("未设置手续费返利比例");
			// return;
			// }
			// List<DappMemberEntity> memberList = dappMemberDao.selectMemberListNeedProfit();
			// if (CollUtil.isEmpty(memberList)) {
			// return;
			// }
			//
			// BigDecimal feeReturnRatio = new BigDecimal(memberFeeDic.getValue());
			// int size = memberList.size();
			// BigDecimal totalProfit = fundFlow.getFee().multiply(feeReturnRatio.divide(BigDecimal.valueOf(100), 2, RoundingMode.HALF_DOWN));
			// BigDecimal perProfit = totalProfit.divide(BigDecimal.valueOf(size), 8, RoundingMode.HALF_DOWN);
			//
			// memberList.forEach(item -> {
			// dappWalletService.updateWalletMineWithLock(perProfit, item.getId(), 1);
			//
			// DappFundFlowEntity profitFlow = new DappFundFlowEntity(item.getId(), perProfit, 12, 2, null, null);
			// dappFundFlowDao.insert(profitFlow);
			// });
			}

			@Override
			public void levelProfit(Long id) {
			// DappSystemProfit dappSystemProfit = dappSystemProfitDao.selectById(id);
			// if(ObjectUtil.isEmpty(dappSystemProfit)){
			// return;
			// }
			// Integer levelProfitState = dappSystemProfit.getLevelProfit();
			//
			// if(DappSystemProfit.ENUM_YES == levelProfitState){
			// return;
			// }
			// Long memberId = dappSystemProfit.getMemberId();
			// //获取用户的上级用户信息
			// DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
			// if(ObjectUtil.isEmpty(dappMemberEntity)){
			// return;
			// }
			// String refererIds = dappMemberEntity.getRefererIds();
			// if(StrUtil.isEmpty(refererIds)){
			// return;
			// }
			// DataDictionaryCustom levelProfitSet = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(DataDictionaryEnum.LEVEL_PROFIT.getType(), DataDictionaryEnum.LEVEL_PROFIT.getCode());
			// BigDecimal levelProfit = new BigDecimal(StrUtil.isEmpty(levelProfitSet.getValue()) ? "0.3" : levelProfitSet.getValue());
			// //投入金额减去技术方收益
			// DataDictionaryCustom systemProfitSet = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(DataDictionaryEnum.SYSTEM_PROFIT.getType(), DataDictionaryEnum.SYSTEM_PROFIT.getCode());
			// BigDecimal systemProfit = new BigDecimal(StrUtil.isEmpty(systemProfitSet.getValue()) ? "0.05" : systemProfitSet.getValue());
			// BigDecimal amount = dappSystemProfit.getAmount().subtract(systemProfit);
			// //层级奖励总奖金
			// BigDecimal levelProfitTotal = amount.multiply(levelProfit);
			// //实发层级奖励 -- 如果还有剩余给技术方
			// BigDecimal systemProfitTotal = BigDecimal.ZERO;
			// //返回十层
			// List<String> refererIdList = StrUtil.split(refererIds, ',');
			// //i：计数层数，同时i也为对应层数应推广的人数，当达到对应的直推人数时，才能获取对应层级奖励
			// if(CollUtil.isEmpty(refererIdList)){
			// return;
			// }
			// //层级奖励最大循环次数
			// int maxLevel = 10;
			// if(maxLevel > refererIdList.size()){
			// maxLevel = refererIdList.size();
			// }
			// for(int i = 0;i < maxLevel; i++){
			// if(systemProfitTotal.compareTo(levelProfitTotal) < 0){
			// String inviteId = refererIdList.get(i);
			// //获取每层用户的直推人数，判断能否获得这个层级的层级奖励
			// DappMemberEntity refererMember = dappMemberDao.selectMemberInfoByInviteId(inviteId);
			// //获取直推用户数量
			// QueryWrapper<DappMemberEntity> objectQueryWrapper = new QueryWrapper<>();
			// objectQueryWrapper.eq("referer_id",refererMember.getInviteId());
			// Integer selectCount = dappMemberDao.selectCount(objectQueryWrapper);
			// if(i >= selectCount){
			// continue;
			// }
			// //获取对应层级奖励
			// BigDecimal profit = LevelProfitEnum.YI.getProfit(i+1);
			// String accountType = refererMember.getAccountType();
			// //根据会员的等级类型，获取对应的百分比收益
			// DataDictionaryCustom memberLevelSet = dataDictionaryCustomMapper.selectDicDataByTypeAndCode("MEMBER_LEVEL", accountType);
			// BigDecimal memberLevel = new BigDecimal(memberLevelSet.getValue());
			//
			//// BigDecimal memberLevelProfit = levelProfitTotal.multiply(profit).multiply(memberLevel);
			//
			// BigDecimal memberLevelProfit = profit.multiply(memberLevel);
			//
			// DappFundFlowEntity fundFlow = new DappFundFlowEntity(refererMember.getId(), memberLevelProfit, 4, 1, BigDecimal.ZERO,null,dappSystemProfit.getId());
			// dappFundFlowDao.insert(fundFlow);
			// //发送转币消息
			// chainProducer.sendBnbTransferMsg(fundFlow.getId());
			// systemProfitTotal = systemProfitTotal.add(memberLevelProfit);
			// }
			// }
			// //如果还有剩余给技术方
			// if(levelProfitTotal.compareTo(systemProfitTotal) > 0){
			// BigDecimal avaProfit = levelProfitTotal.subtract(systemProfitTotal);
			// DappFundFlowEntity fundFlow = new DappFundFlowEntity(2L, avaProfit, 5, 1, BigDecimal.ZERO,null,dappSystemProfit.getId());
			// dappFundFlowDao.insert(fundFlow);
			// //发送转币消息
			// chainProducer.sendBnbTransferMsg(fundFlow.getId());
			// }
			//
			// dappSystemProfitDao.updateLevelProfitById(DappSystemProfit.ENUM_YES,dappSystemProfit.getId());
			}

			@Override
			public void memberOut(Long id) {
			//验证是否已经加入动能队列
			// DappSystemProfit systemProfit = dappSystemProfitDao.selectById(id);
			// if(ObjectUtil.isEmpty(systemProfit)){
			// return;
			// }
			// //获取当前是第几轮队列
			// String redisKey = "QUEUE_COUNT";
			// String memberOutCount = redisUtils.getString(redisKey);
			// DataDictionaryCustom queueCountSet = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(DataDictionaryEnum.QUEUE_COUNT.getType(), DataDictionaryEnum.QUEUE_COUNT.getCode());
			// String queueCount = queueCountSet.getValue();
			// if(StrUtil.isBlank(memberOutCount) \|\| !queueCount.equals(memberOutCount)){
			// redisUtils.set(redisKey,queueCount,0L);
			// memberOutCount = queueCount;
			// }
			// //出局条件的人数
			// /**
			// * 初始大小 5+4*0
			// * 1 1,2,3,4,5 1出局 5+4*0
			// * 2 2,3,4,5,1(复投),7,8,9,10 2出局 5+4*1
			// * 3 3,4,5,1(复投),7,8,9,10,2(复投),12,13,14,15 3出局 5+4*2
			// * 4 4,5,1(复投),7,8,9,10,2(复投),12,13,14,15,3(复投),17,18,19,20 4出局 5+4*3
			// */
			// Integer memberCount = Integer.parseInt(memberOutCount) * 4 + 5;
			// //判断当前是否符合出局条件
			// QueryWrapper<DappSystemProfit> objectQueryWrapper = new QueryWrapper<>();
			// objectQueryWrapper.eq("state",DappSystemProfit.STATE_IN);
			// //实际投资人数
			// Integer selectCount = dappSystemProfitDao.selectCount(objectQueryWrapper);
			// //实际投资人数小于出局条件人数
			// if(selectCount < memberCount){
			// return;
			// }
			// //符合则出局实际投资人数等于出局条件人数
			// DappSystemProfit dappSystemProfit = dappSystemProfitDao.selectSystemProfitByState(DappSystemProfit.STATE_IN);
			// if(ObjectUtil.isEmpty(dappSystemProfit)){
			// return;
			// }
			// //符合则出局，轮数+1
			// Integer realCount = (Integer.parseInt(queueCount) + 1);
			// queueCountSet.setValue(realCount.toString());
			// dataDictionaryCustomMapper.updateById(queueCountSet);
			// redisUtils.set(redisKey,realCount,0L);
			//
			// DappSystemProfit dappSystemProfitNow = dappSystemProfitDao.selectByIdForUpdate(dappSystemProfit.getId(),DappSystemProfit.STATE_IN);
			// dappSystemProfitDao.updateStateById(DappSystemProfit.STATE_OUT,dappSystemProfitNow.getId());
			//
			// // 直接拿走0.95ge
			//
			// DataDictionaryCustom investAmountProfitSet = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(DataDictionaryEnum.INVEST_AMOUNT_PROFIT.getType(), DataDictionaryEnum.INVEST_AMOUNT_PROFIT.getCode());
			// BigDecimal investAmountProfit = new BigDecimal(investAmountProfitSet.getValue());
			// DappFundFlowEntity fundFlowOut = new DappFundFlowEntity(dappSystemProfitNow.getMemberId(), investAmountProfit, 7, 1, BigDecimal.ZERO, null,dappSystemProfitNow.getId());
			// dappFundFlowDao.insert(fundFlowOut);
			// //发送转币消息
			// chainProducer.sendBnbTransferMsg(fundFlowOut.getId());
			// //复投成功{type: 1, txHash: result.transactionHash, id: res.data, flag: 'success', buyType: 2}
			// DataDictionaryCustom investAmountSet = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(DataDictionaryEnum.INVEST_AMOUNT.getType(), DataDictionaryEnum.INVEST_AMOUNT.getCode());
			// BigDecimal investAmount = new BigDecimal(investAmountSet.getValue());
			// //todo 直接运行转账
			// String txHash = "复投";
			// DappFundFlowEntity fundFlow = new DappFundFlowEntity(dappSystemProfitNow.getMemberId(), investAmount, 6, 1, BigDecimal.ZERO, txHash);
			// dappFundFlowDao.insert(fundFlow);
			//
			// TransferDto transferDto = new TransferDto();
			// transferDto.setType(1);
			// transferDto.setTxHash(txHash);
			// transferDto.setBuyType(2);
			// transferDto.setId(fundFlow.getId());
			// transferDto.setFlag("success");
			// transferDto.setAmount(investAmount);
			// transferDto.setMemberId(dappSystemProfitNow.getMemberId());
			// dappWalletService.transferAgain(transferDto);
			}

			@Override
			public void bnbTransfer(Long id) {
			log.info("{}",id);
			//获取对应的流水记录
			DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectInfoById(id);
			if(ObjectUtil.isEmpty(dappFundFlowEntity)){
			return;
			}
			if(DappFundFlowEntity.WITHDRAW_STATUS_AGREE == dappFundFlowEntity.getStatus()){
			return;
			}
			Long memberId = dappFundFlowEntity.getMemberId();
			DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
			if(ObjectUtil.isEmpty(dappMemberEntity)){
			return;
			}
			Integer count = dappFundFlowDao.updateStatusById(DappFundFlowEntity.WITHDRAW_STATUS_AGREE,dappFundFlowEntity.getId());
			if(count > 0){
			/**
			* 转账直推收益
			*/
			DappFundFlowEntity dappFundFlow = dappFundFlowDao.selectById(id);
			//金额
			BigDecimal amount = dappFundFlow.getAmount();
			//目标地址
			String address = dappMemberEntity.getAddress();
			/**
			* 发起USDT转账
			*/
			String hash = ChainService.getInstance(ChainEnum.BSC_USDT.name()).transfer(address, amount);
			if(StrUtil.isEmpty(hash)){
			return;
			}
			log.info("{},{}",id,hash);
			dappFundFlow.setFromHash(hash);
			dappFundFlowDao.updateById(dappFundFlow);

			}
			}

			@Override
			public void agentUp(Long id) {
			//根据邀请码获取用户信息
			// DappMemberEntity dappMemberEntity = dappMemberDao.selectById(id);
			// if(ObjectUtil.isEmpty(dappMemberEntity)){
			// return;
			// }
			// //所有上级（不包含直属上级）
			// String refererIds = dappMemberEntity.getRefererIds();
			// List<String> refererIdList = StrUtil.split(refererIds, ',');
			// if(CollUtil.isNotEmpty(refererIdList)){
			// for(String inviteIdStr : refererIdList){
			// DappMemberEntity dappMemberEntityUp = dappMemberDao.selectMemberInfoByInviteId(inviteIdStr);
			// if(ObjectUtil.isEmpty(dappMemberEntityUp)){
			// continue;
			// }
			// String accountType = dappMemberEntityUp.getAccountType();
			// if(DataDictionaryEnum.BIG_BOSS.getCode().equals(accountType)){
			// continue;
			// }
			// //当前为BOSS，且直推中有两个BOSS以上，则升级BIG_BOSS
			// if(DataDictionaryEnum.BOSS.getCode().equals(accountType)){
			// Integer bossCount = dappMemberDao.selectCountByAccountTypeAndRefererId(DataDictionaryEnum.BOSS.getCode(),dappMemberEntityUp.getInviteId());
			// if(2 <= bossCount){
			// dappMemberDao.updateMemberAccountType(DataDictionaryEnum.BIG_BOSS.getCode(),dappMemberEntityUp.getId());
			// }
			// continue;
			// }
			// //当前为AGENT，且直推中有两个以上，则升级BOSS
			// if(DataDictionaryEnum.AGENT.getCode().equals(accountType)){
			// Integer bossCount = dappMemberDao.selectCountByAccountTypeAndRefererId(null,dappMemberEntityUp.getInviteId());
			// if(2 <= bossCount){
			// dappMemberDao.updateMemberAccountType(DataDictionaryEnum.BOSS.getCode(),dappMemberEntityUp.getId());
			// }
			// continue;
			// }
			// }
			// }
			// //直属上级
			// String accountType = dappMemberEntity.getAccountType();
			// if(DataDictionaryEnum.BIG_BOSS.getCode().equals(accountType)){
			// return;
			// }
			// //当前为BOSS，且直推中有两个BOSS以上，则升级BIG_BOSS
			// if(DataDictionaryEnum.BOSS.getCode().equals(accountType)){
			// Integer bossCount = dappMemberDao.selectCountByAccountTypeAndRefererId(DataDictionaryEnum.BOSS.getCode(),dappMemberEntity.getInviteId());
			// if(2 <= bossCount){
			// dappMemberDao.updateMemberAccountType(DataDictionaryEnum.BIG_BOSS.getCode(),dappMemberEntity.getId());
			// }
			// return;
			// }
			// //当前为AGENT，且直推中有两个以上，则升级BOSS
			// if(DataDictionaryEnum.AGENT.getCode().equals(accountType)){
			// Integer bossCount = dappMemberDao.selectCountByAccountTypeAndRefererId(null,dappMemberEntity.getInviteId());
			// if(2 <= bossCount){
			// dappMemberDao.updateMemberAccountType(DataDictionaryEnum.BOSS.getCode(),dappMemberEntity.getId());
			// }
			// return;
			// }
			}

			@Override
			public void bnbTransferTest(Long id) {
			log.info("{}",id);
			//获取对应的流水记录
			DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectInfoById(id);
			if(ObjectUtil.isEmpty(dappFundFlowEntity)){
			return;
			}
			Long memberId = dappFundFlowEntity.getMemberId();
			DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
			if(ObjectUtil.isEmpty(dappMemberEntity)){
			return;
			}
			if(AppContants.ADDRESS_PEOJECT.equals(dappMemberEntity.getAddress())){
			DappFundFlowEntity dappFundFlow = dappFundFlowDao.selectById(id);
			//金额
			BigDecimal amount = dappFundFlow.getAmount();
			//目标地址
			String address = dappMemberEntity.getAddress();
			/**
			* 发起USDT转账
			*/
			String hash = ChainService.getInstance(ChainEnum.BSC_USDT.name()).transfer(address, amount);
			if(StrUtil.isEmpty(hash)){
			return;
			}
			log.info("{},{}",id,hash);
			dappFundFlow.setFromHash(hash);
			dappFundFlowDao.updateById(dappFundFlow);
			}
			}

			@Override
			public void AntACoinInMsg(Long id) {
			// /**
			// * 获取对应的流水记录
			// */
			// DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectInfoById(id);
			// if(ObjectUtil.isEmpty(dappFundFlowEntity)){
			// return;
			// }
			// Long memberId = dappFundFlowEntity.getMemberId();
			// DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
			// if(ObjectUtil.isEmpty(dappMemberEntity)){
			// return;
			// }
			// /**
			// * 会员充值金额
			// */
			// BigDecimal amount = dappFundFlowEntity.getAmount();
			// /**
			// * A币的当前价格
			// */
			// DataDictionaryCustom coinAPriceDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.COIN_A_PRICE.getType(),
			// PoolEnum.COIN_A_PRICE.getCode()
			// );
			// BigDecimal coinAPrice = new BigDecimal(StrUtil.isEmpty(coinAPriceDic.getValue()) ? "0" : coinAPriceDic.getValue()).setScale(12,BigDecimal.ROUND_DOWN);
			// /**
			// * 会员充值USDT买入A币记录的ID
			// */
			// Long chergeRecordId = dappFundFlowEntity.getSystemProfitId();
			// DappChargeUsdtEntity dappChargeUsdtEntity = dappChargeUsdtMapper.selectById(chergeRecordId);
			// if(2 != dappChargeUsdtEntity.getStatus()){
			// return;
			// }
			// if(StrUtil.isEmpty(dappChargeUsdtEntity.getMemberHash())){
			// return;
			// }
			// /**
			// * 金本位的三倍额度,增加业绩,增加对应的NFT的值
			// */
			// DappUsdtPerkEntity dappUsdtPerkEntity = dappUsdtPerkEntityMapper.selectByMemberId(memberId);
			// if(ObjectUtil.isEmpty(dappUsdtPerkEntity)){
			// dappUsdtPerkEntity = new DappUsdtPerkEntity();
			// dappUsdtPerkEntity.setAmount(amount.multiply(new BigDecimal(3)));
			// dappUsdtPerkEntity.setNftDevote(amount);
			// dappUsdtPerkEntity.setMemberId(memberId);
			// dappUsdtPerkEntityMapper.insert(dappUsdtPerkEntity);
			// }
			// //金本位的三倍额度
			// BigDecimal amountPerk = dappUsdtPerkEntity.getAmount();
			// amountPerk = amountPerk.add(amount.multiply(new BigDecimal(3)));
			// dappUsdtPerkEntity.setAmount(amountPerk);
			// //生成一条金本位的三倍额度的资金流水记录
			// DappFundFlowEntity amountPerkFundFlow = new DappFundFlowEntity(
			// memberId,
			// amount.multiply(new BigDecimal(3)),
			// FundFlowEnum.MEMBER_AMOUNT_PERK_TOTAL.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(amountPerkFundFlow);
			//
			// //增加业绩
			// BigDecimal achieveAmount = dappUsdtPerkEntity.getAchieveAmount();
			// achieveAmount = achieveAmount.add(amount);
			// dappUsdtPerkEntity.setAchieveAmount(achieveAmount);
			// //增加对应的NFT的值
			// BigDecimal nftDevote = dappUsdtPerkEntity.getNftDevote();
			// nftDevote = nftDevote.add(amount);
			// dappUsdtPerkEntity.setNftDevote(nftDevote);
			// dappUsdtPerkEntityMapper.updateById(dappUsdtPerkEntity);
			// /**
			// * 90%进入A币底池 10%进入B币LP薄饼底池
			// */
			// DataDictionaryCustom usdtAPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.USDT_A_PERCENT.getType(),
			// PoolEnum.USDT_A_PERCENT.getCode()
			// );
			// BigDecimal usdtAPercent = new BigDecimal(StrUtil.isEmpty(usdtAPercentDic.getValue()) ? "0.7" : usdtAPercentDic.getValue());
			// BigDecimal usdtAAmount = amount.multiply(usdtAPercent).setScale(4, BigDecimal.ROUND_DOWN);
			//
			// //生成一条进行中的70%进入A币底池的资金流水记录
			// DappFundFlowEntity fundFlowToA = new DappFundFlowEntity(
			// 1L,
			// usdtAAmount,
			// FundFlowEnum.USDT_IN_A_POOL.getCode(),
			// 1,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(fundFlowToA);
			// //90%进入A币底池
			// chainProducer.sendAntACoinInAPoolMsg(fundFlowToA.getId());
			//
			// BigDecimal usdtWAmount = amount.multiply(new BigDecimal(0.2)).setScale(4, BigDecimal.ROUND_DOWN);
			// //生成一条进行中的20%进入A币底池的资金流水记录
			// DappFundFlowEntity fundFlowToW = new DappFundFlowEntity(
			// 1L,
			// usdtWAmount,
			// FundFlowEnum.USDT_IN_W_POOL.getCode(),
			// 1,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(fundFlowToW);
			//
			// DataDictionaryCustom usdtBPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.USDT_B_PERCENT.getType(),
			// PoolEnum.USDT_B_PERCENT.getCode()
			// );
			// BigDecimal usdtBPercent = new BigDecimal(StrUtil.isEmpty(usdtBPercentDic.getValue()) ? "0.1" : usdtBPercentDic.getValue());
			// BigDecimal usdtBAmount = amount.multiply(usdtBPercent).setScale(4, BigDecimal.ROUND_DOWN);
			// //生成一条进行中的10%进入B币底池的资金流水记录
			// DappFundFlowEntity fundFlowToB = new DappFundFlowEntity(
			// 1L,
			// usdtBAmount,
			// FundFlowEnum.USDT_IN_B_POOL.getCode(),
			// 1,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(fundFlowToB);
			// //10%进入B币LP薄饼底池
			// chainProducer.sendAntACoinInBPoolMsg(fundFlowToB.getId());
			// /**
			// * 1.90%底池的USDT做成100%溢价，铸造出70%金本位价值的A币。
			// */
			// DataDictionaryCustom produceAPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.PRODUCE_A_PERCENT.getType(),
			// PoolEnum.PRODUCE_A_PERCENT.getCode()
			// );
			// BigDecimal produceAPercent = new BigDecimal(StrUtil.isEmpty(produceAPercentDic.getValue()) ? "0.7" : produceAPercentDic.getValue());
			// //购买数量
			// BigDecimal totalCnt = amount.divide(coinAPrice, 4, BigDecimal.ROUND_DOWN);
			// /**
			// * 铸造出70%金本位价值的A币。实际产生数量
			// */
			// BigDecimal realCnt = totalCnt.multiply(produceAPercent).setScale(4, BigDecimal.ROUND_DOWN);
			// dappChargeUsdtEntity.setTotalCnt(totalCnt);
			// dappChargeUsdtEntity.setRealCnt(realCnt);
			// dappChargeUsdtMapper.updateById(dappChargeUsdtEntity);
			// /**
			// * 重新计算A币的价格
			// */
			// DataDictionaryCustom coinACntDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.COIN_A_CNT.getType(),
			// PoolEnum.COIN_A_CNT.getCode()
			// );
			// //A币币本位底池-A币的数量
			// BigDecimal coinACntDicCnt = new BigDecimal(coinACntDic.getValue());
			// coinACntDicCnt = coinACntDicCnt.add(realCnt);
			// coinACntDic.setValue(coinACntDicCnt.toString());
			// dataDictionaryCustomMapper.updateById(coinACntDic);
			//
			// DataDictionaryCustom coinAUsdtPriceDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.COIN_A_USDT_PRICE.getType(),
			// PoolEnum.COIN_A_USDT_PRICE.getCode()
			// );
			// //A币金本位底池-usdt数量
			// BigDecimal coinAUsdtPriceDicCnt = new BigDecimal(coinAUsdtPriceDic.getValue());
			// coinAUsdtPriceDicCnt = coinAUsdtPriceDicCnt.add(amount);
			// coinAUsdtPriceDic.setValue(coinAUsdtPriceDicCnt.toString());
			// dataDictionaryCustomMapper.updateById(coinAUsdtPriceDic);
			//
			// BigDecimal divide = coinAUsdtPriceDicCnt.divide(coinACntDicCnt, 12, BigDecimal.ROUND_DOWN);
			// coinAPriceDic.setValue(divide.toString());
			// dataDictionaryCustomMapper.updateById(coinAPriceDic);
			//
			// chainProducer.sendAntKLineMsg(0);
			// /**
			// * A币的分配 walletMine
			// * 【70%换算100%分配】
			// * 50%客户秒到
			// * 20%全网加权分红（按20%释放递减）
			// * 10%直推
			// * 5%节点
			// * 5%基金会
			// * 10%级差奖
			// */
			// /**
			// * 50%客户秒到
			// */
			// DataDictionaryCustom memberGetAPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.MEMBER_GET_A_PERCENT.getType(),
			// PoolEnum.MEMBER_GET_A_PERCENT.getCode()
			// );
			// BigDecimal memberGetAPercent = new BigDecimal(StrUtil.isEmpty(memberGetAPercentDic.getValue()) ? "0.5" : memberGetAPercentDic.getValue());
			// BigDecimal memberGetACnt = realCnt.multiply(memberGetAPercent).setScale(4, BigDecimal.ROUND_DOWN);
			//
			// BigDecimal fundFlowToMemberFlag = this.getAndUpdateMemberPerk(dappFundFlowEntity.getMemberId(), memberGetACnt);
			// if(fundFlowToMemberFlag.compareTo(BigDecimal.ZERO) > 0){
			// //生成一条50%客户秒到的资金流水记录
			// DappFundFlowEntity fundFlowToMember = new DappFundFlowEntity(
			// dappFundFlowEntity.getMemberId(),
			// fundFlowToMemberFlag,
			// FundFlowEnum.MEMBER_GET_A_CNT.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(fundFlowToMember);
			// //用户的A币账户增加memberGetACnt数量
			// dappWalletService.updateWalletMineWithLock(fundFlowToMemberFlag,dappFundFlowEntity.getMemberId(),1);
			// }
			// /**
			// * 20%全网加权分红（按20%释放递减）进入加权分红底池
			// */
			// DataDictionaryCustom poolAllMemberAPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.POOL_ALL_MEMBER_A_PERCENT.getType(),
			// PoolEnum.POOL_ALL_MEMBER_A_PERCENT.getCode()
			// );
			// BigDecimal poolAllMemberAPercent = new BigDecimal(StrUtil.isEmpty(poolAllMemberAPercentDic.getValue()) ? "0.2" : poolAllMemberAPercentDic.getValue());
			// BigDecimal poolAllMemberAPercentCnt = realCnt.multiply(poolAllMemberAPercent).setScale(4, BigDecimal.ROUND_DOWN);
			//
			// DataDictionaryCustom poolAllMemberACntDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.POOL_ALL_MEMBER_A_CNT.getType(),
			// PoolEnum.POOL_ALL_MEMBER_A_CNT.getCode()
			// );
			// BigDecimal poolAllMemberACnt = new BigDecimal(StrUtil.isEmpty(poolAllMemberACntDic.getValue()) ? "0" : poolAllMemberACntDic.getValue());
			// poolAllMemberACnt = poolAllMemberACnt.add(poolAllMemberAPercentCnt);
			// poolAllMemberACntDic.setValue(poolAllMemberACnt.toString());
			// dataDictionaryCustomMapper.updateById(poolAllMemberACntDic);
			// //生成一条20%全网加权分红（按20%释放递减）进入加权分红底池的资金流水记录
			// DappFundFlowEntity poolAllMemberAFundFlow = new DappFundFlowEntity(
			// 1L,
			// poolAllMemberAPercentCnt,
			// FundFlowEnum.POOL_ALL_MEMBER_A_CNT.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(poolAllMemberAFundFlow);
			//
			//// BigDecimal poolAllMemberAPercentCntAva = nodePoolPerk(poolAllMemberAPercentCnt, MemberLevelEnum.MEMBER.getType(), FundFlowEnum.POOL_MEMBER_A_CNT.getCode());
			// /**
			// * 20%全网加权平分，按照个人投资占比全网的比例去平分
			// */
			// chainProducer.sendAllMemberPerkAvaMsg(poolAllMemberAFundFlow.getId());
			//// BigDecimal poolAllMemberAPercentCntAva = allMemberPerk(poolAllMemberAPercentCnt, FundFlowEnum.POOL_MEMBER_A_CNT.getCode());
			//// DappFundFlowEntity poolAllMemberAFundFlowAva = new DappFundFlowEntity(
			//// 1L,
			//// poolAllMemberAPercentCnt.subtract(poolAllMemberAPercentCntAva),
			//// FundFlowEnum.POOL_MEMBER_A_CNT.getCode(),
			//// 2,
			//// BigDecimal.ZERO,
			//// null,
			//// chergeRecordId);
			//// dappFundFlowDao.insert(poolAllMemberAFundFlowAva);
			//// dappWalletService.updateWalletMineWithLock(poolAllMemberAPercentCnt.subtract(poolAllMemberAPercentCntAva),
			//// 1L,1);
			//
			// /**
			// * 10%直推
			// */
			// DataDictionaryCustom directAPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.DIRECT_A_PERCENT.getType(),
			// PoolEnum.DIRECT_A_PERCENT.getCode()
			// );
			// BigDecimal directAPercent = new BigDecimal(StrUtil.isEmpty(directAPercentDic.getValue()) ? "0.1" : directAPercentDic.getValue());
			// BigDecimal directAPercentCnt = realCnt.multiply(directAPercent).setScale(4, BigDecimal.ROUND_DOWN);
			//
			// String refererId = dappMemberEntity.getRefererId();
			// DappMemberEntity directMemberEntity = dappMemberDao.selectMemberInfoByInviteId(refererId);
			// if(ObjectUtil.isNotEmpty(directMemberEntity)){
			// /**
			// *推荐用户入单可享有贡献值.例.推荐100获得100贡献值
			// */
			// DappUsdtPerkEntity directDappUsdtPerkEntity = dappUsdtPerkEntityMapper.selectByMemberId(directMemberEntity.getId());
			// if(ObjectUtil.isEmpty(directDappUsdtPerkEntity)){
			// directDappUsdtPerkEntity = new DappUsdtPerkEntity();
			// directDappUsdtPerkEntity.setNftDevote(amount);
			// directDappUsdtPerkEntity.setMemberId(directMemberEntity.getId());
			// dappUsdtPerkEntityMapper.insert(directDappUsdtPerkEntity);
			// }
			//
			// BigDecimal directNftDevote = directDappUsdtPerkEntity.getNftDevote();
			// directNftDevote = directNftDevote.add(amount);
			// directDappUsdtPerkEntity.setNftDevote(directNftDevote);
			// dappUsdtPerkEntityMapper.updateById(directDappUsdtPerkEntity);
			//
			// BigDecimal directAPercentFundFlowToMemberFlag = this.getAndUpdateMemberPerk(directMemberEntity.getId(), directAPercentCnt);
			// if(directAPercentFundFlowToMemberFlag.compareTo(BigDecimal.ZERO) > 0){
			// //生成一条10%直推的资金流水记录
			// DappFundFlowEntity directAPercentFundFlowToMember = new DappFundFlowEntity(
			// directMemberEntity.getId(),
			// directAPercentFundFlowToMemberFlag,
			// FundFlowEnum.DIRECT_A_PERCENT.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(directAPercentFundFlowToMember);
			// //用户的A币账户增加directAPercentCnt数量
			// dappWalletService.updateWalletMineWithLock(directAPercentFundFlowToMemberFlag,directMemberEntity.getId(),1);
			// }
			// if(directAPercentCnt.compareTo(directAPercentFundFlowToMemberFlag) > 0){
			// DappFundFlowEntity directAPercentFundFlowToMemberAva = new DappFundFlowEntity(
			// 1L,
			// directAPercentCnt.subtract(directAPercentFundFlowToMemberFlag),
			// FundFlowEnum.DIRECT_A_PERCENT.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(directAPercentFundFlowToMemberAva);
			// dappWalletService.updateWalletMineWithLock(directAPercentCnt.subtract(directAPercentFundFlowToMemberFlag),
			// AppContants.YL_MEMBER_ID,1);
			// }
			// }
			// /**
			// * 5%节点
			// */
			// DataDictionaryCustom nodeAPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.NODE_A_PERCENT.getType(),
			// PoolEnum.NODE_A_PERCENT.getCode()
			// );
			// BigDecimal nodeAPercent = new BigDecimal(StrUtil.isEmpty(nodeAPercentDic.getValue()) ? "0.05" : nodeAPercentDic.getValue());
			// BigDecimal nodeAPercentCnt = realCnt.multiply(nodeAPercent).setScale(4, BigDecimal.ROUND_DOWN);
			// //生成一条5%节点的资金流水记录
			// DappFundFlowEntity nodeAPercentFundFlow = new DappFundFlowEntity(
			// 1L,
			// nodeAPercentCnt,
			// FundFlowEnum.NODE_A_PERCENT.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(nodeAPercentFundFlow);
			//// chainProducer.sendAntACoinInNodeMsg(nodeAPercentFundFlow.getId());
			// DataDictionaryCustom nodeAPercentPoolDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.NODE_A_PERCENT_POOL.getType(),
			// PoolEnum.NODE_A_PERCENT_POOL.getCode()
			// );
			// BigDecimal nodeAPercentPoolDicCnt = new BigDecimal(StrUtil.isEmpty(nodeAPercentPoolDic.getValue()) ? "0" : nodeAPercentPoolDic.getValue());
			// nodeAPercentPoolDicCnt = nodeAPercentPoolDicCnt.add(nodeAPercentCnt);
			// nodeAPercentPoolDic.setValue(nodeAPercentPoolDicCnt.toString());
			// dataDictionaryCustomMapper.updateById(nodeAPercentPoolDic);
			//
			// BigDecimal nodeAPercentCntAva = superNodePoolPerk(nodeAPercentCnt, NodeCodeEnum.SUPER_NODE.getCode(), FundFlowEnum.NODE_A_PERCENT_TO_MEMBER.getCode());
			//
			// if(nodeAPercentCnt.compareTo(nodeAPercentCntAva) > 0){
			// DappFundFlowEntity nodeAPercentFundFlowAva = new DappFundFlowEntity(
			// 1L,
			// nodeAPercentCnt.subtract(nodeAPercentCntAva),
			// FundFlowEnum.NODE_A_PERCENT_TO_MEMBER.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(nodeAPercentFundFlowAva);
			// dappWalletService.updateWalletMineWithLock(nodeAPercentCnt.subtract(nodeAPercentCntAva),
			// AppContants.YL_MEMBER_ID,1);
			// }
			// /**
			// * 5%基金会
			// */
			// DataDictionaryCustom foundationAPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.FOUNDATION_A_PERCENT.getType(),
			// PoolEnum.FOUNDATION_A_PERCENT.getCode()
			// );
			// BigDecimal foundationAPercent = new BigDecimal(StrUtil.isEmpty(foundationAPercentDic.getValue()) ? "0.05" : foundationAPercentDic.getValue());
			// BigDecimal foundationAPercentCnt = realCnt.multiply(foundationAPercent).setScale(4, BigDecimal.ROUND_DOWN);
			//
			// //生成一条5%基金会的资金流水记录
			// DappFundFlowEntity foundationAPercentFundFlow = new DappFundFlowEntity(
			// 295L,
			// foundationAPercentCnt,
			// FundFlowEnum.FOUNDATION_A_PERCENT.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(foundationAPercentFundFlow);
			// //用户的A币账户增加memberGetACnt数量
			// dappWalletService.updateWalletMineWithLock(foundationAPercentCnt,295L,1);
			// /**
			// * 10%级差奖
			// */
			// DataDictionaryCustom levelAPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.LEVEL_A_PERCENT.getType(),
			// PoolEnum.LEVEL_A_PERCENT.getCode()
			// );
			// BigDecimal levelAPercent = new BigDecimal(StrUtil.isEmpty(levelAPercentDic.getValue()) ? "0.1" : levelAPercentDic.getValue());
			// BigDecimal levelAPercentCnt = realCnt.multiply(levelAPercent).setScale(4, BigDecimal.ROUND_DOWN);
			//
			// //生成一条10%级差奖进入10%级差奖底池的资金流水记录
			// DappFundFlowEntity levelAPercentCntFundFlow = new DappFundFlowEntity(
			// 1L,
			// levelAPercentCnt,
			// FundFlowEnum.LEVEL_A_PERCENT_CNT.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(levelAPercentCntFundFlow);
			// chainProducer.sendAntACoinInLevelMsg(levelAPercentCntFundFlow.getId());
			//
			// /**
			// * 更新用户为有效用户
			// */
			// dappMemberDao.updateMemberActiveStatus(1,memberId);

			}

			private BigDecimal allMemberPerk(BigDecimal poolAllMemberAPercentCnt, int code) {

			BigDecimal realPerkAmount = BigDecimal.ZERO;
			/**
			* 查询总业绩
			*/
			List<DappChargeUsdtEntity> dappChargeUsdtEntities = dappChargeUsdtMapper.selectList(null);
			if(CollUtil.isEmpty(dappChargeUsdtEntities)){
			return realPerkAmount;
			}
			//总入金
			BigDecimal amountAll = dappChargeUsdtEntities.stream().map(DappChargeUsdtEntity::getAmount).reduce(BigDecimal.ZERO, BigDecimal::add);
			if(BigDecimal.ZERO.compareTo(amountAll) >= 0){
			return realPerkAmount;
			}
			/**
			* 每个人入金的总额
			*/
			Map<Long, BigDecimal> amountMap = dappChargeUsdtEntities.stream().collect(
			Collectors.groupingBy(DappChargeUsdtEntity::getMemberId,
			Collectors.reducing(BigDecimal.ZERO, DappChargeUsdtEntity::getAmount, BigDecimal::add)));
			/**
			* 入金1U分的代币个数
			*/
			BigDecimal usdtOfCnt = poolAllMemberAPercentCnt.divide(amountAll, 8, BigDecimal.ROUND_DOWN);

			for (Map.Entry<Long, BigDecimal> entry : amountMap.entrySet()) {
			Long memberId = entry.getKey();
			//当前会员的入金总和
			BigDecimal amount = entry.getValue();
			if(BigDecimal.ZERO.compareTo(amount) >= 0){
			continue;
			}
			//应该平分到的数量
			BigDecimal memberCnt = amount.multiply(usdtOfCnt).setScale(8,BigDecimal.ROUND_DOWN);
			BigDecimal fundFlowToMemberFlag = this.getAndUpdateMemberPerk(memberId, memberCnt);
			if(fundFlowToMemberFlag.compareTo(BigDecimal.ZERO) > 0){
			//生成一条50%客户秒到的资金流水记录
			DappFundFlowEntity fundFlowToMember = new DappFundFlowEntity(
			memberId,
			fundFlowToMemberFlag,
			code,
			2,
			BigDecimal.ZERO);
			dappFundFlowDao.insert(fundFlowToMember);
			//用户的A币账户增加memberGetACnt数量
			dappWalletService.updateWalletMineWithLock(fundFlowToMemberFlag,memberId,1);

			realPerkAmount = realPerkAmount.add(fundFlowToMemberFlag);
			}
			}
			return realPerkAmount;
			}

			@Override
			public void AntACoinAPollInMsg(Long id) {
			log.info("{}",id);
			//获取对应的流水记录
			DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectInfoById(id);
			if(ObjectUtil.isEmpty(dappFundFlowEntity)){
			return;
			}
			//金额
			BigDecimal amount = dappFundFlowEntity.getAmount();
			//目标地址
			String address = AppContants.ADDRESS_A_POOL_PEOJECT;
			if(5 == dappFundFlowEntity.getType()){
			address = AppContants.ADDRESS_A_POOL_PEOJECT;
			}else if(34 == dappFundFlowEntity.getType() ){
			address = ChainEnum.BSC_USDT_W_POOL.getAddress();
			}else{
			return;
			}
			/**
			* 发起USDT转账
			*/
			String hash = ChainService.getInstance(ChainEnum.BSC_USDT_A_POOL.name()).transfer(address, amount);
			if(StrUtil.isEmpty(hash)){
			return;
			}
			log.info("{},{}",id,hash);
			dappFundFlowEntity.setFromHash(hash);
			dappFundFlowEntity.setStatus(2);
			dappFundFlowDao.updateById(dappFundFlowEntity);
			}

			// public static void main(String[] args) {
			// String address = "0x7a9bfE048d110EF90a467803653f9B8666f9096C";
			// /**
			// * 发起USDT转账
			// */
			// String hash = ChainService.getInstance(ChainEnum.BSC_USDT_W_POOL_CONTRACT.name()).transferUSDT(address, new BigDecimal("0.99"));
			// System.out.println(hash);
			// }

			@Override
			public void AntACoinBPollInMsg(Long id) {
			log.info("{}",id);
			//获取对应的流水记录
			DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectInfoById(id);
			if(ObjectUtil.isEmpty(dappFundFlowEntity)){
			return;
			}
			//金额
			BigDecimal amount = dappFundFlowEntity.getAmount();
			//目标地址
			String address = AppContants.ADDRESS_B_POOL_PEOJECT;
			/**
			* 发起USDT转账
			*/
			String hash = ChainService.getInstance(ChainEnum.BSC_USDT_A_POOL.name()).transfer(address, amount);
			if(StrUtil.isEmpty(hash)){
			return;
			}
			log.info("{},{}",id,hash);
			dappFundFlowEntity.setFromHash(hash);
			dappFundFlowEntity.setStatus(2);
			dappFundFlowDao.updateById(dappFundFlowEntity);
			}

			@Override
			public void antACoinInNodeMsg(Long id) {
			// /**
			// * 全网节点99名.享受全网5%分红
			// */
			// log.info("{}",id);
			// //获取对应的流水记录
			// DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectInfoById(id);
			// if(ObjectUtil.isEmpty(dappFundFlowEntity)){
			// return;
			// }
			// //金额
			// BigDecimal amount = dappFundFlowEntity.getAmount();
			// /**
			// * 获取全网的超级节点个数
			// */
			// List<DappMemberNodeEntity> dappMemberNodeEntities = dappMemberNodeMapper.selectNodeByNodeCode(NodeCodeEnum.SUPER_NODE.getCode());
			// if(CollUtil.isNotEmpty(dappMemberNodeEntities)){
			// BigDecimal divide = amount.divide(new BigDecimal(dappMemberNodeEntities.size()), 4, BigDecimal.ROUND_DOWN);
			// for(DappMemberNodeEntity dappMemberNodeEntity : dappMemberNodeEntities){
			// Long memberId = dappMemberNodeEntity.getMemberId();
			//
			// DappFundFlowEntity nodeAPercentFundFlow = new DappFundFlowEntity(
			// memberId,
			// divide,
			// FundFlowEnum.NODE_A_PERCENT_TO_MEMBER.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// dappFundFlowEntity.getSystemProfitId());
			// dappFundFlowDao.insert(nodeAPercentFundFlow);
			// //用户的A币账户增加divide数量
			// dappWalletService.updateWalletMineWithLock(divide,memberId,1);
			// }
			// dappFundFlowEntity.setFromHash("已分成"+dappMemberNodeEntities.size()+"人");
			// }else{
			// dappFundFlowEntity.setFromHash("已分成0人");
			// dappWalletService.updateWalletMineWithLock(amount,1L,1);
			// }
			// dappFundFlowEntity.setStatus(2);
			// dappFundFlowDao.updateById(dappFundFlowEntity);
			}

			@Override
			public void antACoinInLevelMsg(Long id) {
			/**
			* DAO1.考核小区业绩5000USDT 享受团队新增业绩2%
			* DAO2.伞下不同部门产生2个DAO1.享受团队新增业绩3%
			* DAO3.伞下不同部门2个DAO2.享受团队新增业绩4%，全网加权分红1%
			* DAO4.两个不同部门DAO3.享受团队新增业绩5%，全网1%分红。
			* DAO5.两个不同部门DAO4.享受团队新增业绩6%，全网1%加权分红
			* 平级奖.DAO5平级享受全网1%加权分红.
			*
			* DAO5直推DAO5平级拿一代，视为平级奖，享受原有DAO5一个点，额外再加一个点分红。享受双份收益，合计2%加权分红
			*/
			// log.info("{}",id);
			// //获取对应的流水记录
			// DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectInfoById(id);
			// if(ObjectUtil.isEmpty(dappFundFlowEntity)){
			// return;
			// }
			// /**
			// * 极差总金额
			// */
			// BigDecimal amountTC = dappFundFlowEntity.getAmount();
			//
			// Long systemProfitId = dappFundFlowEntity.getSystemProfitId();
			// DappChargeUsdtEntity dappChargeUsdtEntity = dappChargeUsdtMapper.selectById(systemProfitId);
			// Long memberId = dappChargeUsdtEntity.getMemberId();
			// DappMemberEntity mallMember = dappMemberDao.selectById(memberId);
			//
			// /**
			// * 团队下不同代理级别获取不用的比例新增业绩补贴
			// */
			// if(StrUtil.isNotEmpty(mallMember.getRefererIds())){
			//
			// String referrerIds = mallMember.getRefererIds();
			// List<String> referrerIdList = StrUtil.splitTrim(referrerIds, ",");
			// if(CollUtil.isNotEmpty(referrerIdList)){
			// List<DappMemberEntity> mallMemberTeamPerk = dappMemberDao.selectByInviteIds(referrerIdList);
			//
			// if(CollUtil.isNotEmpty(mallMemberTeamPerk)){
			// //初始级别
			// String levelNormal = MemberLevelEnum.NODE_1.getType();
			// //初始团队新增业绩补贴
			// BigDecimal teamIncomePerkNormal = BigDecimal.ZERO;
			// //补贴总数
			// BigDecimal teamIncomePerkTotal = BigDecimal.ZERO;
			//
			// for(DappMemberEntity teamPerkMember : mallMemberTeamPerk){
			// String level = teamPerkMember.getAccountType();
			// //比较两个级别的大小，level大于levelNormal返回1
			// int compareMin = MemberLevelEnum.NODE_1.compareLevel(level, levelNormal);
			// int compareMax = MemberLevelEnum.NODE_1.compareLevel(MemberLevelEnum.NODE_5.getType(), level);
			// if(compareMin >= 1 && compareMax >= 1){
			// Long teamPerkMemberId = teamPerkMember.getId();
			// DataDictionaryCustom teamPerkMemberDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// "NODE_PERK", level);
			//
			// NodePerk nodePerk = JSONObject.parseObject(teamPerkMemberDic.getValue(), NodePerk.class);
			// BigDecimal teamIncomePerk = nodePerk.getTeamIncomePerk();
			// //极差
			// teamIncomePerk = teamIncomePerk.subtract(teamIncomePerkNormal);
			//
			// BigDecimal teamIncomePerkAmount = amountTC.multiply(teamIncomePerk).setScale(4, BigDecimal.ROUND_DOWN);
			//
			// BigDecimal nodeAPercentFundFlowFlag = this.getAndUpdateMemberPerk(teamPerkMemberId, teamIncomePerkAmount);
			// if(nodeAPercentFundFlowFlag.compareTo(BigDecimal.ZERO) > 0){
			// DappFundFlowEntity nodeAPercentFundFlow = new DappFundFlowEntity(
			// teamPerkMemberId,
			// nodeAPercentFundFlowFlag,
			// FundFlowEnum.LEVEL_A_PERCENT_CNT_MEMBER.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// dappFundFlowEntity.getSystemProfitId());
			// dappFundFlowDao.insert(nodeAPercentFundFlow);
			// //用户的A币账户增加divide数量
			// dappWalletService.updateWalletMineWithLock(nodeAPercentFundFlowFlag,teamPerkMemberId,1);
			// //累加补贴总数
			// teamIncomePerkTotal = teamIncomePerkTotal.add(nodeAPercentFundFlowFlag);
			// }
			//
			// //初始级别变成当前遍历的会员的级别
			// levelNormal = level;
			// //初始新增业绩补贴比例变成当前会员级别的补贴比例
			// teamIncomePerkNormal = nodePerk.getTeamIncomePerk();
			// }
			// }
			// //更新总数据
			// dappFundFlowEntity.setFromHash("已分成"+teamIncomePerkTotal.setScale(4,BigDecimal.ROUND_DOWN));
			// dappFundFlowEntity.setStatus(2);
			// dappFundFlowDao.updateById(dappFundFlowEntity);
			// BigDecimal subtract = amountTC.subtract(teamIncomePerkTotal);
			// //用户的A币账户增加divide数量
			//// if(amountTC.compareTo(teamIncomePerkTotal) > 0){
			//// DappFundFlowEntity nodeAPercentFundFlowAva = new DappFundFlowEntity(
			//// 1L,
			//// subtract,
			//// FundFlowEnum.LEVEL_A_PERCENT_CNT_MEMBER.getCode(),
			//// 2,
			//// BigDecimal.ZERO,
			//// null,
			//// systemProfitId);
			//// dappFundFlowDao.insert(nodeAPercentFundFlowAva);
			//// dappWalletService.updateWalletMineWithLock(subtract,
			//// 1L,1);
			//// }
			// }
			// }
			// }
			// /**
			// * 极差的dao3、dao4、dao5级别全网分红入自己的底池，每天按20%平分
			// */
			// //获取新增数量
			// DataDictionaryCustom nodeThreeDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.NODE_3.getType(),
			// PoolEnum.NODE_3.getCode());
			// NodePerk nodePerk = JSONObject.parseObject(nodeThreeDic.getValue(), NodePerk.class);
			// BigDecimal averagePerk = nodePerk.getAveragePerk();
			// BigDecimal averagePerkCnt = amountTC.multiply(averagePerk).setScale(4, BigDecimal.ROUND_DOWN);
			//
			// BigDecimal averagePerkCntAva = nodePoolPerk(averagePerkCnt, MemberLevelEnum.NODE_3.getType(), FundFlowEnum.DAO_3_NODE_PERK.getCode());
			//
			// //用户的A币账户增加divide数量
			// if(averagePerkCnt.compareTo(averagePerkCntAva) > 0){
			// DappFundFlowEntity nodeAPercentFundFlowAva = new DappFundFlowEntity(
			// 1L,
			// averagePerkCnt.subtract(averagePerkCntAva),
			// FundFlowEnum.DAO_3_NODE_PERK.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// systemProfitId);
			// dappFundFlowDao.insert(nodeAPercentFundFlowAva);
			// dappWalletService.updateWalletMineWithLock(averagePerkCnt.subtract(averagePerkCntAva),
			// AppContants.YL_MEMBER_ID,1);
			// }
			// //生成流水记录
			// DappFundFlowEntity nodeThreeFundFlow = new DappFundFlowEntity(
			// 1L,
			// averagePerkCnt,
			// FundFlowEnum.DAO_3_CNT_MEMBER.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// dappChargeUsdtEntity.getId());
			// dappFundFlowDao.insert(nodeThreeFundFlow);
			// //更新底池
			// DataDictionaryCustom nodeThreePoolDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.NODE_3_POOL.getType(),
			// PoolEnum.NODE_3_POOL.getCode());
			// BigDecimal nodeThreePool = new BigDecimal(nodeThreePoolDic.getValue());
			// nodeThreePool = nodeThreePool.add(averagePerkCnt).setScale(4,BigDecimal.ROUND_DOWN);
			// nodeThreePoolDic.setValue(nodeThreePool.toString());
			// dataDictionaryCustomMapper.updateById(nodeThreePoolDic);
			//
			// DataDictionaryCustom nodeFourDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.NODE_4.getType(),
			// PoolEnum.NODE_4.getCode());
			// NodePerk nodeFourDicPerk = JSONObject.parseObject(nodeFourDic.getValue(), NodePerk.class);
			// BigDecimal averagePerkFour = nodeFourDicPerk.getAveragePerk();
			// BigDecimal averagePerkFourCnt = amountTC.multiply(averagePerkFour).setScale(4, BigDecimal.ROUND_DOWN);
			//
			// BigDecimal averagePerkFourCntAva = nodePoolPerk(averagePerkFourCnt, MemberLevelEnum.NODE_4.getType(), FundFlowEnum.DAO_4_NODE_PERK.getCode());
			// //用户的A币账户增加divide数量
			// if(averagePerkFourCnt.compareTo(averagePerkFourCntAva) > 0){
			// DappFundFlowEntity nodeAPercentFundFlowAva = new DappFundFlowEntity(
			// 1L,
			// averagePerkFourCnt.subtract(averagePerkFourCntAva),
			// FundFlowEnum.DAO_4_NODE_PERK.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// systemProfitId);
			// dappFundFlowDao.insert(nodeAPercentFundFlowAva);
			// dappWalletService.updateWalletMineWithLock(averagePerkFourCnt.subtract(averagePerkFourCntAva),
			// AppContants.YL_MEMBER_ID,1);
			// }
			// DappFundFlowEntity nodeFourFundFlow = new DappFundFlowEntity(
			// 1L,
			// averagePerkFourCnt,
			// FundFlowEnum.DAO_4_CNT_MEMBER.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// dappChargeUsdtEntity.getId());
			// dappFundFlowDao.insert(nodeFourFundFlow);
			// DataDictionaryCustom nodeFourPoolDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.NODE_4_POOL.getType(),
			// PoolEnum.NODE_4_POOL.getCode());
			// BigDecimal nodeFourPool = new BigDecimal(nodeFourPoolDic.getValue());
			// nodeFourPool = nodeFourPool.add(averagePerkFourCnt).setScale(4,BigDecimal.ROUND_DOWN);
			// nodeFourPoolDic.setValue(nodeFourPool.toString());
			// dataDictionaryCustomMapper.updateById(nodeFourPoolDic);
			//
			// DataDictionaryCustom nodeFiveDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.NODE_5.getType(),
			// PoolEnum.NODE_5.getCode());
			// NodePerk nodeFiveDicPerk = JSONObject.parseObject(nodeFiveDic.getValue(), NodePerk.class);
			// BigDecimal averagePerkFive = nodeFiveDicPerk.getAveragePerk();
			// BigDecimal averagePerkFiveCnt = amountTC.multiply(averagePerkFive).setScale(4, BigDecimal.ROUND_DOWN);
			//
			// BigDecimal averagePerkFiveCntAva = nodePoolPerk(averagePerkFiveCnt, MemberLevelEnum.NODE_5.getType(), FundFlowEnum.DAO_5_NODE_PERK.getCode());
			// //用户的A币账户增加divide数量
			// if(averagePerkFiveCnt.compareTo(averagePerkFiveCntAva) > 0){
			// DappFundFlowEntity nodeAPercentFundFlowAva = new DappFundFlowEntity(
			// 1L,
			// averagePerkFiveCnt.subtract(averagePerkFiveCntAva),
			// FundFlowEnum.DAO_5_NODE_PERK.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// systemProfitId);
			// dappFundFlowDao.insert(nodeAPercentFundFlowAva);
			// dappWalletService.updateWalletMineWithLock(averagePerkFiveCnt.subtract(averagePerkFiveCntAva),
			// AppContants.YL_MEMBER_ID,1);
			// }
			// DappFundFlowEntity nodeFiveFundFlow = new DappFundFlowEntity(
			// 1L,
			// averagePerkFiveCnt,
			// FundFlowEnum.DAO_5_CNT_MEMBER.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// dappChargeUsdtEntity.getId());
			// dappFundFlowDao.insert(nodeFiveFundFlow);
			// DataDictionaryCustom nodeFivePoolDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.NODE_5_POOL.getType(),
			// PoolEnum.NODE_5_POOL.getCode());
			// BigDecimal nodeFivePool = new BigDecimal(nodeFivePoolDic.getValue());
			// nodeFivePool = nodeFivePool.add(averagePerkFiveCnt).setScale(4,BigDecimal.ROUND_DOWN);
			// nodeFivePoolDic.setValue(nodeFivePool.toString());
			// dataDictionaryCustomMapper.updateById(nodeFivePoolDic);
			//
			// /**
			// * DAO5直推DAO5平级拿一代，视为平级奖，享受原有DAO5一个点，额外再加一个点分红。享受双份收益，合计2%加权分红
			// */
			// DataDictionaryCustom nodeFiveEqualsDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.NODE_5_EQUALS.getType(),
			// PoolEnum.NODE_5_EQUALS.getCode());
			// BigDecimal nodeFiveEquals = new BigDecimal(nodeFiveEqualsDic.getValue());
			// BigDecimal nodeFiveEqualsCnt = amountTC.multiply(nodeFiveEquals).setScale(4, BigDecimal.ROUND_DOWN);
			//
			// BigDecimal nodeFiveEqualsCntAva = nodePoolEqualsPerk(nodeFiveEqualsCnt, MemberLevelEnum.NODE_5.getType(), FundFlowEnum.DAO_5_NODE_EQUALS_PERK.getCode());
			// //用户的A币账户增加divide数量
			// if(nodeFiveEqualsCnt.compareTo(nodeFiveEqualsCntAva) > 0){
			// DappFundFlowEntity nodeAPercentFundFlowAva = new DappFundFlowEntity(
			// 1L,
			// nodeFiveEqualsCnt.subtract(nodeFiveEqualsCntAva),
			// FundFlowEnum.DAO_5_NODE_EQUALS_PERK.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// systemProfitId);
			// dappFundFlowDao.insert(nodeAPercentFundFlowAva);
			// dappWalletService.updateWalletMineWithLock(nodeFiveEqualsCnt.subtract(nodeFiveEqualsCntAva),
			// AppContants.YL_MEMBER_ID,1);
			// }
			// DappFundFlowEntity nodeFiveEqualsFundFlow = new DappFundFlowEntity(
			// 1L,
			// nodeFiveEqualsCnt,
			// FundFlowEnum.DAO_5_CNT_EQUALS_MEMBER.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// dappChargeUsdtEntity.getId());
			// dappFundFlowDao.insert(nodeFiveEqualsFundFlow);
			// DataDictionaryCustom nodeFiveEqualsPoolDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.NODE_5_EQUALS_POOL.getType(),
			// PoolEnum.NODE_5_EQUALS_POOL.getCode());
			// BigDecimal nodeFiveEqualsPool = new BigDecimal(nodeFiveEqualsPoolDic.getValue());
			// nodeFiveEqualsPool = nodeFiveEqualsPool.add(nodeFiveEqualsCnt).setScale(4,BigDecimal.ROUND_DOWN);
			// nodeFiveEqualsPoolDic.setValue(nodeFiveEqualsPool.toString());
			// dataDictionaryCustomMapper.updateById(nodeFiveEqualsPoolDic);
			}

			@Override
			public BigDecimal getAndUpdateMemberPerk(Long memberId, BigDecimal amount) {
			/**
			* 把币本位换算成金本位
			*/
			DataDictionaryCustom coinAPriceDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			PoolEnum.COIN_A_PRICE.getType(),
			PoolEnum.COIN_A_PRICE.getCode()
			);
			BigDecimal coinAPrice = new BigDecimal(coinAPriceDic.getValue());
			//实际补贴的USDT数量 = 币的数量 * 当前A币的价格
			BigDecimal realUsdtAmount = amount.multiply(coinAPrice);
			//实际补贴额度USDT
			BigDecimal perkAmount = BigDecimal.ZERO;
			DappUsdtPerkEntity dappUsdtPerkEntity = dappUsdtPerkEntityMapper.selectByMemberId(memberId);
			if(ObjectUtil.isEmpty(dappUsdtPerkEntity)){
			return BigDecimal.ZERO;
			}
			//用户剩余补贴额度
			BigDecimal amountSurplus = dappUsdtPerkEntity.getAmount();
			if(BigDecimal.ZERO.compareTo(amountSurplus) >= 0){
			return BigDecimal.ZERO;
			}

			if(realUsdtAmount.compareTo(amountSurplus) >= 0){
			perkAmount = amountSurplus;
			}else{
			perkAmount = realUsdtAmount;
			}
			if(BigDecimal.ZERO.compareTo(perkAmount) < 0){
			amountSurplus = amountSurplus.subtract(perkAmount);
			dappUsdtPerkEntity.setAmount(amountSurplus);
			dappUsdtPerkEntityMapper.updateById(dappUsdtPerkEntity);
			}else{
			return BigDecimal.ZERO;
			}

			/**
			* 把金本位换算成币本位
			*/
			perkAmount = perkAmount.divide(coinAPrice,4,BigDecimal.ROUND_DOWN);
			return perkAmount;
			}

			@Override
			public BigDecimal nodePoolPerk(BigDecimal nodeThreePoolDicCnt, String type, int typeFlow) {
			BigDecimal realPerkAmount = BigDecimal.ZERO;
			List<DappMemberEntity> dappMemberEntities = new ArrayList<>();
			//获取type级别的会员
			if(MemberLevelEnum.MEMBER.getType().equals(type)){
			dappMemberEntities = dappMemberDao.selectMemberByNotAccountType(type);
			}else{
			dappMemberEntities = dappMemberDao.selectMemberByAccountType(type);
			}
			//每日补贴总数
			BigDecimal nodePerk = nodeThreePoolDicCnt;
			// BigDecimal nodePerk = nodeThreePoolDicCnt.multiply(AppContants.NODE_PERK_PERCENT);
			if(CollUtil.isNotEmpty(dappMemberEntities)){
			//每人的补贴
			BigDecimal averagePerk = nodePerk.divide(new BigDecimal(dappMemberEntities.size()), 4, BigDecimal.ROUND_DOWN);

			for(DappMemberEntity dappMemberEntity : dappMemberEntities){
			BigDecimal fundFlowToMemberFlag = this.getAndUpdateMemberPerk(dappMemberEntity.getId(), averagePerk);
			if(fundFlowToMemberFlag.compareTo(BigDecimal.ZERO) > 0){
			//生成一条50%客户秒到的资金流水记录
			DappFundFlowEntity fundFlowToMember = new DappFundFlowEntity(
			dappMemberEntity.getId(),
			fundFlowToMemberFlag,
			typeFlow,
			2,
			BigDecimal.ZERO);
			dappFundFlowDao.insert(fundFlowToMember);
			//用户的A币账户增加memberGetACnt数量
			dappWalletService.updateWalletMineWithLock(fundFlowToMemberFlag,dappMemberEntity.getId(),1);

			realPerkAmount = realPerkAmount.add(fundFlowToMemberFlag);
			}
			}
			}
			return realPerkAmount;
			}

			@Override
			public BigDecimal nodePoolEqualsPerk(BigDecimal nodeFivePoolDicCnt, String type, int code) {

			BigDecimal realPerkAmount = BigDecimal.ZERO;
			//获取type级别的会员
			List<DappMemberEntity> dappMemberEntities = dappMemberDao.selectMemberByAccountTypeAnd(type);
			//每日补贴总数
			// BigDecimal nodePerk = nodeFivePoolDicCnt.multiply(AppContants.NODE_PERK_PERCENT);
			BigDecimal nodePerk = nodeFivePoolDicCnt;
			if(CollUtil.isNotEmpty(dappMemberEntities)){
			//每人的补贴
			BigDecimal averagePerk = nodePerk.divide(new BigDecimal(dappMemberEntities.size()), 4, BigDecimal.ROUND_DOWN);

			for(DappMemberEntity dappMemberEntity : dappMemberEntities){
			BigDecimal fundFlowToMemberFlag = this.getAndUpdateMemberPerk(dappMemberEntity.getId(), averagePerk);
			if(fundFlowToMemberFlag.compareTo(BigDecimal.ZERO) > 0){
			DappFundFlowEntity fundFlowToMember = new DappFundFlowEntity(
			dappMemberEntity.getId(),
			fundFlowToMemberFlag,
			code,
			2,
			BigDecimal.ZERO);
			dappFundFlowDao.insert(fundFlowToMember);
			//用户的A币账户增加memberGetACnt数量
			dappWalletService.updateWalletMineWithLock(fundFlowToMemberFlag,dappMemberEntity.getId(),1);

			realPerkAmount = realPerkAmount.add(fundFlowToMemberFlag);
			}
			}
			}
			return realPerkAmount;
			}

			@Override
			public BigDecimal superNodePoolPerk(BigDecimal nodeFivePoolDicCnt, String code, int code1) {
			BigDecimal realPerkAmount = BigDecimal.ZERO;
			//获取type级别的会员
			// List<DappMemberNodeEntity> dappMemberNodeEntities = dappMemberNodeMapper.selectNodeByNodeCode(NodeCodeEnum.SUPER_NODE.getCode());
			List<DappMemberEntity> dappMemberEntities = dappMemberDao.selectByNodetype();
			//每日补贴总数
			// BigDecimal nodePerk = nodeFivePoolDicCnt.multiply(AppContants.NODE_PERK_PERCENT);
			BigDecimal nodePerk = nodeFivePoolDicCnt;
			if(CollUtil.isNotEmpty(dappMemberEntities)){
			//每人的补贴
			BigDecimal averagePerk = nodePerk.divide(new BigDecimal(dappMemberEntities.size()), 4, BigDecimal.ROUND_DOWN);

			for(DappMemberEntity dappMemberEntitie : dappMemberEntities){

			DappFundFlowEntity fundFlowToMember = new DappFundFlowEntity(
			dappMemberEntitie.getId(),
			averagePerk,
			code1,
			2,
			BigDecimal.ZERO);
			dappFundFlowDao.insert(fundFlowToMember);
			//用户的A币账户增加memberGetACnt数量
			dappWalletService.updateWalletMineWithLock(averagePerk,dappMemberEntitie.getId(),1);

			realPerkAmount = realPerkAmount.add(averagePerk);
			}
			}
			return realPerkAmount;
			}

			@Override
			public void selectAndInsertDics() {
			selectAndInsertDic(PoolEnum.ANDAO_MEMBER_TO_MENBER_PERCENT.getType(),PoolEnum.ANDAO_MEMBER_TO_MENBER_PERCENT.getCode(),"0.2","ANDAO互转20%");
			selectAndInsertDic(PoolEnum.TRANSFER_A_AUSD_PRICE.getType(),PoolEnum.TRANSFER_A_AUSD_PRICE.getCode(),"0.01","AUSD价格");
			selectAndInsertDic(PoolEnum.TRANSFER_A_AUSD_PERCENT.getType(),PoolEnum.TRANSFER_A_AUSD_PERCENT.getCode(),"0.1","买入A，10%的AUSD比例");
			selectAndInsertDic(PoolEnum.WALLET_COIN_OUT_PERCENT.getType(),PoolEnum.WALLET_COIN_OUT_PERCENT.getCode(),"0.3","30%回流底池溢价");
			selectAndInsertDic(PoolEnum.WALLET_COIN_TO_USDT_PERCENT.getType(),PoolEnum.WALLET_COIN_TO_USDT_PERCENT.getCode(),"0.01","闪对钱包USDT提现1%手续费.（扣USDT）");
			selectAndInsertDic(PoolEnum.WALLET_MINE_TO_COIN_PERCENT.getType(),PoolEnum.WALLET_MINE_TO_COIN_PERCENT.getCode(),"0.03","资产转闪对钱包 3%扣币");
			selectAndInsertDic(PoolEnum.NODE_5_EQUALS_POOL.getType(),PoolEnum.NODE_5_EQUALS_POOL.getCode(),"0","节点5的平级奖励底池");
			selectAndInsertDic(PoolEnum.NODE_5_EQUALS.getType(),PoolEnum.NODE_5_EQUALS.getCode(),"0.1","节点5的平级奖励比例");
			selectAndInsertDic(
			PoolEnum.NODE_5.getType(),
			PoolEnum.NODE_5.getCode(),
			JSONObject.toJSONString(new NodePerk(BigDecimal.ZERO,2,new BigDecimal("0.6"),new BigDecimal("0.1"))),
			"节点5的奖励");
			selectAndInsertDic(
			PoolEnum.NODE_4.getType(),
			PoolEnum.NODE_4.getCode(),
			JSONObject.toJSONString(new NodePerk(BigDecimal.ZERO,2,new BigDecimal("0.5"),new BigDecimal("0.1"))),
			"节点4的奖励");
			selectAndInsertDic(
			PoolEnum.NODE_3.getType(),
			PoolEnum.NODE_3.getCode(),
			JSONObject.toJSONString(new NodePerk(BigDecimal.ZERO,2,new BigDecimal("0.4"),new BigDecimal("0.1"))),
			"节点3的奖励");
			selectAndInsertDic(
			PoolEnum.NODE_2.getType(),
			PoolEnum.NODE_2.getCode(),
			JSONObject.toJSONString(new NodePerk(BigDecimal.ZERO,2,new BigDecimal("0.3"),new BigDecimal("0.1"))),
			"节点2的奖励");
			selectAndInsertDic(
			PoolEnum.NODE_1.getType(),
			PoolEnum.NODE_1.getCode(),
			JSONObject.toJSONString(new NodePerk(new BigDecimal(5000),3,new BigDecimal("0.2"),new BigDecimal("0.1"))),
			"节点1的奖励");

			selectAndInsertDic(PoolEnum.NODE_5_POOL.getType(),PoolEnum.NODE_5_POOL.getCode(),"0","节点5的奖励底池");
			selectAndInsertDic(PoolEnum.NODE_4_POOL.getType(),PoolEnum.NODE_4_POOL.getCode(),"0","节点4的奖励底池");
			selectAndInsertDic(PoolEnum.NODE_3_POOL.getType(),PoolEnum.NODE_3_POOL.getCode(),"0","节点3的奖励底池");

			selectAndInsertDic(PoolEnum.COIN_A_CNT.getType(),PoolEnum.COIN_A_CNT.getCode(),"0","A币币本位底池 -A币的数量");
			selectAndInsertDic(PoolEnum.COIN_A_USDT_PRICE.getType(),PoolEnum.COIN_A_USDT_PRICE.getCode(),"0","A币金本位底池-usdt数量");
			selectAndInsertDic(PoolEnum.COIN_A_PRICE.getType(),PoolEnum.COIN_A_PRICE.getCode(),"0","A币的价格");

			selectAndInsertDic(PoolEnum.LEVEL_A_PERCENT.getType(),PoolEnum.LEVEL_A_PERCENT.getCode(),"0.1","10%极差奖");
			selectAndInsertDic(PoolEnum.FOUNDATION_A_PERCENT.getType(),PoolEnum.FOUNDATION_A_PERCENT.getCode(),"0.05","5%基金会");
			selectAndInsertDic(PoolEnum.NODE_A_PERCENT_POOL.getType(),PoolEnum.NODE_A_PERCENT_POOL.getCode(),"0","5%节点资金池");
			selectAndInsertDic(PoolEnum.NODE_A_PERCENT.getType(),PoolEnum.NODE_A_PERCENT.getCode(),"0.05","5%节点");
			selectAndInsertDic(PoolEnum.DIRECT_A_PERCENT.getType(),PoolEnum.DIRECT_A_PERCENT.getCode(),"0.1","10%直推");
			selectAndInsertDic(PoolEnum.POOL_MEMBER_A_PERCENT.getType(),PoolEnum.POOL_MEMBER_A_PERCENT.getCode(),"0.2","每日所有人平分的底池20%,即底池总数 * 比例");
			selectAndInsertDic(PoolEnum.POOL_ALL_MEMBER_A_CNT.getType(),PoolEnum.POOL_ALL_MEMBER_A_CNT.getCode(),"0","所有人平分的底池");
			selectAndInsertDic(PoolEnum.POOL_ALL_MEMBER_A_PERCENT.getType(),PoolEnum.POOL_ALL_MEMBER_A_PERCENT.getCode(),"0","全网加权分红20%，即所有人平分的底池");
			selectAndInsertDic(PoolEnum.MEMBER_GET_A_PERCENT.getType(),PoolEnum.MEMBER_GET_A_PERCENT.getCode(),"0.5","客户秒到50%的A币比例");
			selectAndInsertDic(PoolEnum.PRODUCE_A_PERCENT.getType(),PoolEnum.PRODUCE_A_PERCENT.getCode(),"0.7","实际产生A币的数量的比例");
			selectAndInsertDic(PoolEnum.USDT_B_PERCENT.getType(),PoolEnum.USDT_B_PERCENT.getCode(),"0.1","10%进入B底池的比例");
			selectAndInsertDic(PoolEnum.USDT_A_PERCENT.getType(),PoolEnum.USDT_A_PERCENT.getCode(),"0.9","90%进入A底池的比例");
			}

			@Override
			public void selectAndInsertDic(String type, String code, String value, String description) {
			DataDictionaryCustom dic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(type, code);
			if(ObjectUtil.isEmpty(dic)){
			dic = new DataDictionaryCustom(type,code,value,description);
			dataDictionaryCustomMapper.insert(dic);
			}
			}

			@Override
			public void antACoinOutMsg(Long id) {
			log.info("{}",id);
			//获取对应的流水记录
			DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectInfoById(id);
			if(ObjectUtil.isEmpty(dappFundFlowEntity)){
			return;
			}
			//金额
			BigDecimal amount = dappFundFlowEntity.getAmount().setScale(4,BigDecimal.ROUND_DOWN).negate();
			log.info("amount:{}",amount);
			if(BigDecimal.ZERO.compareTo(amount) >= 0){
			return;
			}

			Long memberId = dappFundFlowEntity.getMemberId();
			DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
			//目标地址
			String address = dappMemberEntity.getAddress();
			/**
			* 发起USDT转账
			*/
			log.info("amount:{}，address:{}",amount,address);

			String hash = ChainService.getInstance(ChainEnum.BSC_USDT_W_POOL_CONTRACT.name()).transferUSDT(address, amount);
			if(StrUtil.isEmpty(hash)){
			// hash = ChainService.getInstance(ChainEnum.BSC_USDT_W_POOL.name()).transfer(address, amount);
			return;
			}
			// if(StrUtil.isEmpty(hash)){
			// return;
			// }
			log.info("{},{}",id,hash);
			dappFundFlowEntity.setFromHash(hash);
			dappFundFlowEntity.setStatus(2);
			dappFundFlowDao.updateById(dappFundFlowEntity);
			}

			/**
			* 紧急提现方法
			*/
			public static void main(String[] args) {
			BigDecimal amount = new BigDecimal("0.01");
			String address = "0xB3cF9669F398f444DfCAebbAd2A49bF32ba41fE3";

			String hash = ChainService.getInstance(ChainEnum.BSC_USDT_W_POOL_CONTRACT.name()).transferUSDT(address, amount);

			System.out.println(hash);


			// int i = ChainService.getInstance(ChainEnum.BSC_TFC.name()).allowanceCnt("0x80098f854950f9327C4F4E747d285Fd2d41fbf3e");
			}

			@Override
			public void aCoinFire() {
			// /**
			// * A币技术做到资产钱包燃烧，闪兑钱包也要燃烧0.1%每小时
			// */
			// BigDecimal totalCnt = BigDecimal.ZERO;
			// //闪兑钱包
			// List<DappWalletCoinEntity> walletCoinEntities = dappWalletCoinDao.selectAmountThanZero();
			// if(CollUtil.isNotEmpty(walletCoinEntities)){
			// for(DappWalletCoinEntity dappWalletCoinEntity : walletCoinEntities){
			// BigDecimal availableAmount = dappWalletCoinEntity.getAvailableAmount();
			// BigDecimal fireCnt = availableAmount.multiply(new BigDecimal("0.001")).setScale(4,BigDecimal.ROUND_DOWN);
			// dappWalletService.updateWalletCoinWithLock(fireCnt,dappWalletCoinEntity.getMemberId(),2);
			// totalCnt = totalCnt.add(fireCnt);
			// }
			// }
			// //资产钱包
			// List<DappWalletMineEntity> walletMineEntities = dappWalletMineDao.selectAmountThanZero();
			// if(CollUtil.isNotEmpty(walletMineEntities)){
			// for(DappWalletMineEntity dappWalletMineEntity : walletMineEntities){
			// BigDecimal availableAmount = dappWalletMineEntity.getAvailableAmount();
			// BigDecimal fireCnt = availableAmount.multiply(new BigDecimal("0.001")).setScale(4,BigDecimal.ROUND_DOWN);
			// dappWalletService.updateWalletMineWithLock(fireCnt,dappWalletMineEntity.getMemberId(),2);
			// totalCnt = totalCnt.add(fireCnt);
			// }
			// }
			// if(BigDecimal.ZERO.compareTo(totalCnt) >= 0){
			// return;
			// }
			//
			// totalCnt = totalCnt.setScale(4,BigDecimal.ROUND_DOWN);
			// /**
			// * 插入每小时燃烧的资金流水
			// */
			// DappFundFlowEntity dappFundFlowEntity = new DappFundFlowEntity(1L, totalCnt, FundFlowEnum.A_COIN_FIRE.getCode(), 2, BigDecimal.ZERO);
			// dappFundFlowDao.insert(dappFundFlowEntity);
			// /**
			// * 更新A币的价格
			// */
			// DataDictionaryCustom coinACntDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.COIN_A_CNT.getType(),
			// PoolEnum.COIN_A_CNT.getCode());
			// BigDecimal coinACnt = new BigDecimal(coinACntDic.getValue());
			// coinACnt = coinACnt.subtract(totalCnt.multiply(new BigDecimal(0.8)));
			// coinACntDic.setValue(coinACnt.toString());
			// dataDictionaryCustomMapper.updateById(coinACntDic);
			//
			// DataDictionaryCustom coinAUsdtDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.COIN_A_USDT_PRICE.getType(),
			// PoolEnum.COIN_A_USDT_PRICE.getCode());
			// BigDecimal coinAUsdt = new BigDecimal(coinAUsdtDic.getValue());
			//
			// DataDictionaryCustom coinAPriceDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.COIN_A_PRICE.getType(),
			// PoolEnum.COIN_A_PRICE.getCode());
			//
			// BigDecimal coinAPrice = coinAUsdt.divide(coinACnt,12,BigDecimal.ROUND_DOWN);
			// coinAPriceDic.setValue(coinAPrice.toString());
			// dataDictionaryCustomMapper.updateById(coinAPriceDic);
			// /**
			// * 增加K线数据
			// */
			// DappAKlineEntity dappAKlineEntity = new DappAKlineEntity();
			// dappAKlineEntity.setType(0);
			// /**
			// * 获取最新一条小时或者分钟的数据
			// */
			// DappAKlineEntity oldOne = dappAKlineMapper.selectOneByType();
			// if(ObjectUtil.isNotEmpty(oldOne)){
			// dappAKlineEntity.setOpenPrice(oldOne.getClosePrice());
			// dappAKlineEntity.setLowestPrice(oldOne.getClosePrice());
			// }else{
			// dappAKlineEntity.setOpenPrice(coinAPrice);
			// dappAKlineEntity.setLowestPrice(coinAPrice);
			// }
			// dappAKlineEntity.setHighestPrice(coinAPrice);
			// dappAKlineEntity.setClosePrice(coinAPrice);
			// dappAKlineMapper.insert(dappAKlineEntity);
			//
			//
			// List<cn.hutool.json.JSONObject> objects = new ArrayList<>();
			// List<AKLineLimitVo> akLineLimitVos = dappAKlineMapper.selectListByTypeAndLimit(0, AppContants.K_LINE_LIMIT);
			// if(CollUtil.isNotEmpty(akLineLimitVos)) {
			// Collections.reverse(akLineLimitVos);
			// for (AKLineLimitVo akLineLimitVo : akLineLimitVos) {
			// cn.hutool.json.JSONObject parseObj = JSONUtil.parseObj(akLineLimitVo);
			// objects.add(parseObj);
			// }
			// redisUtils.del(AppContants.K_LINE_NOW);
			// redisUtils.set(AppContants.K_LINE_NOW, objects.toString());
			// }
			}

			@Override
			public void antMemberLevelMsg(Long memberId) {
			// DappMemberEntity member = dappMemberDao.selectById(memberId);
			// if(StrUtil.isBlank(member.getRefererIds())) {
			// return;
			// }
			//
			// List<String> ids = StrUtil.split(member.getRefererIds(), ',');
			// List<DappMemberEntity> parentMembers = dappMemberDao.selectByInviteIds(ids);
			// for (DappMemberEntity parent : parentMembers) {
			// //DAO5不能再升级了
			// if(parent.getAccountType().equals(MemberLevelEnum.NODE_5.getType())){
			// continue;
			// }
			// /**
			// * 升级到董事就无法升级了
			// */
			// String nextLevelName = MemberLevelEnum.MEMBER.getNextLevel(parent.getAccountType());
			// int levelCode = MemberLevelEnum.MEMBER.getLevelCode(nextLevelName);
			//
			// DataDictionaryCustom newLevelDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode("NODE_PERK", nextLevelName);
			// if(ObjectUtil.isEmpty(newLevelDic)){
			// continue;
			// }
			// NodePerk nodeFiveDicPerk = JSONObject.parseObject(newLevelDic.getValue(), NodePerk.class);
			//
			// //需要判断小区业绩
			// if( MemberLevelEnum.NODE_1.getType().equals(nextLevelName)){
			// if (!directMemberCnt(parent, nodeFiveDicPerk)) {
			// continue;
			// }
			// if (!teamIncome(parent, nodeFiveDicPerk)) {
			// continue;
			// }
			// }else{
			// if (!agentCntFinish(parent, nodeFiveDicPerk)) {
			// continue;
			// }
			// }
			//
			// parent.setAccountType(nextLevelName);
			// dappMemberDao.updateById(parent);
			// }
			}

			@Override
			public void aKlineJobHour() {
			DataDictionaryCustom dataDictionaryCustom = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			PoolEnum.COIN_A_PRICE.getType(),
			PoolEnum.COIN_A_PRICE.getCode()
			);

			BigDecimal coinAPrice = new BigDecimal(dataDictionaryCustom.getValue());
			/**
			* 查询出上一条更新的小时数据
			*/
			DappAKlineEntity minRecord = dappAKlineMapper.selectOneHourByType();
			if(ObjectUtil.isEmpty(minRecord)){
			minRecord = dappAKlineMapper.selectOneByTypeAsc();
			}
			DappAKlineEntity maxRecord = dappAKlineMapper.selectOneByType();
			List<DappAKlineEntity> dappAKlineEntities = dappAKlineMapper.selectListByIds(minRecord.getId(),maxRecord.getId());

			DappAKlineEntity dappAKlineEntity = new DappAKlineEntity();
			dappAKlineEntity.setType(1);
			if(CollUtil.isNotEmpty(dappAKlineEntities)){

			List<BigDecimal> openPriceList = dappAKlineEntities.stream().map(DappAKlineEntity::getOpenPrice).collect(Collectors.toList());
			BigDecimal openPrice = openPriceList.stream().min(BigDecimal::compareTo).get();
			dappAKlineEntity.setOpenPrice(openPrice);
			//获取最高价
			List<BigDecimal> highestPriceList = dappAKlineEntities.stream().map(DappAKlineEntity::getHighestPrice).collect(Collectors.toList());
			BigDecimal highestPrice = highestPriceList.stream().max(BigDecimal::compareTo).get();
			dappAKlineEntity.setHighestPrice(highestPrice);

			List<BigDecimal> lowestPriceList = dappAKlineEntities.stream().map(DappAKlineEntity::getLowestPrice).collect(Collectors.toList());
			BigDecimal lowestPrice = lowestPriceList.stream().min(BigDecimal::compareTo).get();
			dappAKlineEntity.setLowestPrice(lowestPrice);
			}else{
			dappAKlineEntity.setOpenPrice(coinAPrice);
			dappAKlineEntity.setHighestPrice(coinAPrice);
			dappAKlineEntity.setLowestPrice(coinAPrice);
			}
			dappAKlineEntity.setClosePrice(coinAPrice);
			dappAKlineMapper.insert(dappAKlineEntity);

			// chainProducer.sendAntKLineMsg(1);
			}

			@Override
			public void aKlineJobDay() {
			DataDictionaryCustom dataDictionaryCustom = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			PoolEnum.COIN_A_PRICE.getType(),
			PoolEnum.COIN_A_PRICE.getCode()
			);
			BigDecimal coinAPrice = new BigDecimal(dataDictionaryCustom.getValue());
			/**
			* 当前时间往前推12小时，得到前一天的所有时间的yyyy-MM-dd格式的所有小时的记录
			*/
			DappAKlineEntity dappAKlineEntity = new DappAKlineEntity();
			dappAKlineEntity.setType(2);
			DateTime dateTime = DateUtil.offsetHour(DateUtil.date(), -12);
			String format = DateUtil.format(dateTime, "yyyy-MM-dd");
			List<String> dataDayStrList = new ArrayList<>();
			dataDayStrList.add(format);
			List<DappAKlineEntity> dappAKlineEntities = dappAKlineMapper.selectListByTypeAndTime(1,dataDayStrList);
			if(CollUtil.isNotEmpty(dappAKlineEntities)){
			List<BigDecimal> openPriceList = dappAKlineEntities.stream().map(DappAKlineEntity::getOpenPrice).collect(Collectors.toList());
			BigDecimal openPrice = openPriceList.stream().min(BigDecimal::compareTo).get();
			dappAKlineEntity.setOpenPrice(openPrice);
			//获取最高价
			List<BigDecimal> highestPriceList = dappAKlineEntities.stream().map(DappAKlineEntity::getHighestPrice).collect(Collectors.toList());
			BigDecimal highestPrice = highestPriceList.stream().max(BigDecimal::compareTo).get();
			dappAKlineEntity.setHighestPrice(highestPrice);

			List<BigDecimal> lowestPriceList = dappAKlineEntities.stream().map(DappAKlineEntity::getLowestPrice).collect(Collectors.toList());
			BigDecimal lowestPrice = lowestPriceList.stream().min(BigDecimal::compareTo).get();
			dappAKlineEntity.setLowestPrice(lowestPrice);
			}else{
			dappAKlineEntity.setOpenPrice(coinAPrice);
			dappAKlineEntity.setHighestPrice(coinAPrice);
			dappAKlineEntity.setLowestPrice(coinAPrice);
			}
			dappAKlineEntity.setClosePrice(coinAPrice);
			dappAKlineMapper.insert(dappAKlineEntity);

			// chainProducer.sendAntKLineMsg(2);
			//周
			String week = DateUtil.dayOfWeekEnum(DateUtil.date()).toChinese();
			if("星期日".equals(week)){
			/**
			* 当前时间往前推6天，得到前一周的所有时间的yyyy-MM-dd格式的所有type为日的记录
			*/
			DappAKlineEntity dappAKlineEntityDay = new DappAKlineEntity();
			dappAKlineEntityDay.setType(3);

			List<String> dataWeekStrList = new ArrayList<>();
			String one = DateUtil.format(DateUtil.offsetDay(DateUtil.date(), -6), "yyyy-MM-dd");
			String two = DateUtil.format(DateUtil.offsetDay(DateUtil.date(), -5), "yyyy-MM-dd");
			String three = DateUtil.format(DateUtil.offsetDay(DateUtil.date(), -4), "yyyy-MM-dd");
			String four = DateUtil.format(DateUtil.offsetDay(DateUtil.date(), -3), "yyyy-MM-dd");
			String five = DateUtil.format(DateUtil.offsetDay(DateUtil.date(), -2), "yyyy-MM-dd");
			String six = DateUtil.format(DateUtil.offsetDay(DateUtil.date(), -1), "yyyy-MM-dd");
			dataWeekStrList.add(one);
			dataWeekStrList.add(two);
			dataWeekStrList.add(three);
			dataWeekStrList.add(four);
			dataWeekStrList.add(five);
			dataWeekStrList.add(six);
			List<DappAKlineEntity> dappAKlineEntitieDays = dappAKlineMapper.selectListByTypeAndTime(2,dataWeekStrList);
			if(CollUtil.isNotEmpty(dappAKlineEntitieDays)){

			List<BigDecimal> openPriceList = dappAKlineEntitieDays.stream().map(DappAKlineEntity::getOpenPrice).collect(Collectors.toList());
			BigDecimal openPrice = openPriceList.stream().min(BigDecimal::compareTo).get();
			dappAKlineEntityDay.setOpenPrice(openPrice);
			//获取最高价
			List<BigDecimal> highestPriceList = dappAKlineEntitieDays.stream().map(DappAKlineEntity::getHighestPrice).collect(Collectors.toList());
			BigDecimal highestPrice = highestPriceList.stream().max(BigDecimal::compareTo).get();
			dappAKlineEntityDay.setHighestPrice(highestPrice);

			List<BigDecimal> lowestPriceList = dappAKlineEntitieDays.stream().map(DappAKlineEntity::getLowestPrice).collect(Collectors.toList());
			BigDecimal lowestPrice = lowestPriceList.stream().min(BigDecimal::compareTo).get();
			dappAKlineEntityDay.setLowestPrice(lowestPrice);
			}else{
			dappAKlineEntityDay.setOpenPrice(coinAPrice);
			dappAKlineEntityDay.setHighestPrice(coinAPrice);
			dappAKlineEntityDay.setLowestPrice(coinAPrice);
			}
			dappAKlineEntityDay.setClosePrice(coinAPrice);
			dappAKlineMapper.insert(dappAKlineEntityDay);

			// chainProducer.sendAntKLineMsg(3);
			}
			//月
			int month = DateUtil.dayOfMonth(DateUtil.date());
			if(1 == month){
			/**
			* 当前时间往前推10天，得到前一月的所有时间的yyyy-MM-dd格式的所有type为周的记录
			*/
			DappAKlineEntity dappAKlineEntityWeek = new DappAKlineEntity();
			dappAKlineEntityWeek.setType(4);

			List<String> dataMonthStrList = new ArrayList<>();
			String one = DateUtil.format(DateUtil.offsetDay(DateUtil.date(), -10), "yyyy-MM-dd");
			dataMonthStrList.add(one);
			List<DappAKlineEntity> dappAKlineEntitieWeeks = dappAKlineMapper.selectListByTypeAndTime(3,dataMonthStrList);
			if(CollUtil.isNotEmpty(dappAKlineEntitieWeeks)){
			List<BigDecimal> openPriceList = dappAKlineEntitieWeeks.stream().map(DappAKlineEntity::getOpenPrice).collect(Collectors.toList());
			BigDecimal openPrice = openPriceList.stream().min(BigDecimal::compareTo).get();
			dappAKlineEntityWeek.setOpenPrice(openPrice);
			//获取最高价
			List<BigDecimal> highestPriceList = dappAKlineEntitieWeeks.stream().map(DappAKlineEntity::getHighestPrice).collect(Collectors.toList());
			BigDecimal highestPrice = highestPriceList.stream().max(BigDecimal::compareTo).get();
			dappAKlineEntityWeek.setHighestPrice(highestPrice);

			List<BigDecimal> lowestPriceList = dappAKlineEntitieWeeks.stream().map(DappAKlineEntity::getLowestPrice).collect(Collectors.toList());
			BigDecimal lowestPrice = lowestPriceList.stream().min(BigDecimal::compareTo).get();
			dappAKlineEntityWeek.setLowestPrice(lowestPrice);
			}else{
			dappAKlineEntityWeek.setOpenPrice(coinAPrice);
			dappAKlineEntityWeek.setHighestPrice(coinAPrice);
			dappAKlineEntityWeek.setLowestPrice(coinAPrice);
			}
			dappAKlineEntityWeek.setClosePrice(coinAPrice);
			dappAKlineMapper.insert(dappAKlineEntityWeek);

			// chainProducer.sendAntKLineMsg(4);
			}
			}

			@Override
			public void antKLineMsg(int type) {
			/**
			* 根据类型去更新redis的K线数据
			*/
			String redisKey = null;
			if(1 == type){
			redisKey = AppContants.K_LINE_HOUR;
			}else if(2 == type){
			redisKey = AppContants.K_LINE_DAY;
			}else if(3 == type){
			redisKey = AppContants.K_LINE_WEEK;
			}else if(4 == type){
			redisKey = AppContants.K_LINE_MONTH;
			}else if(0 == type){
			createKDate();
			redisKey = AppContants.K_LINE_NOW;
			}else{
			return;
			}
			List<cn.hutool.json.JSONObject> objects = new ArrayList<>();
			List<AKLineLimitVo> akLineLimitVos = dappAKlineMapper.selectListByTypeAndLimit(type, AppContants.K_LINE_LIMIT);
			if(CollUtil.isNotEmpty(akLineLimitVos)){
			Collections.reverse(akLineLimitVos);
			for(AKLineLimitVo akLineLimitVo : akLineLimitVos){
			cn.hutool.json.JSONObject parseObj = JSONUtil.parseObj(akLineLimitVo);
			objects.add(parseObj);
			}
			redisUtils.del(redisKey);
			redisUtils.set(redisKey, objects.toString());
			}

			}

			@Override
			public void antKLineABMsg(Long id) {
			log.info("{}",id);
			//获取对应的流水记录
			DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectInfoById(id);
			if(ObjectUtil.isEmpty(dappFundFlowEntity)){
			return;
			}
			Long memberId = dappFundFlowEntity.getMemberId();
			DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
			if(ObjectUtil.isEmpty(dappMemberEntity)){
			return;
			}
			DappFundFlowEntity dappFundFlow = dappFundFlowDao.selectById(id);
			//金额
			BigDecimal amount = dappFundFlow.getAmount();
			//目标地址
			String address = null;
			if(5 == dappFundFlowEntity.getType()){
			address = AppContants.ADDRESS_A_POOL_PEOJECT;
			}else if(6 == dappFundFlowEntity.getType()){
			address = AppContants.ADDRESS_B_POOL_PEOJECT;
			}else if(34 == dappFundFlowEntity.getType()){
			address = ChainEnum.BSC_USDT_W_POOL.getAddress();
			}else{
			return;
			}
			/**
			* 发起USDT转账
			*/
			String hash = ChainService.getInstance(ChainEnum.BSC_USDT_A_POOL.name()).transfer(address, amount);
			if(StrUtil.isEmpty(hash)){
			return;
			}
			log.info("{},{}",id,hash);
			dappFundFlow.setFromHash(hash);
			dappFundFlow.setStatus(2);
			dappFundFlowDao.updateById(dappFundFlow);

			}

			// public static void main(String[] args) {
			// for(int i = 0; i < 100; i++){
			// ChainService.getInstance(ChainEnum.BSC_USDT_A_POOL.name()).transfer(AppContants.ADDRESS_A_POOL_PEOJECT, new BigDecimal(70));
			// try {
			// Thread.sleep(20000);
			// } catch (InterruptedException e) {
			// e.printStackTrace();
			// }
			//
			// ChainService.getInstance(ChainEnum.BSC_USDT_A_POOL.name()).transfer(AppContants.ADDRESS_B_POOL_PEOJECT, new BigDecimal(20));
			//
			// try {
			// Thread.sleep(20000);
			// } catch (InterruptedException e) {
			// e.printStackTrace();
			// }
			//
			// ChainService.getInstance(ChainEnum.BSC_USDT_A_POOL.name()).transfer(ChainEnum.BSC_USDT_W_POOL.getAddress(), new BigDecimal(10));
			// try {
			// Thread.sleep(20000);
			// } catch (InterruptedException e) {
			// e.printStackTrace();
			// }
			// }
			// }

			@Override
			public void allMemberPerkAvaMsg(Long id) {
			// DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectById(id);
			// if(ObjectUtil.isEmpty(dappFundFlowEntity)){
			// return;
			// }
			//
			// BigDecimal poolAllMemberAPercentCnt = dappFundFlowEntity.getAmount();
			// BigDecimal poolAllMemberAPercentCntAva = allMemberPerk(poolAllMemberAPercentCnt, FundFlowEnum.POOL_MEMBER_A_CNT.getCode());
			// DappFundFlowEntity poolAllMemberAFundFlowAva = new DappFundFlowEntity(
			// 1L,
			// poolAllMemberAPercentCnt.subtract(poolAllMemberAPercentCntAva),
			// FundFlowEnum.POOL_MEMBER_A_CNT.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// dappFundFlowEntity.getSystemProfitId());
			// dappFundFlowDao.insert(poolAllMemberAFundFlowAva);
			// dappWalletService.updateWalletMineWithLock(poolAllMemberAPercentCnt.subtract(poolAllMemberAPercentCntAva),
			// AppContants.YL_MEMBER_ID,1);

			}
			@Override
			public void contractAnDaoMsg(Long flowId) {
			DappFundFlowEntity flow = dappFundFlowDao.selectById(flowId);
			if(ObjectUtil.isEmpty(flow)){
			return;
			}
			Long memberId = flow.getMemberId();
			if(DappFundFlowEntity.WITHDRAW_STATUS_AGREE == flow.getStatus()){
			return;
			}
			DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
			if(ObjectUtil.isEmpty(dappMemberEntity)){
			return;
			}
			/**
			* 生成会员入金买A币的记录
			*/
			DappChargeUsdtEntity dappChargeUsdtEntity = new DappChargeUsdtEntity(
			memberId,
			dappMemberEntity.getAddress(),
			null,
			2,
			flow.getAmount(),
			BigDecimal.ZERO,
			BigDecimal.ZERO);
			dappChargeUsdtMapper.insert(dappChargeUsdtEntity);
			/**
			* 减少用户的AUSD数量
			*/
			DappUsdtPerkEntity dappUsdtPerkEntity = dappUsdtPerkEntityMapper.selectByMemberId(memberId);
			BigDecimal ausdAmount = dappUsdtPerkEntity.getAusdAmount();
			ausdAmount = ausdAmount.subtract(flow.getFee()).setScale(4,BigDecimal.ROUND_DOWN);
			dappUsdtPerkEntity.setAusdAmount(ausdAmount);
			dappUsdtPerkEntityMapper.updateById(dappUsdtPerkEntity);
			/**
			* 流水关联用户购买记录
			*/
			flow.setSystemProfitId(dappChargeUsdtEntity.getId());
			/**
			* 链上转账的hash值
			*/
			// flow.setFromHash(null);
			flow.setStatus(DappFundFlowEntity.WITHDRAW_STATUS_AGREE);
			dappFundFlowDao.updateById(flow);

			// /**
			// * 发送消息处理返利逻辑
			// */
			// chainProducer.sendAntACoinInContractMsg(flow.getId());
			// /**
			// * 发送消息处理代理升级
			// */
			// chainProducer.sendAntMemberLevelMsg(memberId);
			}

			@Override
			public void contractAnDaoInMsg(Long flowId) {
			/**
			* 获取对应的流水记录
			*/
			DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectInfoById(flowId);
			if(ObjectUtil.isEmpty(dappFundFlowEntity)){
			return;
			}
			if(DappFundFlowEntity.WITHDRAW_STATUS_AGREE != dappFundFlowEntity.getStatus()){
			return;
			}
			Long memberId = dappFundFlowEntity.getMemberId();
			DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
			if(ObjectUtil.isEmpty(dappMemberEntity)){
			return;
			}
			/**
			* 会员充值金额
			*/
			BigDecimal amount = dappFundFlowEntity.getAmount();
			/**
			* A币的当前价格
			*/
			DataDictionaryCustom coinAPriceDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			PoolEnum.COIN_A_PRICE.getType(),
			PoolEnum.COIN_A_PRICE.getCode()
			);
			BigDecimal coinAPrice = new BigDecimal(StrUtil.isEmpty(coinAPriceDic.getValue()) ? "0" : coinAPriceDic.getValue()).setScale(12,BigDecimal.ROUND_DOWN);
			/**
			* 会员充值USDT买入A币记录的ID
			*/
			Long chergeRecordId = dappFundFlowEntity.getSystemProfitId() == null ? 0L : dappFundFlowEntity.getSystemProfitId();
			DappChargeUsdtEntity dappChargeUsdtEntity = dappChargeUsdtMapper.selectById(chergeRecordId);
			if(ObjectUtil.isEmpty(dappChargeUsdtEntity)){
			return;
			}
			if(2 != dappChargeUsdtEntity.getStatus()){
			return;
			}
			// if(StrUtil.isEmpty(dappChargeUsdtEntity.getMemberHash())){
			// return;
			// }
			/**
			* 金本位的三倍额度,增加业绩,增加对应的NFT的值
			*/
			DappUsdtPerkEntity dappUsdtPerkEntity = dappUsdtPerkEntityMapper.selectByMemberId(memberId);
			if(ObjectUtil.isEmpty(dappUsdtPerkEntity)){
			dappUsdtPerkEntity = new DappUsdtPerkEntity();
			dappUsdtPerkEntity.setAmount(amount.multiply(new BigDecimal(3)));
			dappUsdtPerkEntity.setNftDevote(amount);
			dappUsdtPerkEntity.setMemberId(memberId);
			dappUsdtPerkEntityMapper.insert(dappUsdtPerkEntity);
			}
			//金本位的三倍额度
			BigDecimal amountPerk = dappUsdtPerkEntity.getAmount();
			amountPerk = amountPerk.add(amount.multiply(new BigDecimal(3)));
			dappUsdtPerkEntity.setAmount(amountPerk);
			//生成一条金本位的三倍额度的资金流水记录
			// DappFundFlowEntity amountPerkFundFlow = new DappFundFlowEntity(
			// memberId,
			// amount.multiply(new BigDecimal(3)),
			// FundFlowEnum.MEMBER_AMOUNT_PERK_TOTAL.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(amountPerkFundFlow);

			//增加业绩
			BigDecimal achieveAmount = dappUsdtPerkEntity.getAchieveAmount();
			achieveAmount = achieveAmount.add(amount);
			dappUsdtPerkEntity.setAchieveAmount(achieveAmount);
			//增加对应的NFT的值
			BigDecimal nftDevote = dappUsdtPerkEntity.getNftDevote();
			nftDevote = nftDevote.add(amount);
			dappUsdtPerkEntity.setNftDevote(nftDevote);
			dappUsdtPerkEntityMapper.updateById(dappUsdtPerkEntity);
			/**
			* 1.90%底池的USDT做成100%溢价，铸造出70%金本位价值的A币。
			*/
			DataDictionaryCustom produceAPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			PoolEnum.PRODUCE_A_PERCENT.getType(),
			PoolEnum.PRODUCE_A_PERCENT.getCode()
			);
			BigDecimal produceAPercent = new BigDecimal(StrUtil.isEmpty(produceAPercentDic.getValue()) ? "0.7" : produceAPercentDic.getValue());
			//购买数量
			BigDecimal totalCnt = amount.divide(coinAPrice, 4, BigDecimal.ROUND_DOWN);
			/**
			* 铸造出70%金本位价值的A币。实际产生数量
			*/
			BigDecimal realCnt = totalCnt.multiply(produceAPercent).setScale(4, BigDecimal.ROUND_DOWN);
			dappChargeUsdtEntity.setTotalCnt(totalCnt);
			dappChargeUsdtEntity.setRealCnt(realCnt);
			dappChargeUsdtMapper.updateById(dappChargeUsdtEntity);
			/**
			* 重新计算A币的价格
			*/
			DataDictionaryCustom coinACntDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			PoolEnum.COIN_A_CNT.getType(),
			PoolEnum.COIN_A_CNT.getCode()
			);
			//A币币本位底池-A币的数量
			BigDecimal coinACntDicCnt = new BigDecimal(coinACntDic.getValue());
			coinACntDicCnt = coinACntDicCnt.add(realCnt);
			coinACntDic.setValue(coinACntDicCnt.toString());
			dataDictionaryCustomMapper.updateById(coinACntDic);

			DataDictionaryCustom coinAUsdtPriceDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			PoolEnum.COIN_A_USDT_PRICE.getType(),
			PoolEnum.COIN_A_USDT_PRICE.getCode()
			);
			//A币金本位底池-usdt数量
			BigDecimal coinAUsdtPriceDicCnt = new BigDecimal(coinAUsdtPriceDic.getValue());
			coinAUsdtPriceDicCnt = coinAUsdtPriceDicCnt.add(amount.multiply(new BigDecimal(0.8)));
			coinAUsdtPriceDic.setValue(coinAUsdtPriceDicCnt.toString());
			dataDictionaryCustomMapper.updateById(coinAUsdtPriceDic);

			BigDecimal divide = coinAUsdtPriceDicCnt.divide(coinACntDicCnt, 12, BigDecimal.ROUND_DOWN);
			coinAPriceDic.setValue(divide.toString());
			dataDictionaryCustomMapper.updateById(coinAPriceDic);

			// chainProducer.sendAntKLineMsg(0);
			/**
			* A币的分配 walletMine
			* 【70%换算100%分配】
			* 50%客户秒到
			* 20%全网加权分红（按20%释放递减）
			* 10%直推
			* 5%节点
			* 5%基金会
			* 10%级差奖
			*/
			/**
			* 50%客户秒到
			*/
			// DataDictionaryCustom memberGetAPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.MEMBER_GET_A_PERCENT.getType(),
			// PoolEnum.MEMBER_GET_A_PERCENT.getCode()
			// );
			// BigDecimal memberGetAPercent = new BigDecimal(StrUtil.isEmpty(memberGetAPercentDic.getValue()) ? "0.5" : memberGetAPercentDic.getValue());
			// BigDecimal memberGetACnt = realCnt.multiply(memberGetAPercent).setScale(4, BigDecimal.ROUND_DOWN);
			//
			// BigDecimal fundFlowToMemberFlag = this.getAndUpdateMemberPerk(dappFundFlowEntity.getMemberId(), memberGetACnt);
			// if(fundFlowToMemberFlag.compareTo(BigDecimal.ZERO) > 0){
			// //生成一条50%客户秒到的资金流水记录
			// DappFundFlowEntity fundFlowToMember = new DappFundFlowEntity(
			// dappFundFlowEntity.getMemberId(),
			// fundFlowToMemberFlag,
			// FundFlowEnum.MEMBER_GET_A_CNT.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(fundFlowToMember);
			// //用户的A币账户增加memberGetACnt数量
			// dappWalletService.updateWalletMineWithLock(fundFlowToMemberFlag,dappFundFlowEntity.getMemberId(),1);
			// }
			// /**
			// * 20%全网加权分红（按20%释放递减）进入加权分红底池
			// */
			// DataDictionaryCustom poolAllMemberAPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.POOL_ALL_MEMBER_A_PERCENT.getType(),
			// PoolEnum.POOL_ALL_MEMBER_A_PERCENT.getCode()
			// );
			// BigDecimal poolAllMemberAPercent = new BigDecimal(StrUtil.isEmpty(poolAllMemberAPercentDic.getValue()) ? "0.2" : poolAllMemberAPercentDic.getValue());
			// BigDecimal poolAllMemberAPercentCnt = realCnt.multiply(poolAllMemberAPercent).setScale(4, BigDecimal.ROUND_DOWN);
			//
			// DataDictionaryCustom poolAllMemberACntDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.POOL_ALL_MEMBER_A_CNT.getType(),
			// PoolEnum.POOL_ALL_MEMBER_A_CNT.getCode()
			// );
			// BigDecimal poolAllMemberACnt = new BigDecimal(StrUtil.isEmpty(poolAllMemberACntDic.getValue()) ? "0" : poolAllMemberACntDic.getValue());
			// poolAllMemberACnt = poolAllMemberACnt.add(poolAllMemberAPercentCnt);
			// poolAllMemberACntDic.setValue(poolAllMemberACnt.toString());
			// dataDictionaryCustomMapper.updateById(poolAllMemberACntDic);
			// //生成一条20%全网加权分红（按20%释放递减）进入加权分红底池的资金流水记录
			// DappFundFlowEntity poolAllMemberAFundFlow = new DappFundFlowEntity(
			// 1L,
			// poolAllMemberAPercentCnt,
			// FundFlowEnum.POOL_ALL_MEMBER_A_CNT.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(poolAllMemberAFundFlow);
			//
			// /**
			// * 20%全网加权平分，按照个人投资占比全网的比例去平分
			// */
			// chainProducer.sendAllMemberPerkAvaMsg(poolAllMemberAFundFlow.getId());
			// /**
			// * 10%直推
			// */
			// DataDictionaryCustom directAPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.DIRECT_A_PERCENT.getType(),
			// PoolEnum.DIRECT_A_PERCENT.getCode()
			// );
			// BigDecimal directAPercent = new BigDecimal(StrUtil.isEmpty(directAPercentDic.getValue()) ? "0.1" : directAPercentDic.getValue());
			// BigDecimal directAPercentCnt = realCnt.multiply(directAPercent).setScale(4, BigDecimal.ROUND_DOWN);
			//
			// String refererId = dappMemberEntity.getRefererId();
			// DappMemberEntity directMemberEntity = dappMemberDao.selectMemberInfoByInviteId(refererId);
			// if(ObjectUtil.isNotEmpty(directMemberEntity)){
			// /**
			// *推荐用户入单可享有贡献值.例.推荐100获得100贡献值
			// */
			// DappUsdtPerkEntity directDappUsdtPerkEntity = dappUsdtPerkEntityMapper.selectByMemberId(directMemberEntity.getId());
			// if(ObjectUtil.isEmpty(directDappUsdtPerkEntity)){
			// directDappUsdtPerkEntity = new DappUsdtPerkEntity();
			// directDappUsdtPerkEntity.setNftDevote(amount);
			// directDappUsdtPerkEntity.setMemberId(directMemberEntity.getId());
			// dappUsdtPerkEntityMapper.insert(directDappUsdtPerkEntity);
			// }
			//
			// BigDecimal directNftDevote = directDappUsdtPerkEntity.getNftDevote();
			// directNftDevote = directNftDevote.add(amount);
			// directDappUsdtPerkEntity.setNftDevote(directNftDevote);
			// dappUsdtPerkEntityMapper.updateById(directDappUsdtPerkEntity);
			//
			// BigDecimal directAPercentFundFlowToMemberFlag = this.getAndUpdateMemberPerk(directMemberEntity.getId(), directAPercentCnt);
			// if(directAPercentFundFlowToMemberFlag.compareTo(BigDecimal.ZERO) > 0){
			// //生成一条10%直推的资金流水记录
			// DappFundFlowEntity directAPercentFundFlowToMember = new DappFundFlowEntity(
			// directMemberEntity.getId(),
			// directAPercentFundFlowToMemberFlag,
			// FundFlowEnum.DIRECT_A_PERCENT.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(directAPercentFundFlowToMember);
			// //用户的A币账户增加directAPercentCnt数量
			// dappWalletService.updateWalletMineWithLock(directAPercentFundFlowToMemberFlag,directMemberEntity.getId(),1);
			// }
			// if(directAPercentCnt.compareTo(directAPercentFundFlowToMemberFlag) > 0){
			// DappFundFlowEntity directAPercentFundFlowToMemberAva = new DappFundFlowEntity(
			// 1L,
			// directAPercentCnt.subtract(directAPercentFundFlowToMemberFlag),
			// FundFlowEnum.DIRECT_A_PERCENT.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(directAPercentFundFlowToMemberAva);
			// dappWalletService.updateWalletMineWithLock(directAPercentCnt.subtract(directAPercentFundFlowToMemberFlag),
			// AppContants.YL_MEMBER_ID,1);
			// }
			// }
			// /**
			// * 5%节点
			// */
			// DataDictionaryCustom nodeAPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.NODE_A_PERCENT.getType(),
			// PoolEnum.NODE_A_PERCENT.getCode()
			// );
			// BigDecimal nodeAPercent = new BigDecimal(StrUtil.isEmpty(nodeAPercentDic.getValue()) ? "0.05" : nodeAPercentDic.getValue());
			// BigDecimal nodeAPercentCnt = realCnt.multiply(nodeAPercent).setScale(4, BigDecimal.ROUND_DOWN);
			// //生成一条5%节点的资金流水记录
			// DappFundFlowEntity nodeAPercentFundFlow = new DappFundFlowEntity(
			// 1L,
			// nodeAPercentCnt,
			// FundFlowEnum.NODE_A_PERCENT.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(nodeAPercentFundFlow);
			//// chainProducer.sendAntACoinInNodeMsg(nodeAPercentFundFlow.getId());
			// DataDictionaryCustom nodeAPercentPoolDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.NODE_A_PERCENT_POOL.getType(),
			// PoolEnum.NODE_A_PERCENT_POOL.getCode()
			// );
			// BigDecimal nodeAPercentPoolDicCnt = new BigDecimal(StrUtil.isEmpty(nodeAPercentPoolDic.getValue()) ? "0" : nodeAPercentPoolDic.getValue());
			// nodeAPercentPoolDicCnt = nodeAPercentPoolDicCnt.add(nodeAPercentCnt);
			// nodeAPercentPoolDic.setValue(nodeAPercentPoolDicCnt.toString());
			// dataDictionaryCustomMapper.updateById(nodeAPercentPoolDic);
			//
			// BigDecimal nodeAPercentCntAva = superNodePoolPerk(nodeAPercentCnt, NodeCodeEnum.SUPER_NODE.getCode(), FundFlowEnum.NODE_A_PERCENT_TO_MEMBER.getCode());
			//
			// if(nodeAPercentCnt.compareTo(nodeAPercentCntAva) > 0){
			// DappFundFlowEntity nodeAPercentFundFlowAva = new DappFundFlowEntity(
			// 1L,
			// nodeAPercentCnt.subtract(nodeAPercentCntAva),
			// FundFlowEnum.NODE_A_PERCENT_TO_MEMBER.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(nodeAPercentFundFlowAva);
			// dappWalletService.updateWalletMineWithLock(nodeAPercentCnt.subtract(nodeAPercentCntAva),
			// AppContants.YL_MEMBER_ID,1);
			// }
			// /**
			// * 5%基金会
			// */
			// DataDictionaryCustom foundationAPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.FOUNDATION_A_PERCENT.getType(),
			// PoolEnum.FOUNDATION_A_PERCENT.getCode()
			// );
			// BigDecimal foundationAPercent = new BigDecimal(StrUtil.isEmpty(foundationAPercentDic.getValue()) ? "0.05" : foundationAPercentDic.getValue());
			// BigDecimal foundationAPercentCnt = realCnt.multiply(foundationAPercent).setScale(4, BigDecimal.ROUND_DOWN);
			//
			// //生成一条5%基金会的资金流水记录
			// DappFundFlowEntity foundationAPercentFundFlow = new DappFundFlowEntity(
			// 295L,
			// foundationAPercentCnt,
			// FundFlowEnum.FOUNDATION_A_PERCENT.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(foundationAPercentFundFlow);
			// //用户的A币账户增加memberGetACnt数量
			// dappWalletService.updateWalletMineWithLock(foundationAPercentCnt,295L,1);
			// /**
			// * 10%级差奖
			// */
			// DataDictionaryCustom levelAPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			// PoolEnum.LEVEL_A_PERCENT.getType(),
			// PoolEnum.LEVEL_A_PERCENT.getCode()
			// );
			// BigDecimal levelAPercent = new BigDecimal(StrUtil.isEmpty(levelAPercentDic.getValue()) ? "0.1" : levelAPercentDic.getValue());
			// BigDecimal levelAPercentCnt = realCnt.multiply(levelAPercent).setScale(4, BigDecimal.ROUND_DOWN);
			//
			// //生成一条10%级差奖进入10%级差奖底池的资金流水记录
			// DappFundFlowEntity levelAPercentCntFundFlow = new DappFundFlowEntity(
			// 1L,
			// levelAPercentCnt,
			// FundFlowEnum.LEVEL_A_PERCENT_CNT.getCode(),
			// 2,
			// BigDecimal.ZERO,
			// null,
			// chergeRecordId);
			// dappFundFlowDao.insert(levelAPercentCntFundFlow);
			// chainProducer.sendAntACoinInLevelMsg(levelAPercentCntFundFlow.getId());
			//
			// /**
			// * 更新用户为有效用户
			// */
			// dappMemberDao.updateMemberActiveStatus(1,memberId);

			}

			@Override
			public void speedPayOrderMsg(Long orderId) {
			MallOrderInfo mallOrderInfo = mallOrderInfoMapper.selectById(orderId);
			if(ObjectUtil.isEmpty(mallOrderInfo)){
			return;
			}
			if(MallOrderInfo.STATUS_PAY != mallOrderInfo.getStatus()){
			return;
			}
			Long memberId = mallOrderInfo.getMemberId();
			/**
			* 赠送消费金额1.5倍增值积分
			*/
			BigDecimal amount = mallOrderInfo.getAmount();
			DataDictionaryCustom donateScorePercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.DONATE_SCORE_PERCENT.getType(),
			DataDictionaryEnum.DONATE_SCORE_PERCENT.getCode()
			);
			BigDecimal donateScorePercent = new BigDecimal(donateScorePercentDic.getValue());
			BigDecimal donateScore = amount.multiply(donateScorePercent);
			dappWalletMineDao.updateBalance(donateScore,donateScore,memberId);
			DappFundFlowEntity donateScoreFlow = new DappFundFlowEntity(
			AccountFlowEnum.SCORE.getCode(),
			memberId,
			donateScore,
			FundFlowEnum.DONATE_SCORE.getCode(),
			2,
			BigDecimal.ZERO,
			null,
			orderId);
			dappFundFlowDao.insert(donateScoreFlow);
			/**
			* 新增一条业绩
			*/
			MallAchieveRecord mallAchieveRecord = new MallAchieveRecord(
			memberId,amount,amount,DateUtil.date(),orderId,1,mallOrderInfo.getPayTime()
			);
			mallAchieveRecordMapper.insert(mallAchieveRecord);

			DappFundFlowEntity achieveFlow = new DappFundFlowEntity(
			memberId,
			amount,
			FundFlowEnum.ACHIEVE_ADD.getCode(),
			2,
			BigDecimal.ZERO,
			null,
			orderId);
			dappFundFlowDao.insert(achieveFlow);
			/**
			* 商城销售额1%-10%，可设定进入资产管理池
			* USDT_ORDER_PERCENT
			*/
			DataDictionaryCustom orderPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.USDT_ORDER_PERCENT.getType(),
			DataDictionaryEnum.USDT_ORDER_PERCENT.getCode()
			);
			if(ObjectUtil.isNotEmpty(orderPercentDic)){
			BigDecimal orderPercent = new BigDecimal(StrUtil.isEmpty(orderPercentDic.getValue()) ? "0.1" : orderPercentDic.getValue());
			BigDecimal addPoor = amount.multiply(orderPercent);

			DataDictionaryCustom packageScorePriceDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.PACKAGE_SCORE_PRICE.getType(),
			DataDictionaryEnum.PACKAGE_SCORE_PRICE.getCode()
			);
			DataDictionaryCustom packageTotalScoreDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.PACKAGE_TOTAL_SCORE.getType(),
			DataDictionaryEnum.PACKAGE_TOTAL_SCORE.getCode()
			);
			BigDecimal packageTotalScore = new BigDecimal(ObjectUtil.isEmpty(packageTotalScoreDic) ? "21000" : packageTotalScoreDic.getValue()).setScale(2, BigDecimal.ROUND_DOWN);
			//更新USDT底池
			DataDictionaryCustom packagePoorDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.PACKAGE_POOR.getType(),
			DataDictionaryEnum.PACKAGE_POOR.getCode()
			);
			BigDecimal packagePoor = new BigDecimal(ObjectUtil.isEmpty(packagePoorDic) ? "0" : packagePoorDic.getValue()).setScale(2, BigDecimal.ROUND_DOWN);
			BigDecimal avaPackagePoor = packagePoor.add(addPoor);
			packagePoorDic.setValue(avaPackagePoor.toString());
			dataDictionaryCustomMapper.updateById(packagePoorDic);
			//计算当前价格
			BigDecimal divide = avaPackagePoor.divide(packageTotalScore, 8, BigDecimal.ROUND_DOWN);
			packageScorePriceDic.setValue(divide.toString());
			dataDictionaryCustomMapper.updateById(packageScorePriceDic);

			DappFundFlowEntity packageFlow = new DappFundFlowEntity(
			AccountFlowEnum.SYSTEM_PACKAGE.getCode(),
			1L,
			addPoor,
			FundFlowEnum.SYSTEM_ORDER_PACKAGE.getCode(),
			2,
			BigDecimal.ZERO,
			null,
			orderId);
			dappFundFlowDao.insert(packageFlow);

			DappAKlineEntity dappAKlineEntity = new DappAKlineEntity();
			dappAKlineEntity.setOpenPrice(divide);
			dappAKlineEntity.setType(1);
			dappAKlineMapper.insert(dappAKlineEntity);
			}

			}


			private final IMatrixTreeNodeService matrixTreeNodeService;

			@Override
			public void speedAutoLevelUpMsg(Long memberId) {log.info("###代理自动升级###");
			DappMemberEntity member = dappMemberDao.selectById(memberId);
			if (MemberLevelEnum.V7.getType().equals(member.getAccountType())) {
			return;
			}

			MemberNode parentNode = matrixTreeNodeService.addTreeNode(memberId);
			if (parentNode == null) {
			log.info("父级节点未找到:{}", memberId);
			return;
			}

			MatrixTree matrixTree = MatrixTree.getInstance();
			List<MemberNode> allNodes = matrixTree.getAllAncestors(parentNode); // 获取某一个MemberNode的所有上级节点
			allNodes.add(parentNode);
			if(CollUtil.isEmpty(allNodes)){
			return;
			}
			/**
			* 更新所有上级的小区业绩
			*/
			for(MemberNode memberNode : allNodes){
			BigDecimal smallAchieve = BigDecimal.ZERO;
			List<MemberNode> allNodesChildList = memberNode.getCHILD();
			if(CollUtil.isNotEmpty(allNodesChildList)){
			List<Long> left = allNodesChildList.stream().filter(allNodesChild -> allNodesChild.getType() == 1).map(MemberNode::getMemberId).collect(Collectors.toList());
			List<Long> right = allNodesChildList.stream().filter(allNodesChild -> allNodesChild.getType() == 2).map(MemberNode::getMemberId).collect(Collectors.toList());

			BigDecimal leftAmount = mallAchieveRecordMapper.selectSumAchieveByMemberIdList(left);

			BigDecimal rightAmount = mallAchieveRecordMapper.selectSumAchieveByMemberIdList(right);
			if(leftAmount.compareTo(rightAmount) > 0){
			smallAchieve = rightAmount;
			}else{
			smallAchieve = leftAmount;
			}
			//更新用户的区域业绩
			DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberNode.getMemberId());
			dappMemberEntity.setUsdtBalance(smallAchieve);
			dappMemberEntity.setLeftAchieve(leftAmount);
			dappMemberEntity.setRightAchieve(rightAmount);
			dappMemberDao.updateById(dappMemberEntity);
			log.info("用户:{},leftAchieve :{}, rightAchieve:{}, smallAchieve:{}",
			dappMemberEntity.getAddress(), leftAmount, rightAmount, smallAchieve);

			/**
			* 判断是否符合升级条件
			*/
			String nextLevel = MemberLevelEnum.MEMBER.getNextLevel(dappMemberEntity.getAccountType());
			DataDictionaryCustom memberLevelDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.V1.getType()
			, nextLevel);
			if(ObjectUtil.isNotEmpty(memberLevelDic)){
			String value = memberLevelDic.getValue();
			cn.hutool.json.JSONObject parseObj = JSONUtil.parseObj(value);
			BigDecimal smallAchieveDic = new BigDecimal(parseObj.get("smallAchieve").toString());
			if(smallAchieve.compareTo(smallAchieveDic) >= 0){
			//升级
			dappMemberEntity.setAccountType(nextLevel);
			dappMemberDao.updateById(dappMemberEntity);
			}
			}
			}
			}
			}

			@Override
			public void memberPerk() {
			List<DappMemberEntity> dappMemberEntityList = dappMemberDao.selectMemberByActiveStatus();
			if(CollUtil.isEmpty(dappMemberEntityList)){
			return;
			}
			DataDictionaryCustom staticReleaseDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.STATIC_RELEASE.getType(),
			DataDictionaryEnum.STATIC_RELEASE.getCode()
			);
			if(ObjectUtil.isEmpty(staticReleaseDic)){
			return;
			}
			BigDecimal staticRelease = new BigDecimal(staticReleaseDic.getValue() == null ? "0" : staticReleaseDic.getValue());
			if(BigDecimal.ZERO.compareTo(staticRelease) >= 0){
			return;
			}
			for(DappMemberEntity dappMemberEntity : dappMemberEntityList){
			if(1 != dappMemberEntity.getActiveStatus()){
			continue;
			}
			Long perkMemberId = dappMemberEntity.getId();
			//获取当前用户所有进行中的业绩释放
			List<MallAchieveRecord> mallAchieveRecords = mallAchieveRecordMapper.selectListByMemberId(perkMemberId);

			if(CollUtil.isEmpty(mallAchieveRecords)){
			continue;
			}
			/**
			* 按照订单、比例生成对应的静态释放
			*/
			for(MallAchieveRecord mallAchieveRecord : mallAchieveRecords){
			//释放总额
			BigDecimal costAmount = mallAchieveRecord.getCostAmount();
			//每日释放金额
			BigDecimal eachDayPerk = costAmount.multiply(staticRelease).setScale(2,BigDecimal.ROUND_DOWN);
			DappMemberEntity mallAchieveMemberEntity = dappMemberDao.selectById(mallAchieveRecord.getMemberId());
			sendPerk(mallAchieveMemberEntity,eachDayPerk,mallAchieveRecord.getOrderId(),FundFlowEnum.STATIC_RELEASE.getCode());
			}

			}
			}



			@Override
			public void speedAutoLevelUpTeamMsg(Long memberId) {
			DappMemberEntity member = dappMemberDao.selectById(memberId);
			if(StrUtil.isBlank(member.getRefererIds())) {
			return;
			}

			List<String> ids = StrUtil.split(member.getRefererIds(), ',');
			List<DappMemberEntity> parentMembers = dappMemberDao.selectByInviteIds(ids);
			for (DappMemberEntity parent : parentMembers) {
			//V7不能再升级了
			if (MemberLevelEnum.V7.getType().equals(member.getAccountType())) {
			continue;
			}

			String nextLevelName = MemberLevelEnum.MEMBER.getNextLevel(parent.getAccountType());

			DataDictionaryCustom newLevelDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode("TEAM_LEVEL", nextLevelName);
			if(ObjectUtil.isEmpty(newLevelDic)){
			continue;
			}
			TeamLevelPerk teamLevelPerk = JSONObject.parseObject(newLevelDic.getValue(), TeamLevelPerk.class);

			//需要判断小区业绩
			if( MemberLevelEnum.V1.getType().equals(nextLevelName)){
			if (!teamAchieveOther(parent, teamLevelPerk)) {
			continue;
			}

			DataDictionaryCustom distribDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(AppContants.DIC_TYPE_DISTRIBUTE_PROP, String.valueOf(i));
			if (distribDic == null) {
			break;
			}else{
			if (!agentCntFinish(parent, teamLevelPerk)) {
			continue;
			}
			if (!teamAchieveOther(parent, teamLevelPerk)) {
			continue;
			}
			}

			BigDecimal total = distrbAmount.multiply(new BigDecimal(distribDic.getValue()).divide(BigDecimal.valueOf(100), 2, RoundingMode.HALF_UP));
			OnlineTransferUtil.addTransfer(parent.getAddress(), total, fundflow.getType(), 1, ChainEnum.BSC_TFC_SOURCE.name(), AppContants.SYMBOL_COIN, batchNo);
			parent.setAccountType(nextLevelName);
			dappMemberDao.updateById(parent);
			}
			}
			/**
			* 判断下级代理数量是否达标
			*
			* @return
			*/
			private boolean agentCntFinish(DappMemberEntity member,TeamLevelPerk teamLevelPerk) {
			if (teamLevelPerk.getLastAgentCnt() == null \|\| teamLevelPerk.getLastAgentCnt() == 0) {
			return true;
			}

			DappFundFlowEntity distribFlow = new DappFundFlowEntity(parent.getId(), total, 4, 2, BigDecimal.ZERO);
			dappFundFlowDao.insert(distribFlow);
			// 直推用户
			List<DappMemberEntity> directMember = dappMemberDao.selectMemberInfoByRefererId(member.getInviteId());
			if (CollUtil.isEmpty(directMember)) {
			return false;
			}

			nodeAmount = nodeAmount.subtract(total);
			// 用户团队达到指定代理数量，且都不在同一条线
			int i = 0;
			for (DappMemberEntity child : directMember) {
			List<DappMemberEntity> mallMembers = dappMemberDao.selectChildAgentList(child.getInviteId(), member.getAccountType());
			if (CollUtil.isNotEmpty(mallMembers)) {
			i++;
			}
			}

			// 铸池滑点金额
			BigDecimal makerAmount = distrbAmount.multiply(slipSetting.getMakeProp().divide(BigDecimal.valueOf(100), 2, RoundingMode.HALF_UP));
			log.info("铸池滑点金额:{}", makerAmount);
			if (makerAmount.compareTo(BigDecimal.ZERO) > 0) {
			List<DappMemberEntity> makerAddress = dappMemberDao.selectMakerAddress();
			if (CollUtil.isNotEmpty(makerAddress)) {
			BigDecimal totalMaker = BigDecimal.ZERO;
			Map<String, BigDecimal> map = new HashMap<>();
			Map<String, Long> addressAndId = new HashMap<>();
			for (DappMemberEntity maker : makerAddress) {
			BigDecimal balance = instance.balanceOf(maker.getAddress());
			map.put(maker.getAddress(), balance);
			addressAndId.put(maker.getAddress(), maker.getId());
			if (i >= teamLevelPerk.getLastAgentCnt()) {
			return true;
			}

			totalMaker = totalMaker.add(balance);
			log.info("用户:{}代理数量未达标, 当前等级:{}, 当前数量:{}, 目标数量:{}", member.getAddress(), member.getAccountType(), i, teamLevelPerk.getLastAgentCnt());
			return false;
			}
			/**
			* 团队业绩是否达标
			*/
			private boolean teamAchieveOther(DappMemberEntity member, TeamLevelPerk teamLevelPerk ) {
			BigDecimal teamIncome = teamLevelPerk.getSmallAchieve();
			//总业绩
			BigDecimal teamIncomeMax = BigDecimal.ZERO;
			//所有直推团队，就是这个会员的所有区域的业绩。

			// 直推用户
			List<DappMemberEntity> childs = dappMemberDao.selectMemberInfoByRefererId(member.getInviteId());
			List<String> childsInviteIds = childs.stream().map(DappMemberEntity::getInviteId).collect(Collectors.toList());
			for(String inviteId : childsInviteIds){
			BigDecimal totalIncomeMember = dappMemberDao.selectAchieveRecordByInviteId(inviteId);
			teamIncomeMax = teamIncomeMax.add(totalIncomeMember);
			}

			if (teamIncomeMax.compareTo(teamIncome) >= 0) {
			return true;
			}
			log.info("用户:{}团队业绩未达标, 当前等级:{}, 当前业绩:{}, 目标业绩:{}", member.getAddress(), member.getAccountType(), teamIncomeMax, teamIncome);
			return false;
			}

			/**
			* 团队业绩是否达标
			* 除去直属的最大的一个业绩团队，剩余的所有业绩之和
			*/
			private boolean teamAchieve(DappMemberEntity member, TeamLevelPerk teamLevelPerk ) {
			BigDecimal teamIncome = teamLevelPerk.getSmallAchieve();
			//业绩集合
			List<BigDecimal> list = new ArrayList<>();
			//总业绩
			BigDecimal teamIncomeMax = BigDecimal.ZERO;
			//所有直推团队，就是这个会员的所有区域的业绩。

			// 直推用户
			List<DappMemberEntity> childs = dappMemberDao.selectMemberInfoByRefererId(member.getInviteId());
			List<String> childsInviteIds = childs.stream().map(DappMemberEntity::getInviteId).collect(Collectors.toList());
			for(String inviteId : childsInviteIds){
			BigDecimal totalIncomeMember = dappMemberDao.selectAchieveRecordByInviteId(inviteId);
			teamIncomeMax = teamIncomeMax.add(totalIncomeMember);
			list.add(totalIncomeMember);
			}
			//去掉一个最大区的业绩
			BigDecimal bigMax = list.stream().max(BigDecimal::compareTo).get();
			teamIncomeMax = teamIncomeMax.subtract(bigMax);

			if (teamIncomeMax.compareTo(teamIncome) >= 0) {
			return true;
			}
			log.info("用户:{}团队业绩未达标, 当前等级:{}, 当前业绩:{}, 目标业绩:{}", member.getAddress(), member.getAccountType(), teamIncomeMax, teamIncome);
			return false;
			}



			@Override
			public BigDecimal getRealNum(Long memberId, BigDecimal amount) {
			BigDecimal returnAmount = BigDecimal.ZERO;
			DappWalletMineEntity dappWalletMineEntity = dappWalletMineDao.selectByMemberId(memberId);
			BigDecimal totalScore = dappWalletMineEntity.getTotalAmount();
			if(totalScore.compareTo(amount) >= 0){
			returnAmount = amount;
			}else{
			returnAmount = totalScore;
			}
			return returnAmount;
			}

			@Override
			public void directMemberPerk() {
			List<DappMemberEntity> dappMemberEntityList = dappMemberDao.selectMemberByActiveStatus();
			if(CollUtil.isEmpty(dappMemberEntityList)){
			return;
			}
			/**
			* 直推消费分享:享受直接分享人每日消费金额释放的100%加速；
			*/
			for(DappMemberEntity dappMemberEntity : dappMemberEntityList){
			String inviteId = dappMemberEntity.getInviteId();
			//该用户全部的直推用户
			List<DappMemberEntity> dappMemberEntities = dappMemberDao.selectChildMemberDirectOrNot(inviteId, 1, 1);
			if(CollUtil.isEmpty(dappMemberEntities)){
			continue;
			}
			for(DappMemberEntity directMember : dappMemberEntities){
			if(1 != directMember.getActiveStatus()){
			continue;
			}
			DappMemberEntity parentMember = dappMemberDao.selectMemberInfoByInviteId(directMember.getRefererId());
			if(ObjectUtil.isEmpty(parentMember)){
			continue;
			}
			Long directMemberId = directMember.getId();

			for (Map.Entry<String, BigDecimal> entry : map.entrySet()) {
			BigDecimal target = makerAmount.multiply(entry.getValue().divide(totalMaker, 2, RoundingMode.HALF_UP));

			OnlineTransferUtil.addTransfer(entry.getKey(), target, fundflow.getType(), 1, ChainEnum.BSC_TFC_SOURCE.name(), AppContants.SYMBOL_COIN, batchNo);

			DappFundFlowEntity distribFlow = new DappFundFlowEntity(addressAndId.get(entry.getKey()), target, 4, 2, BigDecimal.ZERO);
			dappFundFlowDao.insert(distribFlow);
			DataDictionaryCustom directReleaseDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.DIRECT_RELEASE.getType(),
			DataDictionaryEnum.DIRECT_RELEASE.getCode()
			);
			if(ObjectUtil.isEmpty(directReleaseDic)){
			continue;
			}
			BigDecimal directRelease = new BigDecimal(directReleaseDic.getValue() == null ? "0" : directReleaseDic.getValue());
			if(BigDecimal.ZERO.compareTo(directRelease) >= 0){
			continue;
			}
			/**
			* 获取用户前一天的所有返利记录
			*/
			List<DappFundFlowEntity> dappFundFlowEntities = dappFundFlowDao.selectListByMemberIdAndTypeAndDate(directMemberId,
			FundFlowEnum.STATIC_RELEASE.getCode(),DateUtil.date());
			// List<DappFundFlowEntity> dappFundFlowEntities = dappFundFlowDao.selectListByMemberIdAndTypeAndDate(directMemberId,
			// FundFlowEnum.STATIC_RELEASE.getCode(),DateUtil.offsetHour(DateUtil.date(),-12));
			if(CollUtil.isEmpty(dappFundFlowEntities)){
			continue;
			}
			for(DappFundFlowEntity dappFundFlowEntity : dappFundFlowEntities){
			BigDecimal staticReleaseAmount = dappFundFlowEntity.getAmount();
			BigDecimal directReleaseAmount = staticReleaseAmount.multiply(directRelease).setScale(2, BigDecimal.ROUND_DOWN);
			sendPerk(parentMember,directReleaseAmount,dappFundFlowEntity.getSystemProfitId(),FundFlowEnum.DIRECT_AMOUNT.getCode());
			}
			}
			}


			// 若节点金额还有剩余，则进入技术金额
			techAmount = techAmount.add(nodeAmount);
			OnlineTransferUtil.addTransfer(ChainEnum.BSC_TFC_TECH.getAddress(), techAmount, fundflow.getType(), 3, ChainEnum.BSC_TFC_SOURCE.name(), AppContants.SYMBOL_COIN, batchNo);

			Map<String, String> map = new HashMap<>();
			map.put("batchNo", batchNo);
			map.put("type", "batch");

			// 发送转账消息
			chainProducer.sendOnlineTransfer(JSONObject.toJSONString(map));
			}

			@Override
			public void mining() {
			ContractChainService contract = ChainService.getInstance(ChainEnum.BSC_TFC.name());
			// 发行量
			BigInteger totalSupply = contract.totalSupply();

			BigDecimal totalUnHold = contract.balanceOf(AppContants.DESTROY_ADDRESS);
			List<DappMemberEntity> admin = dappMemberDao.selectMemberByAccountType("admin");
			for (DappMemberEntity member : admin) {
			totalUnHold = totalUnHold.add(contract.balanceOf(member.getAddress()));
			}

			Object transferPoolObj = redisUtils.get(AppContants.REDIS_KEY_MINE_TRANSFER_POOL_TRADE_CNT);

			// 全网持币量
			BigDecimal allInternet = new BigDecimal(totalSupply).subtract(totalUnHold);
			// 中转池交易量
			BigDecimal transferPoll = (BigDecimal) transferPoolObj;

			List<DappMemberEntity> allMembers = dappMemberDao.selectList(null);
			if (CollUtil.isEmpty(allMembers)) {
			public void speedDirectPerkMsg(Long memberId) {
			DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
			if(1 != dappMemberEntity.getActiveStatus()){
			return;
			}
			DataDictionaryCustom miniHoldCoin = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(AppContants.DIC_TYPE_SYSTEM_SETTING, AppContants.DIC_VALUE_MINI_HOLD_COIN_LIMIT);

			String batchNo = RandomUtil.randomString(32);
			ContractChainService instance = ChainService.getInstance(ChainEnum.BSC_TFC.name());
			for (DappMemberEntity member : allMembers) {
			if ("admin".equals(member.getAccountType())) {
			continue;
			}

			BigDecimal balance = instance.balanceOf(member.getAddress());
			if (balance.compareTo(new BigDecimal(miniHoldCoin.getValue())) < 1) {
			continue;
			}

			// 挖矿数量
			BigDecimal mine = transferPoll.multiply(new BigDecimal("0.2")).multiply(balance.divide(allInternet, instance.decimals(), RoundingMode.HALF_UP));
			if (mine.compareTo(BigDecimal.ZERO) < 1) {
			continue;
			}

			DappFundFlowEntity fundFlow = new DappFundFlowEntity(member.getId(), mine, 3, 2, BigDecimal.ZERO);
			dappFundFlowDao.insert(fundFlow);
			OnlineTransferUtil.addTransfer(member.getAddress(), mine, 3, 1, ChainEnum.BSC_TFC.name(), AppContants.SYMBOL_COIN, batchNo);

			member.setBalance(balance);
			dappMemberDao.updateById(member);
			DataDictionaryCustom directReleaseDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.DIRECT_RELEASE.getType(),
			DataDictionaryEnum.DIRECT_RELEASE.getCode()
			);
			if(ObjectUtil.isEmpty(directReleaseDic)){
			return;
			}

			Map<String, String> map = new HashMap<>();
			map.put("batchNo", batchNo);
			map.put("type", "batch");

			// 发送转账消息
			chainProducer.sendOnlineTransfer(JSONObject.toJSONString(map));
			BigDecimal directRelease = new BigDecimal(directReleaseDic.getValue() == null ? "0" : directReleaseDic.getValue());
			if(BigDecimal.ZERO.compareTo(directRelease) >= 0){
			return;
			}
			DappMemberEntity parentMember = dappMemberDao.selectMemberInfoByInviteId(dappMemberEntity.getRefererId());
			/**
			* 获取用户前一天的所有返利记录
			*/
			List<DappFundFlowEntity> dappFundFlowEntities = dappFundFlowDao.selectListByMemberIdAndTypeAndDate(memberId,
			FundFlowEnum.STATIC_RELEASE.getCode(),DateUtil.offsetHour(DateUtil.date(),-12));
			for(DappFundFlowEntity dappFundFlowEntity : dappFundFlowEntities){
			BigDecimal staticReleaseAmount = dappFundFlowEntity.getAmount();
			BigDecimal directReleaseAmount = staticReleaseAmount.multiply(directRelease).setScale(2, BigDecimal.ROUND_DOWN);
			sendPerk(parentMember,directReleaseAmount,dappFundFlowEntity.getSystemProfitId(),FundFlowEnum.DIRECT_AMOUNT.getCode());
			}
			}

			@Override
			public void onlineTransfer(String str) {
			JSONObject jsonObject = JSONObject.parseObject(str);
			String batchNo = jsonObject.getString("batchNo");
			List<DappOnlineTransferEntity> transferList = dappOnlineTransferDao.selectByBatchNo(batchNo);
			public void teamStaticPerk() {
			//平级
			DataDictionaryCustom teamPerkEqualsDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.TEAM_PERK_LEVEL_EQUALS.getType(),
			DataDictionaryEnum.TEAM_PERK_LEVEL_EQUALS.getCode());
			BigDecimal teamPerkEquals = new BigDecimal(ObjectUtil.isEmpty(teamPerkEqualsDic) ? "0.1" : teamPerkEqualsDic.getValue());
			DataDictionaryCustom staticReleaseDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.STATIC_RELEASE.getType(),
			DataDictionaryEnum.STATIC_RELEASE.getCode());
			BigDecimal staticRelease = new BigDecimal(ObjectUtil.isEmpty(staticReleaseDic) ? "0.006" : staticReleaseDic.getValue());

			if (CollUtil.isEmpty(transferList)) {
			return;
			List<DappMemberEntity> dappMemberEntities = dappMemberDao.selectMemberByAccountType(MemberLevelEnum.V1.getType());
			shareStaticPerk(dappMemberEntities,FundFlowEnum.SHARE_PERK_V1.getCode());
			teamStaticPerkMemberLevel(dappMemberEntities,teamPerkEquals,staticRelease,FundFlowEnum.TEAM_PERK_V1.getCode(),MemberLevelEnum.V1.getType());
			isAllPerkMemberLevel(dappMemberEntities,MemberLevelEnum.V1.getType(),FundFlowEnum.ALL_PERK_V1.getCode());

			List<DappMemberEntity> v2DappMemberEntities = dappMemberDao.selectMemberByAccountType(MemberLevelEnum.V2.getType());
			shareStaticPerk(v2DappMemberEntities,FundFlowEnum.SHARE_PERK_V2.getCode());
			teamStaticPerkMemberLevel(v2DappMemberEntities,teamPerkEquals,staticRelease,FundFlowEnum.TEAM_PERK_V2.getCode(),MemberLevelEnum.V2.getType());
			isAllPerkMemberLevel(v2DappMemberEntities,MemberLevelEnum.V2.getType(),FundFlowEnum.ALL_PERK_V2.getCode());

			List<DappMemberEntity> v3DappMemberEntities = dappMemberDao.selectMemberByAccountType(MemberLevelEnum.V3.getType());
			shareStaticPerk(v3DappMemberEntities,FundFlowEnum.SHARE_PERK_V3.getCode());
			teamStaticPerkMemberLevel(v3DappMemberEntities,teamPerkEquals,staticRelease,FundFlowEnum.TEAM_PERK_V3.getCode(),MemberLevelEnum.V3.getType());
			isAllPerkMemberLevel(v3DappMemberEntities,MemberLevelEnum.V3.getType(),FundFlowEnum.ALL_PERK_V3.getCode());

			List<DappMemberEntity> v4DappMemberEntities = dappMemberDao.selectMemberByAccountType(MemberLevelEnum.V4.getType());
			shareStaticPerk(v4DappMemberEntities,FundFlowEnum.SHARE_PERK_V4.getCode());
			teamStaticPerkMemberLevel(v4DappMemberEntities,teamPerkEquals,staticRelease,FundFlowEnum.TEAM_PERK_V4.getCode(),MemberLevelEnum.V4.getType());
			isAllPerkMemberLevel(v4DappMemberEntities,MemberLevelEnum.V4.getType(),FundFlowEnum.ALL_PERK_V4.getCode());

			List<DappMemberEntity> v5DappMemberEntities = dappMemberDao.selectMemberByAccountType(MemberLevelEnum.V5.getType());
			shareStaticPerk(v5DappMemberEntities,FundFlowEnum.SHARE_PERK_V5.getCode());
			teamStaticPerkMemberLevel(v5DappMemberEntities,teamPerkEquals,staticRelease,FundFlowEnum.TEAM_PERK_V5.getCode(),MemberLevelEnum.V5.getType());
			isAllPerkMemberLevel(v5DappMemberEntities,MemberLevelEnum.V5.getType(),FundFlowEnum.ALL_PERK_V5.getCode());

			List<DappMemberEntity> v6DappMemberEntities = dappMemberDao.selectMemberByAccountType(MemberLevelEnum.V6.getType());
			shareStaticPerk(v6DappMemberEntities,FundFlowEnum.SHARE_PERK_V6.getCode());
			teamStaticPerkMemberLevel(v6DappMemberEntities,teamPerkEquals,staticRelease,FundFlowEnum.TEAM_PERK_V6.getCode(),MemberLevelEnum.V6.getType());
			isAllPerkMemberLevel(v6DappMemberEntities,MemberLevelEnum.V6.getType(),FundFlowEnum.ALL_PERK_V6.getCode());

			List<DappMemberEntity> v7DappMemberEntities = dappMemberDao.selectMemberByAccountType(MemberLevelEnum.V7.getType());
			shareStaticPerk(v7DappMemberEntities,FundFlowEnum.SHARE_PERK_V7.getCode());
			teamStaticPerkMemberLevel(v7DappMemberEntities,teamPerkEquals,staticRelease,FundFlowEnum.TEAM_PERK_V7.getCode(),MemberLevelEnum.V7.getType());
			isAllPerkMemberLevel(v7DappMemberEntities,MemberLevelEnum.V7.getType(),FundFlowEnum.ALL_PERK_V7.getCode());

			}

			@Override
			public Set<DappMemberEntity> updateAchieve() {
			/**
			* 每个人预期获得的总流水
			*/

			Set<DappMemberEntity> set = new HashSet<>();
			List<DappFundFlowEntity> dappFundFlowEntities = dappFundFlowDao.selectListByTypeAndDate(FundFlowEnum.ADD_AMOUNT.getCode(), DateUtil.date());
			if(CollUtil.isEmpty(dappFundFlowEntities)){
			return set;
			}

			for (DappOnlineTransferEntity transfer : transferList) {
			if (transfer.getHasFinish() == 1) {
			for(DappFundFlowEntity dappFundFlowEntity : dappFundFlowEntities){
			Long memberId = dappFundFlowEntity.getMemberId();
			//当日预期总收益
			BigDecimal amount = dappFundFlowEntity.getAmount();
			if(BigDecimal.ZERO.compareTo(amount) >= 0){
			continue;
			}
			//当日预期总收益
			BigDecimal amountMagic = amount;
			List<MallAchieveRecord> mallAchieveRecords = mallAchieveRecordMapper.selectListByMemberId(memberId);
			if(CollUtil.isEmpty(mallAchieveRecords)){

			String txHash = ChainService.getInstance(transfer.getFromType()).transfer(transfer.getAddress(), transfer.getAmount());
			while (StrUtil.isEmpty(txHash)) {
			// 休眠2s
			try {
			Thread.sleep(2000);
			} catch (InterruptedException e) {
			e.printStackTrace();
			BigDecimal localTotalAchieve = amount;
			/**
			* 用户减少赠送积分
			*/
			DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
			DappWalletMineEntity dappWalletMineEntity = dappWalletMineDao.selectByMemberId(memberId);
			BigDecimal totalScore = dappWalletMineEntity.getTotalAmount();
			BigDecimal availableScore = dappWalletMineEntity.getAvailableAmount();

			if(localTotalAchieve.compareTo(totalScore) >= 0){
			localTotalAchieve = totalScore;
			//当实际获取大于用户的赠送积分，将用户更新为未激活
			dappMemberEntity.setActiveStatus(2);
			dappMemberDao.updateById(dappMemberEntity);
			}
			txHash = ChainService.getInstance(transfer.getFromType()).transfer(transfer.getAddress(), transfer.getAmount());

			DappAccountMoneyChangeEntity reduceScoreAMC = new DappAccountMoneyChangeEntity(
			memberId,
			totalScore,
			amountMagic.negate(),
			localTotalAchieve.negate(),
			AccountFlowEnum.SCORE.getCode(),
			null);
			dappAccountMoneyChangeDao.insert(reduceScoreAMC);

			//插入积分流水
			DappFundFlowEntity scoreFlow = new DappFundFlowEntity(
			AccountFlowEnum.SCORE.getCode(),
			memberId,
			localTotalAchieve.negate(),
			FundFlowEnum.REDUCE_SCORE_REAL.getCode(),
			DappFundFlowEntity.WITHDRAW_STATUS_AGREE,
			BigDecimal.ZERO);
			dappFundFlowDao.insert(scoreFlow);

			BigDecimal totalScoreRelease = totalScore.subtract(localTotalAchieve);
			BigDecimal availableScoreRelease = availableScore.subtract(localTotalAchieve);
			//更新积分账户
			dappWalletMineEntity.setTotalAmount(totalScoreRelease);
			dappWalletMineEntity.setAvailableAmount(availableScoreRelease);
			dappWalletMineDao.updateById(dappWalletMineEntity);


			//用户增加余额
			DappWalletCoinEntity dappWalletCoinEntity = dappWalletCoinDao.selectByMemberId(memberId);
			BigDecimal totalAmount = dappWalletCoinEntity.getTotalAmount();
			BigDecimal availableAmount = dappWalletCoinEntity.getAvailableAmount();

			DappAccountMoneyChangeEntity addAmountAMC = new DappAccountMoneyChangeEntity(
			memberId,
			totalAmount,
			amountMagic,
			localTotalAchieve,
			AccountFlowEnum.AMOUNT.getCode(),
			null);
			dappAccountMoneyChangeDao.insert(addAmountAMC);
			//插入余额流水
			DappFundFlowEntity amountFlow = new DappFundFlowEntity(
			AccountFlowEnum.AMOUNT.getCode(),
			memberId,
			localTotalAchieve,
			FundFlowEnum.ADD_AMOUNT_REAL.getCode(),
			DappFundFlowEntity.WITHDRAW_STATUS_AGREE,
			BigDecimal.ZERO);
			dappFundFlowDao.insert(amountFlow);

			BigDecimal totalAmountRelease = totalAmount.add(localTotalAchieve);
			BigDecimal availableAmountRelease = availableAmount.add(localTotalAchieve);
			//更新余额账户
			dappWalletCoinEntity.setTotalAmount(totalAmountRelease);
			dappWalletCoinEntity.setAvailableAmount(availableAmountRelease);
			dappWalletCoinDao.updateById(dappWalletCoinEntity);

			StringBuffer content = new StringBuffer();
			if(amountMagic.compareTo(localTotalAchieve) > 0){
			content.append("今日可加速"+amountMagic.setScale(2,BigDecimal.ROUND_DOWN)+"，实际加速"+localTotalAchieve.setScale(2,BigDecimal.ROUND_DOWN)+"" +
			"烧伤"+amountMagic.subtract(localTotalAchieve).setScale(2,BigDecimal.ROUND_DOWN)+"，原因消费金额1%加速上" +
			"限，增加消费金额可获得更多收益");
			}else{
			content.append("今日可加速"+amountMagic.setScale(2,BigDecimal.ROUND_DOWN)+"，实际加速"+localTotalAchieve.setScale(2,BigDecimal.ROUND_DOWN)+"" +
			"烧伤"+amountMagic.subtract(localTotalAchieve).setScale(2,BigDecimal.ROUND_DOWN));
			}
			DappAccountMoneyChangeEntity record = new DappAccountMoneyChangeEntity(
			memberId,
			totalAmount,
			amountMagic,
			localTotalAchieve,
			AccountFlowEnum.AMOUNT_RECORD.getCode(),
			content.toString());
			dappAccountMoneyChangeDao.insert(record);

			//实时更新用户等级
			chainProducer.sendAutoLevelUpTeamMsg(memberId);

			set.add(dappMemberEntity);
			continue;
			}
			//实际获取总收益
			BigDecimal localTotalAchieve = BigDecimal.ZERO;
			BigDecimal totalAchieve = mallAchieveRecords.stream().map(MallAchieveRecord::getAmount).reduce(BigDecimal.ZERO, BigDecimal::add);

			//用户每日获取的最大值
			DataDictionaryCustom maxReleaseDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.MAX_RELEASE.getType(),
			DataDictionaryEnum.MAX_RELEASE.getCode()
			);
			BigDecimal maxRelease = new BigDecimal(ObjectUtil.isEmpty(maxReleaseDic) ? "1" : maxReleaseDic.getValue());
			//用户每日获取的最大值
			BigDecimal maxReleaseMember = totalAchieve.multiply(maxRelease).setScale(2, BigDecimal.ROUND_DOWN);
			if(amount.compareTo(maxReleaseMember) > 0){
			amount = maxReleaseMember;
			}
			//当日获取总收益大于总业绩
			if(amount.compareTo(totalAchieve) >= 0){
			for(MallAchieveRecord memberAchieve : mallAchieveRecords){
			memberAchieve.setIsNormal(2);
			memberAchieve.setAmount(BigDecimal.ZERO);
			mallAchieveRecordMapper.updateById(memberAchieve);
			}
			localTotalAchieve = totalAchieve;
			amount = amount.subtract(totalAchieve);
			}else{
			/**
			*
			* amount 100 a1 100 a2 30 a3 10
			* localTotalAchieve 100 100
			* amount 0 0
			*
			*/
			for(MallAchieveRecord memberAchieve : mallAchieveRecords){
			BigDecimal achieveAmount = memberAchieve.getAmount();
			if(BigDecimal.ZERO.compareTo(amount) >= 0){
			break;
			}else if(amount.compareTo(achieveAmount) < 0){
			memberAchieve.setAmount(achieveAmount.subtract(amount).setScale(2,BigDecimal.ROUND_DOWN));
			mallAchieveRecordMapper.updateById(memberAchieve);
			localTotalAchieve = localTotalAchieve.add(amount);
			amount = BigDecimal.ZERO;
			continue;
			}else{
			memberAchieve.setIsNormal(2);
			memberAchieve.setAmount(BigDecimal.ZERO);
			mallAchieveRecordMapper.updateById(memberAchieve);
			localTotalAchieve = localTotalAchieve.add(achieveAmount);
			amount = amount.subtract(achieveAmount);
			}
			}
			}

			transfer.setTxHash(txHash);
			transfer.setHasFinish(1);
			transfer.setUpdateTime(new Date());
			dappOnlineTransferDao.updateById(transfer);
			/**
			* 用户减少赠送积分
			*/
			DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
			DappWalletMineEntity dappWalletMineEntity = dappWalletMineDao.selectByMemberId(memberId);
			BigDecimal totalScore = dappWalletMineEntity.getTotalAmount();
			BigDecimal availableScore = dappWalletMineEntity.getAvailableAmount();

			if ("flow".equals(jsonObject.getString("type"))) {
			DappFundFlowEntity fundFlow = dappFundFlowDao.selectById(Long.parseLong(batchNo));
			fundFlow.setToHash(txHash);
			dappFundFlowDao.updateById(fundFlow);
			if(localTotalAchieve.compareTo(totalScore) >= 0){
			localTotalAchieve = totalScore;
			//当实际获取大于用户的赠送积分，将用户更新为未激活
			dappMemberEntity.setActiveStatus(2);
			dappMemberDao.updateById(dappMemberEntity);
			}

			DappAccountMoneyChangeEntity reduceScoreAMC = new DappAccountMoneyChangeEntity(
			memberId,
			totalScore,
			amountMagic.negate(),
			localTotalAchieve.negate(),
			AccountFlowEnum.SCORE.getCode(),
			null);
			dappAccountMoneyChangeDao.insert(reduceScoreAMC);

			//插入积分流水
			DappFundFlowEntity scoreFlow = new DappFundFlowEntity(
			AccountFlowEnum.SCORE.getCode(),
			memberId,
			localTotalAchieve.negate(),
			FundFlowEnum.REDUCE_SCORE_REAL.getCode(),
			DappFundFlowEntity.WITHDRAW_STATUS_AGREE,
			BigDecimal.ZERO);
			dappFundFlowDao.insert(scoreFlow);

			BigDecimal totalScoreRelease = totalScore.subtract(localTotalAchieve);
			BigDecimal availableScoreRelease = availableScore.subtract(localTotalAchieve);
			//更新积分账户
			dappWalletMineEntity.setTotalAmount(totalScoreRelease);
			dappWalletMineEntity.setAvailableAmount(availableScoreRelease);
			dappWalletMineDao.updateById(dappWalletMineEntity);


			//用户增加余额
			DappWalletCoinEntity dappWalletCoinEntity = dappWalletCoinDao.selectByMemberId(memberId);
			BigDecimal totalAmount = dappWalletCoinEntity.getTotalAmount();
			BigDecimal availableAmount = dappWalletCoinEntity.getAvailableAmount();

			DappAccountMoneyChangeEntity addAmountAMC = new DappAccountMoneyChangeEntity(
			memberId,
			totalAmount,
			amountMagic,
			localTotalAchieve,
			AccountFlowEnum.AMOUNT.getCode(),
			null);
			dappAccountMoneyChangeDao.insert(addAmountAMC);
			//插入余额流水
			DappFundFlowEntity amountFlow = new DappFundFlowEntity(
			AccountFlowEnum.AMOUNT.getCode(),
			memberId,
			localTotalAchieve,
			FundFlowEnum.ADD_AMOUNT_REAL.getCode(),
			DappFundFlowEntity.WITHDRAW_STATUS_AGREE,
			BigDecimal.ZERO);
			dappFundFlowDao.insert(amountFlow);

			BigDecimal totalAmountRelease = totalAmount.add(localTotalAchieve);
			BigDecimal availableAmountRelease = availableAmount.add(localTotalAchieve);
			//更新余额账户
			dappWalletCoinEntity.setTotalAmount(totalAmountRelease);
			dappWalletCoinEntity.setAvailableAmount(availableAmountRelease);
			dappWalletCoinDao.updateById(dappWalletCoinEntity);

			StringBuffer content = new StringBuffer();
			if(amountMagic.compareTo(localTotalAchieve) > 0){
			content.append("今日可加速"+amountMagic.setScale(2,BigDecimal.ROUND_DOWN)+"，实际加速"+localTotalAchieve.setScale(2,BigDecimal.ROUND_DOWN)+"" +
			"烧伤"+amountMagic.subtract(localTotalAchieve).setScale(2,BigDecimal.ROUND_DOWN)+"，原因消费金额1%加速上" +
			"限，增加消费金额可获得更多收益");
			}else{
			content.append("今日可加速"+amountMagic.setScale(2,BigDecimal.ROUND_DOWN)+"，实际加速"+localTotalAchieve.setScale(2,BigDecimal.ROUND_DOWN)+"" +
			"烧伤"+amountMagic.subtract(localTotalAchieve).setScale(2,BigDecimal.ROUND_DOWN));
			}
			DappAccountMoneyChangeEntity record = new DappAccountMoneyChangeEntity(
			memberId,
			totalAmount,
			amountMagic,
			localTotalAchieve,
			AccountFlowEnum.AMOUNT_RECORD.getCode(),
			content.toString());
			dappAccountMoneyChangeDao.insert(record);

			//实时更新用户等级
			chainProducer.sendAutoLevelUpTeamMsg(memberId);

			set.add(dappMemberEntity);
			}

			// 判断系统是否启动，如满足条件则启动系统
			String hasStart = redisUtils.getString(AppContants.SYSTEM_START_FLAG);
			if (!"start".equals(hasStart)) {
			DataDictionaryCustom dic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(AppContants.DIC_TYPE_SYSTEM_SETTING, AppContants.DIC_VALUE_SYSTEM_START_TARGET);
			BigDecimal target = new BigDecimal(dic.getValue());

			// 若源池中的USDT达到或超过8万U，则启动整个系统
			BigDecimal balance = ChainService.getInstance(ChainEnum.BSC_USDT_SOURCE.name()).balanceOf(ChainEnum.BSC_USDT_SOURCE.getAddress());
			if (target.compareTo(balance) < 1) {
			redisUtils.set(AppContants.SYSTEM_START_FLAG, "start");

			// 启动系统
			startSystem();
			}
			}
			return set;
			}

			@Override
			public void userBuyReward(Long id) {
			// 系统未启动不参与
			String hasStart = redisUtils.getString(AppContants.SYSTEM_START_FLAG);
			if (!"start".equals(hasStart)) {
			public void speedSalePackageMsg(Long flowId) {
			DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectById(flowId);
			if(DappFundFlowEntity.WITHDRAW_STATUS_ING != dappFundFlowEntity.getStatus()){
			return;
			}
			dappFundFlowEntity.setStatus(DappFundFlowEntity.WITHDRAW_STATUS_AGREE);
			dappFundFlowDao.updateById(dappFundFlowEntity);

			DappFundFlowEntity fundFlow = dappFundFlowDao.selectById(id);

			DappMemberEntity member = dappMemberDao.selectById(fundFlow.getMemberId());
			DappMemberEntity referer = dappMemberDao.selectMemberInfoByInviteId(member.getRefererId());
			if (referer == null \|\| "admin".equals(referer.getAccountType())) {
			BigDecimal cnt = dappFundFlowEntity.getAmount();
			Long memberId = dappFundFlowEntity.getMemberId();
			DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
			if(BigDecimal.ZERO.compareTo(cnt) >= 0){
			return;
			}
			DataDictionaryCustom packageScorePriceDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.PACKAGE_SCORE_PRICE.getType(),
			DataDictionaryEnum.PACKAGE_SCORE_PRICE.getCode()
			);
			BigDecimal packageScorePrice = new BigDecimal(ObjectUtil.isEmpty(packageScorePriceDic) ? "0" : packageScorePriceDic.getValue()).setScale(8, BigDecimal.ROUND_DOWN);
			//卖出资产乘以价格获取到预期获取的总额
			BigDecimal totalAmount = cnt.multiply(packageScorePrice).setScale(4, BigDecimal.ROUND_DOWN);
			//资产包卖出划入底池比例
			DataDictionaryCustom packageToPoorPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.PACKAGE_SALE_TO_POOR_PERCENT.getType(),
			DataDictionaryEnum.PACKAGE_SALE_TO_POOR_PERCENT.getCode()
			);
			BigDecimal packageToPoorPercent = new BigDecimal(ObjectUtil.isEmpty(packageToPoorPercentDic) ? "0.1" : packageToPoorPercentDic.getValue()).setScale(8, BigDecimal.ROUND_DOWN);
			//划入底池的金额
			BigDecimal poorAmount = totalAmount.multiply(packageToPoorPercent).setScale(4, BigDecimal.ROUND_DOWN);
			//实际获取的金额
			BigDecimal realAmount = totalAmount.subtract(poorAmount);
			//生成一条资金流水
			DappFundFlowEntity scoreFlow = new DappFundFlowEntity(
			AccountFlowEnum.AMOUNT.getCode(),
			memberId,
			realAmount,
			FundFlowEnum.SALE_PACKAGE_AMOUNT.getCode(),
			DappFundFlowEntity.WITHDRAW_STATUS_AGREE,
			BigDecimal.ZERO);
			dappFundFlowDao.insert(scoreFlow);
			dappWalletCoinDao.addTotalAndaddAvailableByMemberId(memberId,realAmount);
			DappFundFlowEntity feeFlow = new DappFundFlowEntity(
			AccountFlowEnum.AMOUNT.getCode(),
			memberId,
			poorAmount.negate(),
			FundFlowEnum.SALE_PACKAGE_AMOUNT_FEE.getCode(),
			DappFundFlowEntity.WITHDRAW_STATUS_AGREE,
			BigDecimal.ZERO);
			dappFundFlowDao.insert(feeFlow);

			DataDictionaryCustom dic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(AppContants.DIC_TYPE_SYSTEM_SETTING, AppContants.DIC_VALUE_USER_BUY_REWARD);
			BigDecimal prop = new BigDecimal(dic.getValue()).divide(new BigDecimal("100"), 2, RoundingMode.HALF_UP);
			BigDecimal reward = fundFlow.getAmount().multiply(prop);
			//卖出积分直接销毁。
			DataDictionaryCustom packageTotalScoreDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.PACKAGE_TOTAL_SCORE.getType(),
			DataDictionaryEnum.PACKAGE_TOTAL_SCORE.getCode()
			);
			BigDecimal packageTotalScore = new BigDecimal(ObjectUtil.isEmpty(packageTotalScoreDic) ? "21000" : packageTotalScoreDic.getValue()).setScale(4, BigDecimal.ROUND_DOWN);
			BigDecimal avaPackageTotalScore = packageTotalScore.subtract(cnt);
			packageTotalScoreDic.setValue(avaPackageTotalScore.toString());
			dataDictionaryCustomMapper.updateById(packageTotalScoreDic);
			//更新USDT底池
			DataDictionaryCustom packagePoorDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.PACKAGE_POOR.getType(),
			DataDictionaryEnum.PACKAGE_POOR.getCode()
			);
			BigDecimal packagePoor = new BigDecimal(ObjectUtil.isEmpty(packagePoorDic) ? "0" : packagePoorDic.getValue()).setScale(4, BigDecimal.ROUND_DOWN);
			BigDecimal avaPackagePoor = packagePoor.add(poorAmount);
			packagePoorDic.setValue(avaPackagePoor.toString());
			dataDictionaryCustomMapper.updateById(packagePoorDic);
			//计算当前价格
			BigDecimal divide = avaPackagePoor.divide(avaPackageTotalScore, 8, BigDecimal.ROUND_DOWN);
			packageScorePriceDic.setValue(divide.toString());
			dataDictionaryCustomMapper.updateById(packageScorePriceDic);

			BigDecimal balance = ChainService.getInstance(ChainEnum.BSC_TFC_REWARD.name()).balanceOf(ChainEnum.BSC_TFC_REWARD.getAddress());
			if (balance.compareTo(reward) < 1) {
			return;
			}
			DataDictionaryCustom packageAvaCntDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.PACKAGE_AVA_CNT.getType(),
			DataDictionaryEnum.PACKAGE_AVA_CNT.getCode()
			);
			BigDecimal packageAvaCnt = new BigDecimal(ObjectUtil.isEmpty(packageAvaCntDic) ? "0" : packageAvaCntDic.getValue()).setScale(4, BigDecimal.ROUND_DOWN);
			BigDecimal packageAvaCntScore = packageAvaCnt.add(cnt);
			packageAvaCntDic.setValue(packageAvaCntScore.toString());
			dataDictionaryCustomMapper.updateById(packageAvaCntDic);

			DappFundFlowEntity rewardFlow = new DappFundFlowEntity(referer.getId(), reward, 4, 2, BigDecimal.ZERO);
			dappFundFlowDao.insert(rewardFlow);
			DappFundFlowEntity packageFlow = new DappFundFlowEntity(
			AccountFlowEnum.SYSTEM_PACKAGE.getCode(),
			memberId,
			poorAmount.negate(),
			FundFlowEnum.SYSTEM_SALE_PACKAGE.getCode(),
			DappFundFlowEntity.WITHDRAW_STATUS_AGREE,
			BigDecimal.ZERO);
			dappFundFlowDao.insert(packageFlow);

			OnlineTransferUtil.addTransfer(referer.getAddress(), reward, 4, 1, ChainEnum.BSC_TFC_REWARD.name(), AppContants.SYMBOL_COIN, rewardFlow.getId().toString());
			DappAKlineEntity dappAKlineEntity = new DappAKlineEntity();
			dappAKlineEntity.setOpenPrice(divide);
			dappAKlineEntity.setType(1);
			dappAKlineMapper.insert(dappAKlineEntity);

			Map<String, String> map = new HashMap<>();
			map.put("batchNo", rewardFlow.getId().toString());
			map.put("type", "batch");
			chainProducer.sendOnlineTransfer(JSONObject.toJSONString(map));
			}


			@Override
			public void startSystem() {
			log.info("启动系统");

			Thread thread = new Thread(new Runnable() {
			@Override
			public void run() {
			transferPoolSetting();
			sourcePoolUsdtOutLimitSetting();
			}
			});

			thread.start();
			}

			// 最低容量(百分比)
			private final BigDecimal volProp = new BigDecimal("2");
			// 每日增/减百分比
			private final BigDecimal changeProp = new BigDecimal("1");

			@Override
			public void transferPoolSetting() {
			String hasStart = redisUtils.getString(AppContants.SYSTEM_START_FLAG);
			if (!"start".equals(hasStart)) {
			log.info("系统未启动");
			return;
			}

			// 源池初始化容量
			DataDictionaryCustom dic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(AppContants.DIC_TYPE_SYSTEM_SETTING, AppContants.DIC_VALUE_SYSTEM_SOURCE_POOL_VOL);
			BigDecimal basicVol = new BigDecimal(dic.getValue());

			Object o = redisUtils.get(AppContants.REDIS_KEY_TRANSFER_POOL_VOL);
			if (o == null) {
			RedisTransferPoolVo transferPool= new RedisTransferPoolVo();
			BigDecimal total = basicVol.multiply(volProp.divide(BigDecimal.valueOf(100), 4, RoundingMode.HALF_UP));
			transferPool.setTodayVol(total);
			transferPool.setTodayProp(volProp);
			transferPool.setFinishCnt(0);
			transferPool.setUnFinishCnt(0);
			redisUtils.set(AppContants.REDIS_KEY_TRANSFER_POOL_VOL, transferPool);
			redisUtils.set(AppContants.REDIS_KEY_TRANSFER_POOL_VOL_REMAIN, total);

			redisUtils.set(AppContants.REDIS_KEY_MINE_TRANSFER_POOL_TRADE_CNT, BigDecimal.ZERO);
			return;
			}

			RedisTransferPoolVo transferPool = (RedisTransferPoolVo) o;
			BigDecimal remain = (BigDecimal) redisUtils.get(AppContants.REDIS_KEY_TRANSFER_POOL_VOL_REMAIN);

			// 设置当日成交量
			redisUtils.set(AppContants.REDIS_KEY_MINE_TRANSFER_POOL_TRADE_CNT, transferPool.getTodayVol().subtract(remain));

			// 全卖了
			if (remain.compareTo(BigDecimal.ZERO) == 0) {
			int finishCnt = transferPool.getFinishCnt() + 1;
			BigDecimal targetProp = transferPool.getTodayProp();
			if (finishCnt == 1) {
			targetProp = transferPool.getTodayVol().add(changeProp);
			transferPool.setTodayProp(targetProp);
			transferPool.setFinishCnt(0);
			} else {
			transferPool.setFinishCnt(finishCnt);
			}

			BigDecimal total = basicVol.multiply(targetProp.divide(BigDecimal.valueOf(100), 4, RoundingMode.HALF_UP));
			transferPool.setTodayVol(total);
			transferPool.setUnFinishCnt(0);
			redisUtils.set(AppContants.REDIS_KEY_TRANSFER_POOL_VOL_REMAIN, total);

			} else {
			int unFinishCnt = transferPool.getUnFinishCnt() + 1;
			BigDecimal targetProp = transferPool.getTodayProp();
			if (unFinishCnt >= 1) {
			targetProp = transferPool.getTodayProp().compareTo(volProp) == 0 ? volProp : transferPool.getTodayProp().subtract(changeProp);
			transferPool.setTodayProp(targetProp);
			transferPool.setUnFinishCnt(0);
			} else {
			transferPool.setUnFinishCnt(unFinishCnt);
			}
			BigDecimal aa = targetProp.divide(BigDecimal.valueOf(100), 4, RoundingMode.HALF_UP);
			BigDecimal total = basicVol.multiply(aa);
			transferPool.setTodayVol(total);
			redisUtils.set(AppContants.REDIS_KEY_TRANSFER_POOL_VOL_REMAIN, total);
			}

			redisUtils.set(AppContants.REDIS_KEY_TRANSFER_POOL_VOL, transferPool);
			}

			@Override
			public void sourcePoolUsdtOutLimitSetting() {
			String hasStart = redisUtils.getString(AppContants.SYSTEM_START_FLAG);
			if (!"start".equals(hasStart)) {
			log.info("系统未启动");
			public void updatePackage(Set<DappMemberEntity> dappMemberEntities) {
			DataDictionaryCustom packageTeamPerkPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.PACKAGE_TEAM_PERK_PERCENT.getType(),
			DataDictionaryEnum.PACKAGE_TEAM_PERK_PERCENT.getCode()
			);
			BigDecimal packageTeamPerkPercent = new BigDecimal(ObjectUtil.isEmpty(packageTeamPerkPercentDic) ? "0.01" : packageTeamPerkPercentDic.getValue());

			for(DappMemberEntity dappMemberEntity : dappMemberEntities){
			// List<DappFundFlowEntity> dappFundFlowEntities = dappFundFlowDao.selectListByMemberIdAndTypeAndDate(dappMemberEntity.getId()
			// , FundFlowEnum.ADD_AMOUNT_REAL.getCode()
			// , DateUtil.offsetHour(DateUtil.date(), -12));
			List<DappFundFlowEntity> dappFundFlowEntities = dappFundFlowDao.selectListByMemberIdAndTypeAndDate(dappMemberEntity.getId()
			, FundFlowEnum.ADD_AMOUNT_REAL.getCode()
			, DateUtil.date());
			//总收益
			BigDecimal totalPerk = dappFundFlowEntities.stream().map(DappFundFlowEntity::getAmount).reduce(BigDecimal.ZERO, BigDecimal::add);
			BigDecimal memberPerk = totalPerk.multiply(packageTeamPerkPercent);

			DataDictionaryCustom packageTeamPerkCntDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.PACKAGE_TEAM_PERK_CNT.getType(),
			DataDictionaryEnum.PACKAGE_TEAM_PERK_CNT.getCode()
			);

			DataDictionaryCustom packageScorePriceDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			DataDictionaryEnum.PACKAGE_SCORE_PRICE.getType(),
			DataDictionaryEnum.PACKAGE_SCORE_PRICE.getCode()
			);
			BigDecimal packageScorePrice = new BigDecimal(ObjectUtil.isEmpty(packageScorePriceDic) ? "0" : packageScorePriceDic.getValue()).setScale(2, BigDecimal.ROUND_DOWN);

			BigDecimal divide = memberPerk.divide(packageScorePrice, 4, BigDecimal.ROUND_DOWN);
			if(BigDecimal.ZERO.compareTo(divide) >= 0){
			continue;
			}

			BigDecimal packageTeamPerkCnt = new BigDecimal(packageTeamPerkCntDic.getValue()).setScale(2, BigDecimal.ROUND_DOWN);
			if(BigDecimal.ZERO.compareTo(packageTeamPerkCnt) >= 0){
			return;
			}
			if(packageTeamPerkCnt.compareTo(divide) >= 0){
			BigDecimal subtract = packageTeamPerkCnt.subtract(divide);
			packageTeamPerkCntDic.setValue(subtract.toString());
			dataDictionaryCustomMapper.updateById(packageTeamPerkCntDic);
			}

			BigDecimal balance = dappMemberEntity.getBalance();
			balance = balance.add(divide);
			dappMemberEntity.setBalance(balance);
			dappMemberDao.updateById(dappMemberEntity);

			//插入余额流水
			DappFundFlowEntity amountFlow = new DappFundFlowEntity(
			AccountFlowEnum.AMOUNT.getCode(),
			dappMemberEntity.getId(),
			divide,
			FundFlowEnum.PACKAGE_ADD.getCode(),
			DappFundFlowEntity.WITHDRAW_STATUS_AGREE,
			BigDecimal.ZERO);
			dappFundFlowDao.insert(amountFlow);

			}

			}

			public void shareStaticPerk(List<DappMemberEntity> dappMemberEntities,
			int code) {
			if(CollUtil.isEmpty(dappMemberEntities)){
			return;
			}
			BigDecimal sourceBalance = ChainService.getInstance(ChainEnum.BSC_USDT.name()).balanceOf(ChainEnum.BSC_USDT_SOURCE.getAddress());
			for(DappMemberEntity dappMemberEntity : dappMemberEntities){
			/**
			* 每个人的第一次入单之后的业绩不一样
			*/
			List<MallAchieveRecord> mallAchieveRecords = mallAchieveRecordMapper.selectListByMemberId(dappMemberEntity.getId());
			if(CollUtil.isEmpty(mallAchieveRecords)){
			continue;
			}
			Date payTime = mallAchieveRecords.get(0).getPayTime();
			//下第一单之后的共享区全部业绩
			BigDecimal totalAchieve = mallAchieveRecordMapper.selectAchieveTotalByCreateTime(payTime);
			//个人总业绩
			BigDecimal totalMemberAchieve = mallAchieveRecordMapper.selectAchieveTotalByMemberIdAndCreateTime(dappMemberEntity.getId(), payTime);
			if(BigDecimal.ZERO.compareTo(totalAchieve) >= 0 \|\| BigDecimal.ZERO.compareTo(totalMemberAchieve) >= 0){
			continue;
			}
			String accountType = dappMemberEntity.getAccountType();
			DataDictionaryCustom accountTypeDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			"TEAM_LEVEL", accountType
			);
			if(ObjectUtil.isEmpty(accountTypeDic)){
			continue;
			}
			TeamLevelPerk teamLevelPerk = JSONObject.parseObject(accountTypeDic.getValue(), TeamLevelPerk.class);
			BigDecimal shareMinPercent = teamLevelPerk.getShareMinPercent();
			BigDecimal sharePerk = totalAchieve.multiply(shareMinPercent).setScale(2,BigDecimal.ROUND_DOWN);

			BigDecimal total = sourceBalance.multiply(BigDecimal.valueOf(0.1)).setScale(4, RoundingMode.HALF_DOWN);
			redisUtils.set(AppContants.REDIS_KEY_USDT_OUT_LIMIT, total);
			redisUtils.set(AppContants.REDIS_KEY_USDT_OUT_LIMIT_REMAIN, total);
			BigDecimal shareMaxPercent = teamLevelPerk.getShareMaxPercent();
			BigDecimal maxSharePerk = totalMemberAchieve.multiply(shareMaxPercent).setScale(2,BigDecimal.ROUND_DOWN);
			if(BigDecimal.ZERO.compareTo(sharePerk) >= 0 \|\| BigDecimal.ZERO.compareTo(maxSharePerk) >= 0){
			continue;
			}
			//共享区加速万分之2，上限1.2%（按本金计）
			if(sharePerk.compareTo(maxSharePerk) >= 0){
			sharePerk = maxSharePerk;
			}
			sendPerk(dappMemberEntity, sharePerk, dappMemberEntity.getId(), code);
			}
			}

			public void isAllPerkMemberLevel(List<DappMemberEntity> dappMemberEntities,
			String level,
			int code){
			if(CollUtil.isEmpty(dappMemberEntities)){
			return;
			}
			DataDictionaryCustom teamPerkMemberDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			"TEAM_LEVEL", level);
			TeamLevelPerk adminAgentInfo = JSONObject.parseObject(teamPerkMemberDic.getValue(), TeamLevelPerk.class);
			BigDecimal orderSalePercent = adminAgentInfo.getOrderSalePercent();
			if(BigDecimal.ZERO.compareTo(orderSalePercent) >= 0){
			return;
			}
			allPerkMemberLevel(dappMemberEntities,level,code);

			}

			public void allPerkMemberLevel(List<DappMemberEntity> dappMemberEntities,
			String level,
			int code) {
			/**
			* 全网24小时内的全部分红
			*/
			Date createTime = DateUtil.offsetHour(DateUtil.date(),-24);
			//下第一单之后的共享区全部业绩
			BigDecimal totalAchieve = mallAchieveRecordMapper.selectAchieveTotalByCreateTime(createTime);
			if(BigDecimal.ZERO.compareTo(totalAchieve) >= 0){
			return;
			}
			DataDictionaryCustom teamPerkMemberDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			"TEAM_LEVEL", level);
			TeamLevelPerk adminAgentInfo = JSONObject.parseObject(teamPerkMemberDic.getValue(), TeamLevelPerk.class);
			BigDecimal orderSalePercent = adminAgentInfo.getOrderSalePercent();
			//每人平分数量
			BigDecimal divide = totalAchieve.multiply(orderSalePercent).divide(new BigDecimal(dappMemberEntities.size()), 2, BigDecimal.ROUND_DOWN);

			for(DappMemberEntity dappMemberEntity : dappMemberEntities){
			sendPerk(dappMemberEntity, divide, dappMemberEntity.getId(), code);
			}
			}

			public void teamStaticPerkMemberLevel(List<DappMemberEntity> dappMemberEntities,
			BigDecimal teamPerkEquals,
			BigDecimal staticRelease,
			int code,
			String memberAccountType) {
			if(CollUtil.isEmpty(dappMemberEntities)){
			return;
			}
			for(DappMemberEntity teamPerkMember : dappMemberEntities){
			String level = teamPerkMember.getAccountType();
			//比较两个级别的大小，level大于levelNormal返回1
			int compareMin = MemberLevelEnum.V1.compareLevel(level, MemberLevelEnum.V1.getType());
			int compareMax = MemberLevelEnum.V1.compareLevel(MemberLevelEnum.V7.getType(), level);
			if(compareMin >= 1 && compareMax >= 1){
			DataDictionaryCustom teamPerkMemberDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			"TEAM_LEVEL", level);
			TeamLevelPerk adminAgentInfo = JSONObject.parseObject(teamPerkMemberDic.getValue(), TeamLevelPerk.class);
			BigDecimal cashPercent = adminAgentInfo.getTeamPercent();
			// 直推用户
			List<DappMemberEntity> childs = dappMemberDao.selectMemberInfoByRefererId(teamPerkMember.getInviteId());
			// List<DappMemberEntity> collect = childs.stream()
			// .filter(dappMemberEntity -> dappMemberEntity.getAccountType().equals(memberAccountType))
			// .collect(Collectors.toList());
			//所有直推团队，就是这个会员的所有区域的业绩。
			// List<String> childsInviteIds = childs.stream().map(DappMemberEntity::getInviteId).collect(Collectors.toList());
			if(CollUtil.isNotEmpty(childs)){
			for(DappMemberEntity dappMemberChild : childs){
			String childAccountType = dappMemberChild.getAccountType();
			int compareLevel = MemberLevelEnum.V1.compareLevel(level, childAccountType);
			//级别比我高，则没有团队加速
			if(compareLevel < 1){
			continue;
			}
			if(compareLevel == 1){
			BigDecimal cashPercentChild = BigDecimal.ZERO;
			if(!MemberLevelEnum.MEMBER.getType().equals(childAccountType)){
			DataDictionaryCustom teamPerkMemberChildDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			"TEAM_LEVEL", childAccountType);
			TeamLevelPerk adminAgentInfoChild = JSONObject.parseObject(teamPerkMemberChildDic.getValue(), TeamLevelPerk.class);
			cashPercentChild = adminAgentInfoChild.getTeamPercent();
			}
			BigDecimal subtract = cashPercent.subtract(cashPercentChild);
			BigDecimal totalIncomeMember = dappMemberDao.selectAllAchieveByInviteId(dappMemberChild.getInviteId());
			//V1加速团队静态收益的15%=每日静态的200006‰15%=18元的额外释放加速
			BigDecimal cashAmount = totalIncomeMember.multiply(staticRelease).multiply(subtract).setScale(2, BigDecimal.ROUND_DOWN);
			if(BigDecimal.ZERO.compareTo(cashAmount) >= 0){
			continue;
			}
			BigDecimal bigDecimal = sendPerk(teamPerkMember, cashAmount, teamPerkMember.getId(), code);
			continue;
			}
			if(compareLevel > 1){
			BigDecimal totalIncomeMember = dappMemberDao.selectAllAchieveByInviteId(dappMemberChild.getInviteId());
			//V1加速团队静态收益的15%=每日静态的200006‰15%=18元的额外释放加速
			BigDecimal cashAmount = totalIncomeMember.multiply(staticRelease).multiply(teamPerkEquals).setScale(2, BigDecimal.ROUND_DOWN);
			if(BigDecimal.ZERO.compareTo(cashAmount) >= 0){
			continue;
			}
			BigDecimal bigDecimal = sendPerk(teamPerkMember, cashAmount, teamPerkMember.getId(), code);
			continue;

			}
			}
			}
			// //总业绩
			// BigDecimal teamIncomeMax = BigDecimal.ZERO;
			// for(String inviteId : childsInviteIds){
			// //极差
			// if(CollUtil.isNotEmpty(collect)){
			// List<String> collectInviteIds = collect.stream().map(DappMemberEntity::getInviteId).collect(Collectors.toList());
			// if(collectInviteIds.contains(inviteId)){
			// BigDecimal totalIncomeMember = dappMemberDao.selectAllAchieveByInviteId(inviteId);
			// //V1加速团队静态收益的15%=每日静态的200006‰15%=18元的额外释放加速
			// BigDecimal cashAmount = totalIncomeMember.multiply(teamPerkEquals).multiply(staticRelease).setScale(2, BigDecimal.ROUND_DOWN);
			// if(BigDecimal.ZERO.compareTo(cashAmount) >= 0){
			// continue;
			// }
			// BigDecimal bigDecimal = sendPerk(teamPerkMember, cashAmount, teamPerkMember.getId(), code);
			// continue;
			// }else{
			// BigDecimal totalIncomeMember = dappMemberDao.selectAllAchieveByInviteId(inviteId);
			// //V1加速团队静态收益的15%=每日静态的200006‰15%=18元的额外释放加速
			// BigDecimal cashAmount = totalIncomeMember.multiply(cashPercent).multiply(staticRelease).setScale(2, BigDecimal.ROUND_DOWN);
			// if(BigDecimal.ZERO.compareTo(cashAmount) >= 0){
			// continue;
			// }
			// BigDecimal bigDecimal = sendPerk(teamPerkMember, cashAmount, teamPerkMember.getId(), code);
			// continue;
			// }
			// }
			// BigDecimal totalIncomeMember = dappMemberDao.selectAllAchieveByInviteId(inviteId);
			// //V1加速团队静态收益的15%=每日静态的200006‰15%=18元的额外释放加速
			// BigDecimal cashAmount = totalIncomeMember.multiply(cashPercent).multiply(staticRelease).setScale(2, BigDecimal.ROUND_DOWN);
			// if(BigDecimal.ZERO.compareTo(cashAmount) >= 0){
			// continue;
			// }
			// BigDecimal bigDecimal = sendPerk(teamPerkMember, cashAmount, teamPerkMember.getId(), code);
			// }
			}
			}

			}

			private BigDecimal sendPerk(DappMemberEntity parentMember,BigDecimal directReleaseAmount,Long orderId
			,Integer fundFlowEnumType){

			BigDecimal realScoreReduce = directReleaseAmount;
			if(BigDecimal.ZERO.compareTo(directReleaseAmount) >= 0){
			return realScoreReduce;
			}
			//生成一条静态补贴的流水
			DappFundFlowEntity realUsdtAmountFlow = new DappFundFlowEntity(
			AccountFlowEnum.AMOUNT.getCode(),
			parentMember.getId(),
			realScoreReduce,
			fundFlowEnumType,
			DappFundFlowEntity.WITHDRAW_STATUS_AGREE,
			BigDecimal.ZERO,
			null,
			orderId);
			dappFundFlowDao.insert(realUsdtAmountFlow);
			//插入积分流水
			DappFundFlowEntity scoreFlow = new DappFundFlowEntity(
			AccountFlowEnum.SCORE.getCode(),
			parentMember.getId(),
			realScoreReduce.negate(),
			FundFlowEnum.REDUCE_SCORE.getCode(),
			DappFundFlowEntity.WITHDRAW_STATUS_AGREE,
			BigDecimal.ZERO,
			null,
			orderId);
			dappFundFlowDao.insert(scoreFlow);
			//插入余额流水
			DappFundFlowEntity amountFlow = new DappFundFlowEntity(
			AccountFlowEnum.AMOUNT.getCode(),
			parentMember.getId(),
			realScoreReduce,
			FundFlowEnum.ADD_AMOUNT.getCode(),
			DappFundFlowEntity.WITHDRAW_STATUS_AGREE,
			BigDecimal.ZERO,
			null,
			orderId);
			dappFundFlowDao.insert(amountFlow);
			return realScoreReduce;
			}


			/**
			* 测试转账
			* @param args
			*/
			// public static void main(String[] args) {
			// String transfer = ChainService.getInstance(ChainEnum.BSC_USDT_A_POOL.name()).transfer("0x74fC0e035f315F7BD8b7686e22581AB1afC45e97", new BigDecimal(1));
			// System.out.println(transfer);
			//
			// }

			/**
			* 生成当前分钟的k线数据，type为0
			*/
			public void createKDate(){
			DappAKlineEntity dappAKlineEntity = new DappAKlineEntity();
			dappAKlineEntity.setType(0);
			DataDictionaryCustom dataDictionaryCustom = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
			PoolEnum.COIN_A_PRICE.getType(),
			PoolEnum.COIN_A_PRICE.getCode()
			);
			BigDecimal coinAPrice = new BigDecimal(dataDictionaryCustom.getValue());

			/**
			* 获取最新一条小时或者分钟的数据
			*/
			DappAKlineEntity oldOne = dappAKlineMapper.selectOneByType();
			if(ObjectUtil.isNotEmpty(oldOne)){
			dappAKlineEntity.setOpenPrice(oldOne.getClosePrice());
			dappAKlineEntity.setLowestPrice(oldOne.getClosePrice());
			}else{
			dappAKlineEntity.setOpenPrice(coinAPrice);
			dappAKlineEntity.setLowestPrice(coinAPrice);
			}
			dappAKlineEntity.setHighestPrice(coinAPrice);
			dappAKlineEntity.setClosePrice(coinAPrice);
			dappAKlineMapper.insert(dappAKlineEntity);

			}

			// public static void main(String[] args) {
			//
			// int month = DateUtil.dayOfMonth(DateUtil.date());
			// String s = DateUtil.dayOfWeekEnum(DateUtil.date()).toChinese();
			// System.out.println(s);
			// System.out.println(month);
			// }

			/**
			* 判断直推人数是否达标
			*
			* @param member
			* @return
			*/
			private boolean directMemberCnt(DappMemberEntity member, NodePerk agentInfo) {
			List<DappMemberEntity> childs = dappMemberDao.selectMemberInfoByRefererId(member.getInviteId());
			if (CollUtil.isEmpty(childs)) {
			return false;
			}

			if (childs.size() >= agentInfo.getDirectCnt()) {
			return true;
			}

			log.info("用户:{}直推数量未达标, 当前等级:{}, 当前数量:{}, 目标数量:{}", member.getAddress(), member.getAccountType(), childs.size(), agentInfo.getDirectCnt());
			return false;
			}

			/**
			* 判断下级代理数量是否达标
			*
			* @return
			*/
			private boolean agentCntFinish(DappMemberEntity member, NodePerk agentInfo) {
			if (agentInfo.getDirectCnt() == null \|\| agentInfo.getDirectCnt() == 0) {
			return true;
			}
			// 直推用户
			List<DappMemberEntity> childs = dappMemberDao.selectMemberInfoByRefererId(member.getInviteId());
			if (CollUtil.isEmpty(childs)) {
			return false;
			}
			// 用户团队达到指定代理数量，且都不在同一条线
			int i = 0;
			for (DappMemberEntity child : childs) {
			List<DappMemberEntity> mallMembers = dappMemberDao.selectChildAgentListByAccountType(child.getInviteId(), member.getAccountType());
			if (CollUtil.isNotEmpty(mallMembers)) {
			i++;
			}
			}
			if (i >= agentInfo.getDirectCnt()) {
			return true;
			}
			log.info("用户:{}代理数量未达标, 当前等级:{}, 当前数量:{}, 目标数量:{}", member.getAddress(), member.getAccountType(), i, agentInfo.getDirectCnt());
			return false;
			}

			/**
			* 团队业绩是否达标
			* 除去直属的最大的一个业绩团队，剩余的所有业绩之和
			*
			* @param
			* @param agentInfo
			* @return
			*/
			private boolean teamIncome(DappMemberEntity member, NodePerk agentInfo) {
			BigDecimal teamIncome = agentInfo.getTeamIncome();
			//业绩集合
			List<BigDecimal> list = new ArrayList<>();
			//总业绩
			BigDecimal teamIncomeMax = BigDecimal.ZERO;
			//所有直推团队，就是这个会员的所有区域的业绩。

			// 直推用户
			List<DappMemberEntity> childs = dappMemberDao.selectMemberInfoByRefererId(member.getInviteId());
			List<String> childsInviteIds = childs.stream().map(DappMemberEntity::getInviteId).collect(Collectors.toList());
			for(String inviteId : childsInviteIds){
			BigDecimal totalIncomeMember = dappMemberDao.selectAllAchieveByInviteId(inviteId);
			teamIncomeMax = teamIncomeMax.add(totalIncomeMember);
			list.add(totalIncomeMember);
			}
			//去掉一个最大区的业绩
			BigDecimal bigMax = list.stream().max(BigDecimal::compareTo).get();
			teamIncomeMax = teamIncomeMax.subtract(bigMax);

			if (teamIncomeMax.compareTo(teamIncome) >= 0) {
			return true;
			}
			log.info("用户:{}团队业绩未达标, 当前等级:{}, 当前业绩:{}, 目标业绩:{}", member.getAddress(), member.getAccountType(), teamIncomeMax, teamIncome);
			return false;
			}

			}