智能合约

xiaoyong931011

2023-07-12 d13fbfbd5972cbd521ac8eedee57a1888e19cb14

 src/main/java/cc/mrbird/febs/dapp/service/impl/DappSystemServiceImpl.java

@@ -1,6 +1,7 @@
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.utils.LoginUserUtil;
import cc.mrbird.febs.common.utils.RedisUtils;
import cc.mrbird.febs.common.utils.SpringContextUtil;
@@ -10,30 +11,38 @@
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.DataDictionaryEnum;
import cc.mrbird.febs.dapp.enumerate.LevelProfitEnum;
import cc.mrbird.febs.dapp.enumerate.*;
import cc.mrbird.febs.dapp.mapper.*;
import cc.mrbird.febs.dapp.service.DappSystemService;
import cc.mrbird.febs.dapp.service.DappWalletService;
import cc.mrbird.febs.dapp.vo.AKLineLimitVo;
import cc.mrbird.febs.rabbit.producer.ChainProducer;
import cc.mrbird.febs.tree.MatrixTree;
import cc.mrbird.febs.tree.MemberNode;
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.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.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
@@ -56,6 +65,14 @@
    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;



    @Override
@@ -353,22 +370,24 @@
                DataDictionaryCustom memberLevelSet = dataDictionaryCustomMapper.selectDicDataByTypeAndCode("MEMBER_LEVEL", accountType);
                BigDecimal memberLevel = new BigDecimal(memberLevelSet.getValue());

                BigDecimal memberLevelProfit = levelProfitTotal.multiply(profit).multiply(memberLevel);
//                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());
                chainProducer.sendBnbTransferMsg(fundFlow.getId());
                systemProfitTotal = systemProfitTotal.add(memberLevelProfit);
            }
        }
        //如果还有剩余给技术方
        if(levelProfitTotal.compareTo(systemProfitTotal) > 0){
            BigDecimal avaProfit = levelProfitTotal.subtract(systemProfitTotal);
            DappFundFlowEntity fundFlow = new DappFundFlowEntity(1L, avaProfit, 5, 1, BigDecimal.ZERO,null,dappSystemProfit.getId());
            DappFundFlowEntity fundFlow = new DappFundFlowEntity(2L, avaProfit, 5, 1, BigDecimal.ZERO,null,dappSystemProfit.getId());
            dappFundFlowDao.insert(fundFlow);
            //发送转币消息
//            chainProducer.sendBnbTransferMsg(fundFlow.getId());
            chainProducer.sendBnbTransferMsg(fundFlow.getId());
        }

        dappSystemProfitDao.updateLevelProfitById(DappSystemProfit.ENUM_YES,dappSystemProfit.getId());
@@ -422,7 +441,7 @@
        DappSystemProfit dappSystemProfitNow = dappSystemProfitDao.selectByIdForUpdate(dappSystemProfit.getId(),DappSystemProfit.STATE_IN);
        dappSystemProfitDao.updateStateById(DappSystemProfit.STATE_OUT,dappSystemProfitNow.getId());

        //todo 直接拿走0.95ge
        // 直接拿走0.95ge

        DataDictionaryCustom investAmountProfitSet = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(DataDictionaryEnum.INVEST_AMOUNT_PROFIT.getType(), DataDictionaryEnum.INVEST_AMOUNT_PROFIT.getCode());
        BigDecimal investAmountProfit = new BigDecimal(investAmountProfitSet.getValue());
@@ -466,21 +485,27 @@
            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 = dappFundFlow.getAddress();
//    //        String hash = ChainService.getInstance(ChainEnum.BSC_USDT.name()).transfer(address, amount);
//            String hash = ChainService.getInstance(ChainEnum.BNB.name()).transferBaseToken(address, amount);
//            if(StrUtil.isEmpty(hash)){
//                return;
//            }
//            log.info("{},{}",id,hash);
//            dappFundFlow.setFromHash(hash);
//            dappFundFlowDao.updateById(dappFundFlow);
//        }
        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
@@ -546,39 +571,2098 @@

    @Override
    public void bnbTransferTest(Long id) {
        DappFundFlowEntity dappFundFlow = dappFundFlowDao.selectById(id);
        if(ObjectUtil.isEmpty(dappFundFlow)){
        log.info("{}",id);
        //获取对应的流水记录
        DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectInfoById(id);
        if(ObjectUtil.isEmpty(dappFundFlowEntity)){
            return;
        }
        //用户已经加入动能队列
        DappSystemProfit dappSystemProfit = dappSystemProfitDao.selectById(dappFundFlow.getSystemProfitId()==null ? 0L : dappFundFlow.getSystemProfitId());
        if(ObjectUtil.isEmpty(dappSystemProfit)){
            return;
        }
        //金额
        BigDecimal amount = dappFundFlow.getAmount();
        //目标地址
        Long memberId = dappFundFlow.getMemberId();
        Long memberId = dappFundFlowEntity.getMemberId();
        DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
        if(ObjectUtil.isEmpty(dappMemberEntity)){
            return;
        }
        String address = dappMemberEntity.getAddress();
        log.info("{}",address);
        String hash = contractMain.trans(new BigInteger(amount.toString()),address);
        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;
        }

        dappFundFlow.setFromHash(hash);
        dappFundFlowDao.updateById(dappFundFlow);
        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) {
        String refererIds = "1,2,3,4,5," +
                            "6,7,8,9,10," +
                            "11,12,13,14,15";
        List<String> refererIdList = StrUtil.split(refererIds, ',');
        System.out.println(refererIdList);
        BigDecimal amount = new BigDecimal("1");
        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);
        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);
        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);

    }

    /**
     * 测试转账
     * @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;
    }

}