denet-node-server/model/server_data_statistics.js

const logger = require('../model/logger')
var remote_config_db = require("../model/db/remote_config_db");
var collect_coins_db = require("../model/db/collect_coins_db");
var withdraw_db = require("../model/db/withdraw_db");
var moralis = require("../model/moralis_sdk");
var utils = require("../model/utils");
const axios = require('axios');
var { account_config } = require('../config/config.js');
const { max } = require('moment');
//########################################### 出入金数据统计 ########################################

const http_request_get = async (data) => {
    var host = account_config.STATISTICS_URL
    var path = data
    var url = host + path
    logger.log('http_request_get', url)
    return new Promise(response => {
        axios.get(url)
            .then(res => {
                logger.log('res=>', res.status, res.data);
                if (res.data.code == 0) {
                    response(res.data)
                } else {
                    response({
                        code: 0,
                        msg: err.toString(),
                        data: {
                            canNotWithdrawUSD: '0',
                            canWithdrawUSD: '0',
                            incomeUSDTotal: '0',
                            incomeUSDFee: '0'
                        }
                    })
                }
            }).catch(err => {
                logger.error('http_request_get', err.toString(), url.toString());
                response({
                    code: -1,
                    msg: err.toString(),
                    data: {
                        canNotWithdrawUSD: '0',
                        canWithdrawUSD: '0',
                        incomeUSDTotal: '0',
                        incomeUSDFee: '0'
                    }
                })
            });
    })
}

function computeAddressPrice(total_in_coins) {
    //计算总的价格
    for (key of total_in_coins.keys()) {
        var item = total_in_coins.get(key)
        var amount = item.amount
        var usdPrice = item.usdPrice
        if (key == '0x0000000000000000000000000000000000000000') {
            item.totalUsdPrice = parseFloat(amount) / parseFloat(10 ** 18) * parseFloat(usdPrice)
        } else {
            var decimals = 18
            try {
                // decimals = await redis.readRedis('REDIS_ERC20_CONTRACT_DECIMALS_' + element.token_address.toLowerCase())
                decimals = await redis.readAppendRedis('REDIS_ERC20_CONTRACT_DECIMALS', item.chain, key.toLowerCase())
            } catch (error) {
                decimals = 18
            }
            item.totalUsdPrice = parseFloat(amount) / parseFloat(decimals) * parseFloat(usdPrice)
        }
    }
}



async function filterCollectCoinsLists(collect_ret, filterTypt) {
    const total_in_coins = new Map();
    var total_gas_fee = 0
    for (let index = 0; index < collect_ret.results.length; index++) {
        const element = collect_ret.results[index];
        if (element.chain == null || element.chain == filterTypt) {
            var before_gas_fee = element.before_gas_fee ? BigInt(element.before_gas_fee) : BigInt('0')
            total_gas_fee = BigInt(element.total_gas_fee) + BigInt(before_gas_fee) + BigInt(total_gas_fee)
            if (element.transfers) {
                var opts = JSON.parse(element.transfers)
                for (let index = 0; index < opts.length; index++) {
                    const transfers = opts[index];
                    var address = transfers.contractAddress ? transfers.contractAddress : '0x0000000000000000000000000000000000000000'
                    if (total_in_coins.get(address) != null) {
                        var ins = total_in_coins.get(address)
                        ins.amount = BigInt(ins.amount) + BigInt(transfers.amount)
                        total_in_coins.set(address, ins)
                    } else {
                        total_in_coins.set(address, {
                            amount: BigInt(transfers.amount), //总入金
                            usdPrice: transfers.usdPrice,
                            chain: transfers.chain,
                        })
                    }
                }
            }
        }
    }


    //计算总的价格
    computeAddressPrice(total_in_coins)

    //获取 total gas
    try {
        if (total_in_coins.size > 0) {
            switch (filterTypt) {
                case 'bsc_testnet':
                case 'bsc_mainnet':
                    var price = await moralis.getAllTotkenPrice({ chain: 'bsc_testnet' })
                    if (typeof price === 'string') {
                        price = JSON.parse(price)
                    }
                    var bnbPriceItem = moralis.findTokenPriceItem('0x0000000000000000000000000000000000000000', price)
                    total_gas_fee = parseFloat(total_gas_fee) / parseFloat(10 ** 18) * parseFloat(bnbPriceItem.usdPrice)
                    logger.info('new-total_gas_fee ', total_gas_fee, bnbPriceItem)
                    break
                case 'czz':
                    var price = await moralis.getAllTotkenPrice({ chain: 'czz' })
                    if (typeof price === 'string') {
                        price = JSON.parse(price)
                    }
                    var czzPriceItem = moralis.findTokenPriceItem('0x0000000000000000000000000000000000000000', price)
                    total_gas_fee = parseFloat(total_gas_fee) / parseFloat(10 ** 18) * parseFloat(czzPriceItem.usdPrice)
                    logger.info('new-total_gas_fee czz', total_gas_fee, czzPriceItem)
                    break
            }
        }
    } catch (error) {
        logger.error('total_gas_fee', error)
    }
    return {
        map: total_in_coins,
        totalGasFee: total_gas_fee //总入金所消耗的 gas fee
    }
}

async function getCollectCoinsOutInfo(startTime, endTime) {
    var collect_ret = await collect_coins_db.query_collect_total_fee(startTime, endTime);
    logger.info('getCollectCoinsOutInfo query_collect_total_fee', startTime, endTime, collect_ret)

    var bsc_env
    switch (process.env.NODE_ENV) {
        case 'dev':
        case 'test':
            bsc_env = 'bsc_testnet'
            break
        case 'prd':
            bsc_env = 'bsc_mainnet'
            break
        default:
            bsc_env = 'bsc_mainnet'
            break
    }

    var bsc_envnet = await filterCollectCoinsLists(collect_ret, bsc_env)
    logger.info('getCollectCoinsOutInfo bsc_env', bsc_env, bsc_envnet)
    var czz = await filterCollectCoinsLists(collect_ret, 'czz')
    logger.info('getCollectCoinsOutInfo czz', czz)

    logger.info('getCollectCoinsOutInfo total ', bsc_envnet.totalGasFee, czz.totalGasFee)
    return {
        bsc: bsc_envnet.map,
        czz: czz.map,
        totalGasFee: bsc_envnet.totalGasFee + czz.totalGasFee
    }
}

async function getWithdrawOutInfo(startTime, endTime) {
    if (startTime && endTime) {
        startTime = '1655049600000'
        endTime = '1655135999000'
    }
    var withdraw_ret = await withdraw_db.getWidthdrawTotalFee(startTime, endTime)
    const withdraw_map = new Map();
    for (let index = 0; index < withdraw_ret.length; index++) {
        const element = withdraw_ret[index];
        if (element.gas_price && element.gas_limit)
            var total_gas_fee2 = (BigInt(element.gas_price) * BigInt(element.gas_limit))
        if (withdraw_map.get(element.chain_id) != null) {
            var ins = withdraw_map.get(element.chain_id)
            withdraw_map.set(element.chain_id, BigInt(ins) + BigInt(total_gas_fee2))
        } else {
            withdraw_map.set(element.chain_id, BigInt(total_gas_fee2))
        }
    }


    var keys = withdraw_map.keys();
    var total_gas_fee = 0
    for (key of keys) {
        console.log(key, withdraw_map.get(key));  // map.get(key)可得value值。
        var value = withdraw_map.get(key)
        //获取币价
        try {
            if (key == 2019) {
                var price = await moralis.getAllTotkenPrice({ chain: 'czz' })
                if (typeof price === 'string') {
                    price = JSON.parse(price)
                }
                var czzPriceItem = moralis.findTokenPriceItem('0x0000000000000000000000000000000000000000', price)
                total_gas_fee += parseFloat(value) / parseFloat(10 ** 18) * parseFloat(czzPriceItem.usdPrice)
                logger.info('new-total_gas_fee czz', total_gas_fee, czzPriceItem)
            } else {
                var price = await moralis.getAllTotkenPrice({ chain: 'bsc_testnet' })
                if (typeof price === 'string') {
                    price = JSON.parse(price)
                }
                var bnbPriceItem = moralis.findTokenPriceItem('0x0000000000000000000000000000000000000000', price)
                total_gas_fee += parseFloat(value) / parseFloat(10 ** 18) * parseFloat(bnbPriceItem.usdPrice)
                logger.info('new-total_gas_fee bsc', total_gas_fee, bnbPriceItem)
            }
        } catch (error) {
            logger.error('total_gas_fee', error)
        }

    }
    return {
        totalGasFee: total_gas_fee
    };
}

/**
 * 获取时间段总支出的 gas fee
 * @param {*} startTime 
 * @param {*} endTime 
 */
async function getStatisticsInfo() {
    // //今日
    var startTime = utils.getLastDay('YYYY-MM-DD') + " 00:00:00"
    var endTime = utils.getLastDay('YYYY-MM-DD') + " 23:59:59"
    logger.info('getTotalOutGasFee', startTime, endTime)
    //归集
    var collectCoinsOut = await getCollectCoinsOutInfo(startTime, endTime)
    logger.info('getCollectCoinsOutInfo  collectCoinsOut', collectCoinsOut)
    //提币
    var withdrawOut = await getWithdrawOutInfo(startTime, endTime)
    logger.info('getWithdrawOutInfo withdrawOut ', withdrawOut)

    var data = await http_request_get(utils.getLastDay('YYYYMMDD'))

    //历史，总的
    //归集
    var totalCollectCoinsOut = await getCollectCoinsOutInfo(null, null)
    logger.info('totalCollectCoinsOut  ', totalCollectCoinsOut)
    //提币
    var totalWithdrawOut = await getWithdrawOutInfo(null, null)
    logger.info('totalWithdrawOut  ', totalWithdrawOut)

    return {
        todayTotalOutGasFee: collectCoinsOut.totalGasFee + withdrawOut.totalGasFee,             //今日总支出的 gas fee
        todayCanNotWithdrawUSD: data.data.canNotWithdrawUSD,                                    //今日不可提现余额
        todayCanWithdrawUSD: data.data.canWithdrawUSD,                                          //今日可提现余额
        todayIncomeUSDTotal: data.data.incomeUSDTotal,                              //今日总收入
        todayIncomeUSDFee: data.data.incomeUSDFee,                                  //今日固定收入
        totalOutGasFee: totalCollectCoinsOut.totalGasFee + totalWithdrawOut.totalGasFee,                                                          //总支出 gas fee
        totalWithdrawGasFee: totalWithdrawOut.totalGasFee,                                                     //总提币 gas fee
        totalCollectCoinsGasFee: totalCollectCoinsOut.totalGasFee,                                                 //总归集 gas fee
        totalInFee: 0,                                                              //总入金
        totalOutFee: 0,                                                             //总出金
        totalbalances: null,                                                        //总余额
        ylGasBalance: 0,                                                            //预留 gas 费余额  native 总余额 - 总入金
        slGasBalance: 0,                                                            //散落 gas 费余额  充值 0.5 gas - 使用 0.3 gas= 散落 0.2gas
    }
}
module.exports = {
    getStatisticsInfo
}