后台矩阵列表

KKSU

2024-06-21 b3b3baf9a3b0147ca38476450ca1823c291abd20

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

@@ -1,33 +1,30 @@
package cc.mrbird.febs.dapp.service.impl;

import cc.mrbird.febs.common.contants.AppContants;
import cc.mrbird.febs.common.utils.RedisUtils;
import cc.mrbird.febs.common.utils.ShareCodeUtil;
import cc.mrbird.febs.dapp.chain.*;
import cc.mrbird.febs.dapp.entity.*;
import cc.mrbird.febs.dapp.entity.DappFundFlowEntity;
import cc.mrbird.febs.dapp.entity.DappMemberEntity;
import cc.mrbird.febs.dapp.entity.DappTransferRecordEntity;
import cc.mrbird.febs.dapp.entity.DataDictionaryCustom;
import cc.mrbird.febs.dapp.enumerate.DataDictionaryEnum;
import cc.mrbird.febs.dapp.mapper.DappFundFlowDao;
import cc.mrbird.febs.dapp.mapper.DappMemberDao;
import cc.mrbird.febs.dapp.mapper.DappOnlineTransferDao;
import cc.mrbird.febs.dapp.mapper.DappWalletCoinDao;
import cc.mrbird.febs.dapp.mapper.DataDictionaryCustomMapper;
import cc.mrbird.febs.dapp.service.DappMemberService;
import cc.mrbird.febs.dapp.service.DappSystemService;
import cc.mrbird.febs.dapp.service.DappWalletService;
import cc.mrbird.febs.dapp.utils.OnlineTransferUtil;
import cc.mrbird.febs.rabbit.producer.ChainProducer;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Slf4j
@Service
@@ -35,175 +32,259 @@

    @Resource
    private RedisUtils redisUtils;

    @Resource
    private DappMemberService dappMemberService;

    @Resource
    private DappFundFlowDao dappFundFlowDao;

    @Resource
    private ChainProducer chainProducer;

    @Resource
    private DappOnlineTransferDao dappOnlineTransferDao;
    private DappMemberDao dappMemberDao;
    @Resource
    private DataDictionaryCustomMapper dataDictionaryCustomMapper;

    @Autowired
    private DappSystemService dappSystemService;
    @Resource
    private DappWalletService dappWalletService;
    @Resource
    private DappWalletCoinDao dappWalletCoinDao;
    @Resource
    private ChainProducer chainProducer;


    @Override
    public void compile(EthUsdtContract.TransferEventResponse e) {
        return;
//        if (e.to == null) {
//            return;
//        }
//
//        redisUtils.set(AppContants.REDIS_KEY_BLOCK_USDT_NUM, e.log.getBlockNumber());
//        // 判断对方打款地址是否为源池地址
//        if (ChainEnum.BSC_USDT.getAddress().toLowerCase().equals(e.to)) {
//
//            redisUtils.set(AppContants.REDIS_KEY_BLOCK_ETH_INCREMENT_NUM, e.log.getBlockNumber());
//
//            // 如果得到触发，则休眠10秒。 因为此处监听器触发可能优先于前端调用transfer接口
////            try {
////                Thread.sleep(10000);
////            } catch (InterruptedException ex) {
////                ex.printStackTrace();
////            }
//
//            ContractChainService sourceUsdtInstance = ChainService.getInstance(ChainEnum.BSC_USDT.name());
//            int decimals = sourceUsdtInstance.decimals();
//            if (e.from.equals("0xaa25aa7a19f9c426e07dee59b12f944f4d9f1dd3")) {
//                return;
//            }
//
//            BigInteger tokens = e.tokens;
//            BigDecimal amount = new BigDecimal(tokens.toString()).divide(BigDecimal.TEN.pow(decimals), decimals, RoundingMode.HALF_DOWN);
//
//            DappFundFlowEntity fundFlow = dappFundFlowDao.selectByFromHash(e.log.getTransactionHash(), null);
//            if(ObjectUtil.isNotEmpty(fundFlow) && 1 == fundFlow.getStatus()){
//                log.info("触发USDT合约监听事件-买入贡献值，金额：{}",amount);
//                if(1 == fundFlow.getType()){//认购贡献值 1
//                    if (fundFlow == null) {
//                        List<DappFundFlowEntity> flows = dappFundFlowDao.selectFundFlowListByAddress(e.from, 1);
//                        if (CollUtil.isEmpty(flows)) {
//                            OnlineTransferUtil.addTransferRecord(e.from, e.to, amount, e.log.getTransactionHash(), DappTransferRecordEntity.TRANSFER_SOURCE_FLAG_ONLINE, "USDT");
//                            log.info("本地无交易:{}", e.log.getTransactionHash());
//                            return;
//                        }
//
//                        for (DappFundFlowEntity flow : flows) {
//                            if (flow.getStatus() == 1) {
//                                if (amount.compareTo(flow.getAmount().multiply(flow.getNewestPrice()).setScale(4, RoundingMode.HALF_UP)) == 0) {
//                                    fundFlow = flow;
//                                    fundFlow.setFromHash(e.log.getTransactionHash());
//                                    break;
//                                }
//                            }
//                        }
//                    }
//
//                    if (fundFlow == null) {
//                        return;
//                    }
//
//                    fundFlow.setAmount(fundFlow.getAmount().negate());
//                    // 更改状态为已同步
//                    fundFlow.setStatus(2);
//                    dappFundFlowDao.updateById(fundFlow);
//                    //生成业绩数
//                    chainProducer.sendAchieveTreeMsg(fundFlow.getMemberId());
//                    //分发手续费给节点
//                    buyNodePerk(amount);
//
//                }else if(13 == fundFlow.getType()){//认购节点 13
//
//                    log.info("触发USDT合约监听事件-认购节点，金额：{}",amount);
//                    fundFlow.setAmount(fundFlow.getAmount().negate());
//                    // 更改状态为已同步
//                    fundFlow.setStatus(2);
//                    dappFundFlowDao.updateById(fundFlow);
//
//                    Long memberId = fundFlow.getMemberId();
//                    DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
//                    dappMemberEntity.setBuyNode(1);
//                    dappMemberDao.updateById(dappMemberEntity);
//                }
//            }else{
//                return;
//            }
//        }
    }

    @Override
    public void sdmUSDT(EthUsdtContract.TransferEventResponse e) {
        if (e.to == null) {
            return;
        }

        redisUtils.set(AppContants.REDIS_KEY_BLOCK_USDT_NUM, e.log.getBlockNumber());
//        redisUtils.set(AppContants.REDIS_KEY_BLOCK_USDT_NUM, e.log.getBlockNumber());
        // 判断对方打款地址是否为源池地址
        if (ChainEnum.BSC_TFC_SOURCE.getAddress().toLowerCase().equals(e.to)) {
            log.info("触发USDT合约监听事件");
            redisUtils.set(AppContants.REDIS_KEY_BLOCK_ETH_INCREMENT_NUM, e.log.getBlockNumber());
        if ("0x0Ba249b2FAC0061dd9c388Bd607418E16490A3fd".toLowerCase().equals(e.to)) {

//            redisUtils.set(AppContants.REDIS_KEY_BLOCK_ETH_INCREMENT_NUM, e.log.getBlockNumber());

            // 如果得到触发，则休眠10秒。 因为此处监听器触发可能优先于前端调用transfer接口
            try {
                Thread.sleep(10000);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
//            try {
//                Thread.sleep(10000);
//            } catch (InterruptedException ex) {
//                ex.printStackTrace();
//            }

            ContractChainService sourceUsdtInstance = ChainService.getInstance(ChainEnum.BSC_USDT.name());
            int decimals = sourceUsdtInstance.decimals();
            if (e.from.equals("0xaa25aa7a19f9c426e07dee59b12f944f4d9f1dd3")) {
            if (e.from.equals("0x0Ba249b2FAC0061dd9c388Bd607418E16490A3fd")) {
                return;
            }

            DappMemberEntity fromMember = dappMemberService.findByAddress(e.from, null);
            // 如果此时fromMember为null，则说明该用户未经过转账绑定关系，而是直接注册并购买币，则将关系绑定到顶级账户
            if (fromMember == null) {
                DappMemberEntity toAddress = dappMemberService.findByAddress(e.to, null);
                fromMember = dappMemberService.insertMember(e.from, toAddress.getInviteId());
            String fromAddress = e.from;
            DappMemberEntity fromMember = dappMemberDao.selectByAddress(fromAddress, null);
            if(ObjectUtil.isEmpty(fromMember)){
                return;
            }

            String hasStart = redisUtils.getString(AppContants.SYSTEM_START_FLAG);

            BigInteger tokens = e.tokens;
            BigDecimal amount = new BigDecimal(tokens.toString()).divide(BigDecimal.TEN.pow(decimals), decimals, RoundingMode.HALF_DOWN);

            DappFundFlowEntity fundFlow = dappFundFlowDao.selectByFromHash(e.log.getTransactionHash(), null);
            if (fundFlow != null && fundFlow.getStatus() != 1) {
                return;
            }
            DappFundFlowEntity fundFlow = dappFundFlowDao.selectByFromHashAndAndMemberId(e.log.getTransactionHash(), null,fromMember.getId());
            if(ObjectUtil.isNotEmpty(fundFlow) && 1 == fundFlow.getStatus()){
                if(18 == fundFlow.getType()){//认购贡献值 18
                    log.info("买入贡献值，{}，金额：{}",fromAddress,amount);
                    if (fundFlow == null) {
                        List<DappFundFlowEntity> flows = dappFundFlowDao.selectFundFlowListByAddress(e.from, 1);
                        if (CollUtil.isEmpty(flows)) {
                            OnlineTransferUtil.addTransferRecord(e.from, e.to, amount, e.log.getTransactionHash(), DappTransferRecordEntity.TRANSFER_SOURCE_FLAG_ONLINE, "USDT");
                            log.info("本地无交易:{}", e.log.getTransactionHash());
                            return;
                        }

            if (fundFlow == null) {
                List<DappFundFlowEntity> flows = dappFundFlowDao.selectFundFlowListByAddress(e.from, 1);
                if (CollUtil.isEmpty(flows)) {
                    OnlineTransferUtil.addTransferRecord(e.from, e.to, amount, e.log.getTransactionHash(), DappTransferRecordEntity.TRANSFER_SOURCE_FLAG_ONLINE, "USDT");
                    log.info("本地无交易:{}", e.log.getTransactionHash());
                    return;
                }

                boolean hasFlow = false;
                for (DappFundFlowEntity flow : flows) {
                    if (flow.getStatus() == 1) {
                        if (amount.compareTo(flow.getAmount().multiply(flow.getNewestPrice()).setScale(4, RoundingMode.HALF_UP)) == 0) {
                            hasFlow = true;
                            fundFlow = flow;
                            fundFlow.setFromHash(e.log.getTransactionHash());
                            break;
                        for (DappFundFlowEntity flow : flows) {
                            if (flow.getStatus() == 1) {
                                if (amount.compareTo(flow.getAmount().multiply(flow.getNewestPrice()).setScale(4, RoundingMode.HALF_UP)) == 0) {
                                    fundFlow = flow;
                                    fundFlow.setFromHash(e.log.getTransactionHash());
                                    break;
                                }
                            }
                        }
                    }
                }

                if (!hasFlow) {
                    OnlineTransferUtil.addTransferRecord(e.from, e.to, amount, e.log.getTransactionHash(), DappTransferRecordEntity.TRANSFER_SOURCE_FLAG_ONLINE, "USDT");
                    return;
                }
            }

            // 激活卡牌
            if (fundFlow.getType() == 8) {
                DappFundFlowEntity finalFundFlow = fundFlow;
                DappMemberEntity member = dappMemberService.getById(fundFlow.getMemberId());

                new Thread(() -> {
                    try {
                        int count = finalFundFlow.getAmount().intValue();
                        String token = null;
                        while (count > 0) {
                            token = ChainService.getInstance(ChainEnum.BSC_NFT_SDC.name()).safeMintNFT(member.getAddress());
                            Thread.sleep(5000);
                            count--;
                        }
                        finalFundFlow.setStatus(2);
                        finalFundFlow.setToHash(token);
                        dappFundFlowDao.updateById(finalFundFlow);
                    } catch (Exception ex) {
                        ex.printStackTrace();
                        log.error("发放卡牌错误", ex);
                    if (fundFlow == null) {
                        return;
                    }
                }).start();

                ChainService.getInstance(ChainEnum.BSC_TFC.name()).transfer(AppContants.DESTROY_ADDRESS, finalFundFlow.getTargetAmount());
//                    fundFlow.setAmount(fundFlow.getAmount().negate());
                    // 更改状态为已同步
                    fundFlow.setStatus(2);
                    dappFundFlowDao.updateById(fundFlow);
                    //激活用户
                    fromMember.setActiveStatus(1);
                    dappMemberDao.updateById(fromMember);
                    //给上级直推奖励
//                    DappMemberEntity member = dappMemberDao.selectById(fromMember.getId());
//                    DappMemberEntity parent = dappMemberDao.selectMemberInfoByInviteId(member.getRefererId());
//
//                    if (ObjectUtil.isNotEmpty(parent)) {
//                        BigDecimal directProfit = TreeConstants.PUT_IN_AMOUNT.multiply(new BigDecimal("0.1"));
//                        dappWalletService.updateWalletCoinWithLock(directProfit, parent.getId(), 1);
//
//                        DappFundFlowEntity fundFlowPerk = new DappFundFlowEntity(parent.getId(), directProfit, 3, 2, null, null);
//                        dappFundFlowDao.insert(fundFlowPerk);
//                    }
                    //复投
//                    chainProducer.sendAchieveTreeMsg(fundFlow.getMemberId());
                    chainProducer.sendNodeMsg(fundFlow.getId());
                    //发送推荐规则奖励
                    chainProducer.sendInvitePerkMsg(fundFlow.getId());
                    //发送节点投资
                    chainProducer.sendNodePerkMsg(fundFlow.getId());
//                    buyNodePerk(amount);

                }else if(13 == fundFlow.getType()){//认购节点 13

                    log.info("认购节点，{}，金额：{}",fromAddress,amount);
//                    fundFlow.setAmount(fundFlow.getAmount().negate());
                    // 更改状态为已同步
                    fundFlow.setStatus(2);
                    dappFundFlowDao.updateById(fundFlow);

                    Long memberId = fundFlow.getMemberId();
                    DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
                    Integer buyNode = dappMemberEntity.getBuyNode();
                    buyNode = buyNode + 1;
                    dappMemberEntity.setBuyNode(buyNode);
                    dappMemberDao.updateById(dappMemberEntity);
                }
            }else{
                return;
            }

            OnlineTransferUtil.addTransferRecord(e.from, e.to, amount, e.log.getTransactionHash(), DappTransferRecordEntity.TRANSFER_SOURCE_FLAG_APPLICATION, "USDT");


            // 这个方法主要是处理，tp钱包在调用transfer时，交易详情中的金额可能因为网速慢而显示晚，从而导致实际转账比记录中的少，顾做此处理
            BigDecimal realCoin = amount.divide(fundFlow.getNewestPrice(), decimals, RoundingMode.HALF_UP);
            if (fundFlow.getAmount().subtract(new BigDecimal("0.1")).compareTo(realCoin) > 0) {
                fundFlow.setAmount(realCoin);

                BigDecimal subtract = fundFlow.getAmount().subtract(realCoin);
                BigDecimal poolRemain = (BigDecimal) redisUtils.get(AppContants.REDIS_KEY_TRANSFER_POOL_VOL_REMAIN);
                redisUtils.set(AppContants.REDIS_KEY_TRANSFER_POOL_VOL_REMAIN, poolRemain.add(subtract));
            }

            // 更改状态为已同步
            fundFlow.setStatus(2);
            fundFlow.setTargetAmount(amount);
            dappFundFlowDao.updateById(fundFlow);

            // 如果系统会开启，则使用自动打款
            if (!"start".equals(hasStart)) {
                OnlineTransferUtil.addTransfer(e.from, fundFlow.getAmount(), 1, 1, ChainEnum.BSC_TFC.name(), "BSC", fundFlow.getId().toString());

                Map<String, String> map = new HashMap<>();
                map.put("batchNo", fundFlow.getId().toString());
                map.put("type", "flow");

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

                // 发送盲盒消息
                chainProducer.sendNftBoxMsg(fundFlow.getId());

                fromMember.setMakerType(1);
                dappMemberService.updateById(fromMember);
            } else {
                // 买入收手续费，到账币数量减去手续费
                OnlineTransferUtil.addTransfer(e.from, fundFlow.getAmount().subtract(fundFlow.getFee()), 1, 1, ChainEnum.BSC_TFC_SOURCE.name(), AppContants.SYMBOL_COIN, fundFlow.getId().toString());

                Map<String, String> map = new HashMap<>();
                map.put("batchNo", fundFlow.getId().toString());
                map.put("type", "flow");

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

                // 发送购买奖励消息
                chainProducer.sendUserBuyReward(fundFlow.getId());

                // 发送盲盒消息
                chainProducer.sendNftBoxMsg(fundFlow.getId());
            }
        }
    }

    public static void main(String[] args) {
        System.out.println(ChainService.getInstance(ChainEnum.BSC_USDT.name()).balanceOf("0x9DDE1834683D642D4D077498DC7fbdb8CF70E8FE"));
    public void buyNodePerk(BigDecimal amount){
        log.info("买入贡献值-平分总金额-{}",amount);
        /**
         * 获取节点平分百分比 perkPercent
         * 获取平分的份数 perKNum
         * 获取每一份的金额 perkAmount
         * 获取节点总数 buyNodeNum
         * 如果perKNum大于buyNodeNum，则每个人获得（amount * perkPercent）/ perKNum = perkAmount
         * 如果超出，再超出的人没有奖励
         */
        DataDictionaryCustom perkPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
                DataDictionaryEnum.PERK_PERCENT.getType(),
                DataDictionaryEnum.PERK_PERCENT.getCode()
        );
        BigDecimal perkPercent = new BigDecimal(ObjectUtil.isEmpty(perkPercentDic) ? "10" : perkPercentDic.getValue()).multiply(new BigDecimal("0.01"));

        DataDictionaryCustom perKNumDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
                DataDictionaryEnum.PERK_NUM.getType(),
                DataDictionaryEnum.PERK_NUM.getCode()
        );
        BigDecimal perKNum = new BigDecimal(ObjectUtil.isEmpty(perkPercentDic) ? "1000" : perKNumDic.getValue());

        BigDecimal perkAmount = amount.multiply(perkPercent).divide(perKNum, 8, BigDecimal.ROUND_DOWN);
        if(BigDecimal.ZERO.compareTo(perkAmount) >= 0){
            return;
        }

        QueryWrapper<DappMemberEntity> objectQueryWrapper = new QueryWrapper<>();
        objectQueryWrapper.eq("buy_node",1);
        List<DappMemberEntity> dappMemberEntities = dappMemberDao.selectList(objectQueryWrapper);
        if(CollUtil.isEmpty(dappMemberEntities)){
            return;
        }

        for(DappMemberEntity dappMemberEntity : dappMemberEntities){
            dappWalletService.updateWalletCoinWithLock(perkAmount, dappMemberEntity.getId(), 1);

            DappFundFlowEntity fundFlow = new DappFundFlowEntity(
                    dappMemberEntity.getId(),
                    perkAmount,
                    14,
                    2,
                    BigDecimal.ZERO,
                    null);
            dappFundFlowDao.insert(fundFlow);
        }

        log.info("买入贡献值-总人数{}，-每人金额{}",dappMemberEntities.size(),perkAmount);
    }
}