denet-node-server/model/utils.js

'use strict'
var CryptoJS = require("crypto-js");
require('dotenv').config()
const logger = require('./logger')
const chinaTime = require('china-time');

var { cryppt_config } = require('../config/config.js')
const moment = require('moment-timezone');

function toJson(code_, obj_, errMsg_) {
    var code = code_
    var data = obj_
    var errMsg = errMsg_
    let jopt = { code, data, errMsg };
    return JSON.stringify(jopt)
}

function decryptJson(message, key) {

}

/**
 * 
 * @param {*} crypt_key 密文
 * @param {*} message 待解密的内容 U2FsdGVkX18zHfDE3lO2yVxk2lMCEiwjrzYo1ZbHqfriFapZWXqLhczs9J0cN9EnvQR64GLRzYDgzMuAr9U1C0LZjA5mV4cSAZeBOrY8KNY09+BhTDetb2/43bIwiFR6
 */
function decryptPrivityKey(message) {

    // var encrypted = 'Zc4v3uJgPY+BVg/IrDLA4aIk9ko/UrgjAtBTLqymdMAvmqdp1GttRjkBgNNNTyxA+3ThbIGlM0INeeHGicYVbLea4ymkty8gd30rZXQ4yYQ='; //python is base64 ECB
    // var key = '0IPmaec1o9FQCqGN'//key used in Python
    // var iv = 'Zh4A7bOY2ksp9oIn'

    var encrypted = message; //python is base64 ECB
    var key = process.env.DENET_CRYPT_KEY
    var iv = process.env.DENET_CRYPT_IV
    if (!key || !iv) {
        logger.error('decryptPrivityKey key or iv is empty?');
        return null;
    }
    logger.log('encrypted=', encrypted);
    // logger.log('decryptPrivityKey key= iv=', key, iv);

    key = CryptoJS.enc.Utf8.parse(key);
    // var decrypted =  CryptoJS.AES.decrypt(encrypted, key, {mode:CryptoJS.mode.ECB});
    iv = CryptoJS.enc.Utf8.parse(iv)
    var decrypted = CryptoJS.AES.decrypt(encrypted, key, { iv: iv, mode: CryptoJS.mode.CBC });
    var de_pk = decrypted.toString(CryptoJS.enc.Utf8);
    // logger.log('decrypted==', de_pk);
    return de_pk
}

// console.log('decryptPrivityKey 1',decryptPrivityKey('8C9oepm9euh9UwPfqVf0QaP5qUjZsghT/rRlM3I1NemLACM8N4yx0wHgHnH5sZGM/ai5yg1MJnJMbfmApss/y5Chq8Ys+mZjIVrru2IWl/I='))
// console.log('decryptPrivityKey 2',decryptPrivityKey('4Uz4Jm7Xd1gH+1nFbR0B7hk1ITmsT8O3iAgS/hC0L9TkrqAZoklsQhXl4fA1X+uqpckF4HtnXnMpwng94GvvzsRfXYirfDfboneuzfc0o7s='))
// console.log('decryptPrivityKey 3',decryptPrivityKey('mNSzG6qmijKGldl4EJ9qViv4L5nWjkxR66Xd6E31OS3wiYY55aCfL8w0eYM3GC8bkNTFpQf'))
// 密钥
const SECRET_KEY = CryptoJS.enc.Utf8.parse(cryppt_config.WITHDRAW_KEY);
// 密钥偏移量
const SECRET_IV = CryptoJS.enc.Utf8.parse("68F37CFC40C330D9FAAC0A16D49C8AD5");
/**
 * 加密方法
 * @param data
 * @returns {string}
 */
function encrypt(data) {
    if (typeof data === "object") {
        try {
            data = JSON.stringify(data);
        } catch (error) {
            console.log("encrypt error:", error);
        }
    }
    const dataHex = CryptoJS.enc.Utf8.parse(data);
    const encrypted = CryptoJS.AES.encrypt(dataHex, SECRET_KEY, {
        mode: CryptoJS.mode.ECB,
        padding: CryptoJS.pad.Pkcs7
    });
    return encrypted.ciphertext.toString();
}

/**
 * 解密方法
 * @param data
 * @returns {string}
 */
function decrypt(data) {
    // const key = CryptoJS.enc.Hex.parse(SECRET_KEY);
    const decrypt = CryptoJS.AES.decrypt(data, SECRET_KEY, {
        mode: CryptoJS.mode.ECB,
        padding: CryptoJS.pad.Pkcs7
    });
    return CryptoJS.enc.Utf8.stringify(decrypt).toString();
}

const CHAIN_NAME = {
    eth: 'eth',
    bsc_testnet: 'bsc testnet',
    bsc_mainnet: 'bsc',
    czz: 'czz',
    kcc_testnet: 'kcc_testnet',
    kcc_mainnet: 'kcc_mainnet',
    okc_testnet: 'okc_testnet',
    okc_mainnet: 'okc_mainnet',
}

const CHAIN_TOKEN_TYPE = {
    bsc_testnet: 'erc20',
    bsc_mainnet: 'erc20',
    czz: 'czz',
    kcc_testnet: 'kcc_testnet',
    kcc_mainnet: 'kcc_mainnet',
    okc_testnet: 'okc_testnet',
    okc_mainnet: 'okc_mainnet',
}

const CHAIN_ID = {
    eth: '0x1',
    bsc_testnet: '0x61',
    bsc_mainnet: '0x38',
    czz: '2019',
    kcc_testnet: '322',
    kcc_mainnet: '321',
    okc_testnet: '65',
    okc_mainnet: '66',
}

const CHAIN_ID_NAME = {
    97: 'bsc_testnet',
    56: 'bsc_mainnet',
    2019: 'czz',
    65: 'okc',
    66: 'okc',
    321: 'kcc',
    322: 'kcc',
}

const USE_SDK = {
    MORALIS: 'moralis',
    DENET: 'denet',
}

function getRedisKeyFromChain(chain) {
    switch (chain) {
        case CHAIN_NAME.bsc_mainnet:
        case CHAIN_NAME.bsc_testnet:
        case 'bsc_testnet':
        case 'bsc_mainnet':
        case '97':
        case '56':
            return '_BSC'
        case CHAIN_NAME.czz:
        case CHAIN_ID.czz:
            return '_CZZ'
        case CHAIN_NAME.kcc_mainnet:
        case CHAIN_NAME.kcc_testnet:
        case CHAIN_ID.kcc_mainnet:
        case CHAIN_ID.kcc_testnet:
        case 'kcc':
            return '_KCC'
        case CHAIN_NAME.okc_mainnet:
        case CHAIN_NAME.okc_testnet:
        case CHAIN_ID.okc_mainnet:
        case CHAIN_ID.okc_testnet:
        case 'okc':
            return '_OKC'
        default:
            return '_' + chain.toUpperCase()
    }
}

function getChainNameFromChain(chain) {
    logger.info('getChainNameFromChain', chain)
    switch (chain) {
        case CHAIN_NAME.bsc_mainnet:
        case CHAIN_NAME.bsc_testnet:
        case 'bsc_testnet':
        case 'bsc_mainnet':
        case '97':
        case '56':
            return 'bsc'
        case CHAIN_NAME.czz:
        case CHAIN_ID.czz:
            return 'czz'
        case CHAIN_NAME.kcc_mainnet:
        case CHAIN_NAME.kcc_testnet:
        case CHAIN_ID.kcc_mainnet:
        case CHAIN_ID.kcc_testnet:
            return 'kcc'
        case CHAIN_NAME.okc_mainnet:
        case CHAIN_NAME.okc_testnet:
        case CHAIN_ID.okc_mainnet:
        case CHAIN_ID.okc_testnet:
            return 'okc'
        default:
            return null
    }
}

function getTokenTransferType(chain) {
    switch (chain) {
        case CHAIN_NAME.bsc_mainnet:
        case CHAIN_NAME.bsc_testnet:
        case 'bsc_testnet':
        case 'bsc_mainnet':
        case '97':
        case '56':
            return 'erc20'
        default:
            return 'token'
    }
}

function trim(str) {
    try {
        return str.replace(/(^\s*)|(\s*$)/g, "");
    } catch (error) {
        logger.error('trim error', error.toString())
        return str
    }
}

function getChainName(key) {
    return CHAIN_NAME[key];
}


function getChainIdToName(key) {
    return CHAIN_ID_NAME[key];
}

function getChainId(key) {
    return CHAIN_ID[key];
}

function sleep(time) {
    return new Promise((resolve) => setTimeout(resolve, time));
}

function getTimestamp() {
    return new Date().getTime()
}

function contain(str, char) {
    try {
        return str.indexOf(char) != -1
    } catch (error) {
        logger.error()
        return false
    }
}


function getCurrentDate() {
    return chinaTime('YYYY-MM-DD HH:mm:ss');
}

function getCurrentDateFormat(format) {
    return chinaTime(format);
}

function chinaTimeMs(ms) {
    return moment(ms).tz('Asia/Shanghai').format('YYYY-MM-DD HH:mm:ss');
}

function getLastDay(day, format) {
    return day ?
        moment().subtract(day, 'day').tz('Asia/Shanghai').format(format) :
        moment().subtract(1, 'day').tz('Asia/Shanghai').format(format)
}

function getTimestampToDate(tm) {
    var now = new Date(tm),
        y = now.getFullYear(),
        m = now.getMonth() + 1,
        d = now.getDate();
    return y + '-' + (m < 10 ? '0' + m : m) + '-' + (d < 10 ? '0' + d : d) + 'T' + now.toTimeString().substr(0, 8) + '.000Z';
}

/**
 * @description 科学计数法转为string
 * @param {string, number} param
 */
function scientificNotationToString(param) {
    try {
        let strParam = String(param)
        let flag = /e/.test(strParam)
        if (!flag) return param

        // 指数符号 true: 正，false: 负
        let sysbol = true
        if (/e-/.test(strParam)) {
            sysbol = false
        }
        // 指数
        let index = Number(strParam.match(/\d+$/)[0])
            // 基数
        let basis = strParam.match(/^[\d\.]+/)[0].replace(/\./, '')

        if (sysbol) {
            return basis.padEnd(index + 1, 0)
        } else {
            return basis.padStart(index + basis.length, 0).replace(/^0/, '0.')
        }
    } catch (error) {
        return param.toString()
    }
}

module.exports = {
    toJson,
    decryptPrivityKey,
    getChainName,
    getChainId,
    CHAIN_NAME,
    CHAIN_ID,
    USE_SDK,
    sleep,
    encrypt,
    decrypt,
    getTimestamp,
    getChainIdToName,
    getCurrentDate,
    getCurrentDateFormat,
    scientificNotationToString,
    getTimestampToDate,
    getRedisKeyFromChain,
    trim,
    getLastDay,
    chinaTimeMs,
    contain,
    getTokenTransferType,
    getChainNameFromChain,
}