jsir 1.2.9 → 1.3.1

package/ethWeb.js

@@ -1,1241 +0,0 @@
-let {BigNumber, getLibDataDir, trim, toBigNum, getConfig, objDataFile, infoStr, errorStr, batchAsync,
-    eFn, removeFirst, randomInt, splitArray, sleep, vl, cacheFn, isError, bMin, getOr, errorStack} = require('./util')
-const abiDecoder = require('abi-decoder');
-let fs = require('fs')
-let contractMapPath = getLibDataDir() + "/contractMap.json"
-let erc20Abi = require('./source/erc20Abi')
-let createKeccakHash = require('keccak')
-let tokenMapCache = {}
-const util = require('ethereumjs-util')
-const Tx = require('ethereumjs-tx');
-const ethers = require("ethers")
-let { Interface } = require('@ethersproject/abi')
-const batchCallAbi = [{"inputs":[{"internalType":"bool","name":"atom","type":"bool"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct main.Call[]","name":"calls","type":"tuple[]"}],"name":"aggregate","outputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"},{"internalType":"bytes[]","name":"returnData","type":"bytes[]"},{"internalType":"bool[]","name":"results","type":"bool[]"}],"stateMutability":"nonpayable","type":"function"}]
-let Web3Contract = require('web3-eth-contract');
-
-let batchCallAddressMap = {
-    1: '0xf375451681f567bEB7AeAD101F7944C2574718Eb',
-    128: '0x0817dC05EAb0A0C8aDBafDbE35883B5e5DD8a299',
-    137: '0xa36e94d707ff68629F01f0886c4d790459b90fB4',
-    66: '0x5a8138bF21BdCf8424A999069F24f6F7A065F6A0',
-    56: '0x3C23d715f13797CDF93E54a054ACa2d3A98DD18C',
-    250: '0x8D334d8fd2da9D610Ec69eef7a44fA6a2AcE1fD9',
-    1313161554: '0x4633F95925951F856544DD7ADaE262Bb487c3422'
-}
-
-async function _ethBatchQuery(calls = [], web3) {
-    web3 = web3 || global.web3;
-    let chainId = global.chainId || await web3.eth.getChainId()
-    let batchCallAddress = batchCallAddressMap[chainId]
-    if (!batchCallAddress) {
-        throw 'batchCallAddress not found on chainId ' + chainId
-    }
-    if (calls.length === 0) {
-        return []
-    }
-    const itfs = calls.map(call => newAbiInterface(call.abi))
-    const calldata = calls.map((call, i) => [call.address.toLowerCase(), itfs[i].encodeFunctionData(call.name || call.method, call.params || call.args || [])])
-    const { returnData } = await newContract(web3, batchCallAbi, batchCallAddress).methods.aggregate(false, calldata).call()
-    let pros = []
-    for(let i = 0; i<returnData.length; i++) {
-        let data = returnData[i]
-        let result
-        let error
-        try {
-            result = itfs[i].decodeFunctionResult(calls[i].name || calls[i].method, data)
-        } catch (e) {
-            $log(new Error(errorStack(e)).stack)
-            error = e
-        }
-        pros.push(new Promise(async resolve => {
-            if (calls[i].callback) {
-                try {
-                    await calls[i].callback(error, result)
-                } catch (e) {
-                    $log(new Error(errorStack(e)).stack)
-                    resolve(result || error);
-                    throw e
-                }
-            }
-            resolve(result || error);
-        }))
-    }
-    return await Promise.all(pros);
-}
-
-async function ethBatchQuery(calls = [], web3, batchNum = 49, asyncNum = 33, useWebReq = false) {
-    web3 = web3 || global.web3;
-    let chainId = global.chainId || await web3.eth.getChainId()
-    if (batchCallAddressMap[chainId] && !useWebReq) {
-        return await ethBatchQuery_(calls, web3, batchNum, asyncNum)
-    } else {
-        let transResult = result => {
-            if (!result) {
-                return [null]
-            }
-            if (result.constructor.name !== 'Result') {
-                return [result]
-            } else {
-                let temp = []
-                for (let key of Object.keys(result)) {
-                    if (/^\d+$/.test(key)) {
-                        temp.push(result[key])
-                    } else {
-                        temp[key] = result[key]
-                    }
-                }
-                return temp;
-            }
-        }
-        let newCalls = []
-        for (let call of calls) {
-            let item = {
-                method: newContract(web3, call.abi, call.address)
-                    .methods[call.name || call.method](...(call.args || call.params || []))
-                    .call
-            }
-            if (call.callback) {
-                item.callback = async (error, result) => {
-                    await call.callback(error, transResult(result))
-                }
-            }
-            newCalls.push(item)
-        }
-        let results = await web3BatchReq(newCalls, batchNum, asyncNum, web3)
-        let newResults = []
-        for (let result of results) {
-            if (isError(result)) {
-                newResults.push(result)
-                continue
-            }
-            newResults.push(transResult(result))
-        }
-        return newResults
-    }
-}
-
-async function ethBatchQuery_(calls = [], web3, batchNum, asyncNum) {
-    if (calls.length <= 0) {
-        return []
-    }
-    if (batchNum) {
-        let callBatchs = splitArray(calls, batchNum)
-        return (await batchAsync(callBatchs.map(item => () => _ethBatchQuery(item, web3)), asyncNum))
-            .reduce((a,b) => a.concat(b))
-    }
-    return _ethBatchQuery(calls, web3)
-}
-
-// avoid memory leak
-function newAbiInterface(abi) {
-    if (!global.$abiInterfaces) {
-        global.$abiInterfaces = {}
-    }
-    let key = JSON.stringify(abi)
-    if (!global.$abiInterfaces[key]) {
-        global.$abiInterfaces[key] = new Interface(abi)
-    }
-
-    return global.$abiInterfaces[key]
-}
-
-function initRootWallet(mnemonic) {
-    let wallets = {}
-    return {
-        getWallet(i) {
-            i = String(i)
-            if (!wallets[i]) {
-                if (/^\d+$/.test(i)) {
-                    wallets[i] = ethers.Wallet.fromMnemonic(mnemonic, `m/44\'/60\'/0\'/0/${i}`)
-                } else {
-                    wallets[i] = new ethers.Wallet(i);
-                }
-            }
-            return wallets[i]
-        },
-        getAddress(i){
-            return this.getWallet(i).address
-        },
-        getPrivateKey(i){
-            return this.getWallet(i).privateKey
-        }
-    }
-}
-
-async function erc20Query(address, method, ...args) {
-    try {
-        const contract = newContract(web3, erc20Abi, address);
-        return await contract.methods[method](...args).call()
-    } catch (e) {
-        $log(new Error(errorStack(e)).stack)
-        return null;
-    }
-}
-
-async function initSender(web3, wallet, froms, resetNum) {
-    let senderQueue = {}
-    let senderBlock = {}
-    let senderNonce = {}
-    let senderResetNum = Number(resetNum)
-
-    for(let aIndex of froms) {
-        senderNonce[aIndex] = Number(await web3.eth.getTransactionCount(walletGet(wallet, aIndex).address)) -1
-    }
-
-    let sender = async (txObject) => {
-        let aIndex = froms[randomInt(froms.length) - 1]
-        let adInfo = walletGet(wallet, aIndex)
-
-        if (!(txObject.gasLimit || txObject.gas)) {
-            try {
-                let gas = await web3.eth.estimateGas({
-                    from: adInfo.address,
-                    to: txObject.to,
-                    value: txObject.value,
-                    data: txObject.data
-                })
-                txObject.gasLimit = gas + 10000;
-            } catch (e) {
-                return [Promise.reject(e), {}, aIndex]
-            }
-        }
-
-        if (senderBlock[aIndex]) {
-            return []
-        }
-
-        if (!senderQueue[aIndex]) {
-            senderQueue[aIndex] = []
-        }
-        senderNonce[aIndex] ++
-        txObject.nonce = senderNonce[aIndex]
-        let signedTx = txnSign(txObject, adInfo.privateKey)
-
-        let result = web3.eth.sendSignedTransaction(signedTx.rawTransaction).then(resp => {
-            removeFirst(senderQueue[aIndex], result)
-            return Promise.resolve(resp)
-        }).catch(e => {
-            removeFirst(senderQueue[aIndex], result)
-            return Promise.reject(e)
-        })
-        senderQueue[aIndex].push(result)
-
-        let nonce = senderNonce[aIndex]
-        if (nonce > 0 && senderResetNum > 0 && nonce%senderResetNum === 0) {
-            senderBlock[aIndex] = true
-            let queueFin = async () => {
-                try {
-                    senderNonce[aIndex] = Number(await web3.eth.getTransactionCount(adInfo.address)) -1
-                } catch (e) {}
-                senderBlock[aIndex] = false
-            }
-            Promise.all(senderQueue[aIndex]).then(queueFin).catch(queueFin)
-        }
-        return [result, signedTx, aIndex]
-    }
-    sender.web3 = web3
-    return sender
-}
-
-async function initSenderWithKeys(web3, privateKeys, resetNum) {
-    let senderQueue = {}
-    let senderBlock = {}
-    let senderNonce = {}
-    let senderResetNum = Number(resetNum)
-
-    let keyMap = {}
-    for(let key of privateKeys) {
-        let adds = privateToAddress(key)
-        senderNonce[adds] = Number(await web3.eth.getTransactionCount(adds)) -1
-        keyMap[key] = adds
-    }
-
-    let sender = async (txObject) => {
-        let key = privateKeys[randomInt(privateKeys.length) - 1]
-        let adds = keyMap[key]
-
-        if (!(txObject.gasLimit || txObject.gas)) {
-            try {
-                let gas = await web3.eth.estimateGas({
-                    from: adds,
-                    to: txObject.to,
-                    value: txObject.value,
-                    data: txObject.data
-                })
-                txObject.gasLimit = gas + 10000;
-            } catch (e) {
-                return [Promise.reject(e), {}, adds]
-            }
-        }
-
-        if (senderBlock[adds]) {
-            return []
-        }
-
-        if (!senderQueue[adds]) {
-            senderQueue[adds] = []
-        }
-        senderNonce[adds] ++
-        txObject.nonce = senderNonce[adds]
-        let signedTx = txnSign(txObject, key)
-
-        let result = web3.eth.sendSignedTransaction(signedTx.rawTransaction).then(resp => {
-            removeFirst(senderQueue[adds], result)
-            return Promise.resolve(resp)
-        }).catch(e => {
-            removeFirst(senderQueue[adds], result)
-            return Promise.reject(e)
-        })
-        senderQueue[adds].push(result)
-
-        let nonce = senderNonce[adds]
-        if (nonce > 0 && senderResetNum > 0 && nonce%senderResetNum === 0) {
-            senderBlock[adds] = true
-            let queueFin = async () => {
-                try {
-                    senderNonce[adds] = Number(await web3.eth.getTransactionCount(adds)) - 1
-                } catch (e) {}
-                senderBlock[adds] = false
-            }
-            Promise.all(senderQueue[adds]).then(queueFin).catch(queueFin)
-        }
-        return [result, signedTx, adds]
-    }
-    sender.web3 = web3
-    return sender
-}
-
-function privateToAddress(privateKey) {
-    return util.bufferToHex(util.privateToAddress(util.toBuffer('0x' + privateKey.replace(/^0x/, ''))))
-}
-
-function txnSign(txObject, privateKey) {
-    let params = {
-        nonce: web3.utils.toHex(txObject.nonce),
-        gasPrice: web3.utils.toHex(txObject.gasPrice),
-        gasLimit: web3.utils.toHex(txObject.gasLimit || txObject.gas),
-        to: txObject.to,
-        value: web3.utils.toHex(txObject.value),
-        data: txObject.data
-    }
-    if (global.chainId) {
-        params.chainId = web3.utils.toHex(global.chainId)
-    }
-    let tx = new Tx(params);
-    tx.sign(util.toBuffer(privateKey));
-    let serializedTx = tx.serialize();
-
-    let transactionHash = "0x" + tx.hash().toString("hex")
-    let rawTransaction = '0x' + serializedTx.toString('hex')
-    return {
-        transactionHash,
-        rawTransaction,
-        hash: transactionHash,
-        raw: rawTransaction
-    }
-}
-
-function walletGet(wallet, i) {
-    i = Number(i)
-    return {
-        address: wallet.getAddress(i),
-        privateKey: wallet.getPrivateKey(i),
-    }
-}
-
-async function sendTxn(privateKey, toAddress, value, contract, method, ...args) {
-    let ADDRESS = util.bufferToHex(util.privateToAddress(util.toBuffer('0x' + privateKey.replace(/^0x/, ''))))
-    let signTxn = await web3.eth.accounts.signTransaction({
-        from: ADDRESS,
-        to: toAddress,
-        value,
-        gas: 1000000,
-        gasPrice: Number(await web3.eth.getGasPrice()) + (Number(getConfig("gasAddGwei") || 0) * 1000 * 1000 * 1000),
-        data: contract.methods[method](...args).encodeABI()
-    }, privateKey)
-
-    console.log(`begin send txn ${signTxn.transactionHash}`)
-    try {
-        await web3.eth.sendSignedTransaction(signTxn.rawTransaction)
-        console.info(`发送成功：${signTxn.transactionHash}`)
-    } catch (e) {
-        console.error(`发送失败：${signTxn.transactionHash}`)
-        console.log(String(e))
-    }
-}
-
-async function gasPrice() {
-    return web3.utils.fromWei(await web3.eth.getGasPrice(), 'gwei')
-}
-
-// avoid memory leak
-function newContract(web3, abi, address) {
-    if (!global.$contracts) {
-        global.$contracts = {}
-    }
-    if (address) {
-        address = address.toLowerCase()
-    }
-    let key = [String(chainId), JSON.stringify(abi), address].filter(i => i).join("-")
-
-    if (!global.$contracts[key]) {
-        global.$contracts[key] = new web3.eth.Contract(abi, address);
-    }
-
-    return global.$contracts[key]
-}
-
-// avoid memory leak
-function newWeb3Contract(abi, address) {
-    if (!global.$web3Contracts) {
-        global.$web3Contracts = {}
-    }
-    if (address) {
-        address = address.toLowerCase()
-    }
-    let key = [JSON.stringify(abi), address].filter(i => i).join("-")
-
-    if (!global.$web3Contracts[key]) {
-        global.$web3Contracts[key] = new Web3Contract(abi, address);
-    }
-
-    return global.$web3Contracts[key]
-}
-
-async function tokenMap(address, web3) {
-    if (!address) {
-        return {name: '本币', decimals: 18, symbol: '本币'}
-    }
-    address = '0x' + address.toLowerCase().replace(/^0x/, '')
-    let chainMap = await getTokenMap([address], web3)
-
-    if (chainMap[address]) {
-        let decimals = chainMap[address].decimals
-        if (Number.isNaN(Number(String(decimals)))) {
-            throw new Error(`invalid token decimals ${address} ${decimals}`)
-        }
-    }
-
-    return chainMap[address]
-}
-
-async function getLastBlockSecTime() {
-    let blockNum = await web3.eth.getBlockNumber();
-    let blockInfo = await web3.eth.getBlock(blockNum)
-    return blockInfo.timestamp
-}
-
-async function getPrice(token0Addr, token1Addr, factory, web3) {
-    web3 = web3 || global.web3;
-    return await getPriceByAmt(token0Addr, token1Addr, 1, factory, web3)
-}
-
-async function getPriceNoFee(token0Addr, token1Addr, factory, web3) {
-    web3 = web3 || global.web3;
-    return await getPriceByAmtNoFee(token0Addr, token1Addr, 1, factory, web3)
-}
-
-//返回买入baseAmt个a所需要的b数
-//包含千三手续费
-async function getPriceByAmt(token0Addr, token1Addr, token0Amt, factory, web3) {
-    web3 = web3 || global.web3;
-    token0Amt = toBigNum(token0Amt)
-    let result = await getPoolAmt(token0Addr, token1Addr, factory, web3)
-    return getPairAmt(result[0], result[1], token0Amt)
-}
-
-//返回买入baseAmt个a所需要的b数
-//不包含千三手续费
-async function getPriceByAmtNoFee(token0Addr, token1Addr, token0Amt, factory, web3) {
-    web3 = web3 || global.web3;
-    token0Amt = toBigNum(token0Amt)
-    let result = await getPoolAmt(token0Addr, token1Addr, factory, web3)
-    return getPairAmtNoFee(result[0], result[1], token0Amt)
-}
-
-// 获得池子中两种币的数量
-async function getPoolAmt(token0Addr, token1Addr, factory, web3) {
-    web3 = web3 || global.web3;
-    let tokenOInfo = await tokenMap(token0Addr, web3)
-    let token1Info = await tokenMap(token1Addr, web3)
-
-    let pair = await ethQuery1(web3, factory, require('./source/uniFact'), 'getPair', token0Addr, token1Addr)
-    if (!pair) {
-        return null;
-    }
-    let pairToken0 = await ethQuery1(web3, pair, require('./source/uniPair'), "token0")
-
-    let result = await ethQuery1(web3, pair, require('./source/uniPair'), "getReserves")
-
-    let num0;
-    let num1;
-    if (pairToken0.toLowerCase() === token0Addr.toLowerCase()) {
-        num0 = exDcmNum(result[0], -parseInt(tokenOInfo['decimals']))
-        num1 = exDcmNum(result[1], -parseInt(token1Info['decimals']))
-    } else {
-        num1 = exDcmNum(result[0], -parseInt(token1Info['decimals']))
-        num0= exDcmNum(result[1], -parseInt(tokenOInfo['decimals']))
-    }
-
-    return [num0, num1]
-}
-
-//返回买入baseAmt个a所需要的b数
-//包含千三手续费
-function getPairAmt(a, b, baseAmt) {
-    return toBigNum(getPairAmtNoFee(a,b,baseAmt)).abs().multipliedBy(Number(baseAmt) > 0 ? 1.003:0.997).toFixed(9).toString()
-}
-
-//返回买入baseAmt个a所需要的b数
-//不包含千三手续费
-function getPairAmtNoFee(a, b, baseAmt) {
-    a = toBigNum(String(a))
-    b = toBigNum(String(b))
-    baseAmt = toBigNum(String(baseAmt))
-    let out = a.multipliedBy(b).dividedBy(a.minus(baseAmt)).minus(b)
-
-    if (a.minus(baseAmt).comparedTo(0) < 0 || b.plus(out).comparedTo(0) < 0) {
-        throw "exceed pool"
-    }
-
-    return out.abs().toFixed(9).toString()
-}
-
-let tokenMapLoaded = {}
-let tokenMapLoadSize = {}
-async function saveTokenMap(web3) {
-    web3 = web3 || global.web3;
-    let chainId = global.chainId || await web3.getChainId()
-    let chainMap = getOr(tokenMapCache, chainId, {})
-    let tokenMapFile = `tokenMap_${chainId}`
-    if (!tokenMapLoaded[chainId]) {
-        let temp = objDataFile(tokenMapFile)
-        tokenMapLoadSize[chainId] = Object.keys(temp).length
-        Object.assign(chainMap, temp)
-        tokenMapLoaded[chainId] = true
-    }
-    if (Object.keys(chainMap).length > tokenMapLoadSize[chainId]) {
-        await objDataFile(tokenMapFile, () => chainMap);
-    }
-}
-async function getTokenMap(tokens, web3, batchNum, asyncNum) {
-    web3 = web3 || global.web3;
-    let chainId = global.chainId || await web3.getChainId()
-    let chainMap = getOr(tokenMapCache, chainId, {})
-    if (!tokenMapLoaded[chainId]) {
-        let tokenMapFile = `tokenMap_${chainId}`
-        let temp = objDataFile(tokenMapFile)
-        tokenMapLoadSize[chainId] = Object.keys(temp).length
-        Object.assign(chainMap, temp)
-        tokenMapLoaded[chainId] = true
-    }
-
-    tokens = tokens || []
-    tokens = tokens.map(token => '0x' + token.toLowerCase().replace(/^0x/, ''))
-    tokens = [...new Set(tokens)]
-    tokens = tokens.filter(token => !chainMap[token])
-    if (tokens.length <= 0) {
-        return chainMap
-    }
-    let calls = []
-    for (let token of tokens) {
-        calls.push({
-            abi: erc20Abi,
-            address: token,
-            name: 'name'
-        })
-        calls.push({
-            abi: erc20Abi,
-            address: token,
-            name: 'symbol'
-        })
-        calls.push({
-            abi: erc20Abi,
-            address: token,
-            name: 'decimals'
-        })
-    }
-    let results = await ethBatchQuery(calls, web3, batchNum, asyncNum)
-    for(let i = 0; i<results.length; i+=3) {
-        let token = calls[i].address
-        try {
-            if (isError(results[i]) || isError(results[i + 1]) || isError(results[i + 2])) {
-                $log(`${token} erc20 info error`)
-                continue
-            }
-            chainMap[token] = {
-                name: results[i] ? results[i][0] : null,
-                symbol: results[i + 1] ? results[i + 1][0] : null,
-                decimals: results[i + 2] ? results[i + 2][0] : null,
-            }
-        } catch (e) {
-            $log(`${token} erc20 info error`)
-            $log(new Error(errorStack(e)).stack)
-        }
-    }
-    return chainMap
-}
-
-async function getReserves(pairs, factory, fmt, web3) {
-    web3 = web3 || global.web3;
-
-    if (!Array.isArray(pairs[0])) {
-        pairs = [pairs]
-    }
-
-    let calls = []
-    let uniFact = require('./source/uniFact')
-    for(let i = 0; i < pairs.length; i++) {
-        let pair = pairs[i]
-        calls.push({
-            abi: uniFact,
-            address: factory,
-            name: 'getPair',
-            params: pair
-        })
-    }
-    let results = await ethBatchQuery(calls, web3)
-    let pairMap = {}
-    for(let i = 0; i<results.length; i++) {
-        let call = calls[i]
-        if (results[i]) {
-            pairMap[results[i][0]] = pairMap[call.params.join('-')] = {
-                pairAddress: results[i][0]
-            }
-
-        }
-    }
-
-    let uniPair = require('./source/uniPair')
-    calls = []
-    for(let i = 0; i<pairs.length; i++) {
-        let pair = pairs[i]
-        let pairInfo = pairMap[pair.join('-')]
-        if (!pairInfo) {
-            continue
-        }
-        calls.push({
-            abi: uniPair,
-            address: pairInfo.pairAddress,
-            name: 'token0'
-        })
-        calls.push({
-            abi: uniPair,
-            address: pairInfo.pairAddress,
-            name: 'getReserves'
-        })
-    }
-    results = await ethBatchQuery(calls, web3)
-    for(let i = 0; i < results.length; i+=2) {
-        let call = calls[i]
-        pairMap[call.address].token0 = results[i][0]
-        pairMap[call.address].reserves = results[i + 1].map(i => i.toString()).slice(0, 2)
-    }
-
-    let tokenMap
-    if (fmt) {
-        let tempMap = {}
-        for (let pair of pairs) {
-            tempMap[pair[0]] = true;
-            tempMap[pair[1]] = true;
-        }
-        tokenMap = await getTokenMap(Object.keys(tempMap), web3)
-    }
-
-    let rs = []
-    for(let i =0; i<pairs.length; i++) {
-        let pair = pairs[i]
-        let pairInfo = pairMap[pair.join('-')]
-        if (!pairInfo) {
-            rs.push([])
-            continue
-        }
-        let item
-        if (pairInfo.token0.toLowerCase() === pair[0].toLowerCase()) {
-            item = pairInfo.reserves
-        } else {
-            item = pairInfo.reserves.reverse()
-        }
-        rs.push(item)
-        if (fmt) {
-            let tokenOInfo = tokenMap[pair[0].toLowerCase()]
-            let token1Info = tokenMap[pair[1].toLowerCase()]
-            item[0] = exDcmNum(item[0], -tokenOInfo['decimals']).toString()
-            item[1] = exDcmNum(item[1], -token1Info['decimals']).toString()
-        }
-    }
-    return rs.length === 1 ? rs[0]:rs
-}
-
-async function fmtErc20Amt(token, amount, direction = 1, web3) {
-    web3 = web3 || global.web3;
-    let decimals = (await tokenMap(token, web3)).decimals;
-    if (direction >= 0) {
-        return exDcmNum(amount, direction * decimals).toFixed(0)
-    } else {
-        return exDcmNum(amount, direction * decimals).toString()
-    }
-}
-
-async function getTokenBal(address, token, fmt, web3) {
-    web3 = web3 || global.web3;
-    let bal
-    if (token) {
-        bal = await ethRead(token, erc20Abi, 'balanceOf', [address])
-    } else {
-        bal = await web3.eth.getBalance(address)
-    }
-    if (fmt) {
-        return fmtErc20Amt(token, bal, -1, web3)
-    }
-    return bal
-}
-
-function swapExactFor(amount, reserves, fee) {
-    fee = fee || 0
-    if (!Array.isArray(reserves[0])) {
-        reserves = [reserves]
-    }
-    for(let i = 0; i<reserves.length; i++) {
-        let r = reserves[i]
-        let a = toBigNum(r[0])
-        let b = toBigNum(r[1])
-        amount = b.minus(a.multipliedBy(b).dividedBy(a.plus(toBigNum(amount))))
-        amount = amount.multipliedBy(1 - Number(fee))
-    }
-    return amount.toString()
-}
-
-function fastSwapExactFor(amount, reserves, fee) {
-    fee = fee || 0
-    if (!Array.isArray(reserves[0])) {
-        reserves = [reserves]
-    }
-    for(let i = 0; i<reserves.length; i++) {
-        let r = reserves[i]
-        let a = Number(r[0])
-        let b = Number(r[1])
-        amount = b - (a*b/(a + Number(amount)))
-        amount = amount * (1 - Number(fee))
-    }
-    return amount
-}
-
-function swapForExact(amount, reserves, fee) {
-    fee = fee || 0
-    if (!Array.isArray(reserves[0])) {
-        reserves = [reserves]
-    }
-    for(let i = reserves.length - 1; i>=0; i--) {
-        let r = reserves[i]
-        let a = toBigNum(r[0])
-        let b = toBigNum(r[1])
-        amount = a.multipliedBy(b).div(b.minus(toBigNum(amount))).minus(a)
-        amount = amount.multipliedBy(1 + Number(fee))
-    }
-    return amount.toString()
-}
-
-function fastSwapForExact(amount, reserves, fee) {
-    fee = fee || 0
-    if (!Array.isArray(reserves[0])) {
-        reserves = [reserves]
-    }
-    for(let i = reserves.length - 1; i>=0; i--) {
-        let r = reserves[i]
-        let a = Number(r[0])
-        let b = Number(r[1])
-        amount = (a * b / (b - Number(amount))) - a
-        amount = amount * (1 + Number(fee))
-    }
-    return amount
-}
-
-function encodeEthAddress(address) {
-    if (address.length !== 42) throw new TypeError('Bad address')
-    address = address.slice(2).toLowerCase()
-    let checksum = createKeccakHash('keccak256')
-        .update(address)
-        .digest()
-
-    let ret = '0x'
-    for (let i = 0; i < 20; ++i) {
-        let byte = checksum[i]
-        let ha = address.charAt(i * 2)
-        let hb = address.charAt(i * 2 + 1)
-        ret += (byte & 0xf0) >= 0x80 ? ha.toUpperCase() : ha
-        ret += (byte & 0x0f) >= 0x08 ? hb.toUpperCase() : hb
-    }
-
-    return ret
-}
-
-async function ethQuery(web3, address, method, ...args) {
-    try {
-        const contract = newContract(web3, (await getContractJson(address)).abi, address);
-        return await contract.methods[method](...args).call()
-    } catch (e) {
-        $log(new Error(errorStack(e)).stack)
-        return null;
-    }
-}
-
-async function ethQuery1(web3, address, abi, method, ...args) {
-    try {
-        const contract = newContract(web3, abi, address);
-        return await contract.methods[method](...args).call()
-    } catch (e) {
-        $log(new Error(errorStack(e)).stack)
-        return null
-    }
-}
-
-async function ethRead(address, abi, method, args, web3) {
-    web3 = web3 || global.web3
-    try {
-        const contract = newContract(web3, abi, address);
-        return await contract.methods[method](...args).call()
-    } catch (e) {
-        $log(new Error(errorStack(e)).stack)
-        return null
-    }
-}
-
-function createEthWrite(config = {}) {
-    return async (sender, address, opt) => {
-        return await ethWrite(sender, address, Object.assign({}, config, opt))
-    }
-}
-
-async function ethWrite(sender, address,
-                        {data, abi, method, args, gasPrice, gasPriceAdd, gasLimit,
-                            value, waitConfirm, sleepSec, msg, onError} = {}) {
-    if (!address) {
-        throw 'address require for ethWrite'
-    }
-    let web3 = sender.web3 || global.web3
-
-    let txObject = {
-        gasPrice: gasPrice ? gasPrice * 1000000000 : await cacheFn('getGasPrice', async () => await web3.eth.getGasPrice(), 1000 * 5),
-        gasLimit: gasLimit,
-        to: address,
-        value
-    }
-    if (gasPriceAdd && !gasPrice) {
-        txObject.gasPrice = Number(txObject.gasPrice) + (gasPriceAdd * 1000000000)
-    }
-    if (method) {
-        txObject.data = newContract(web3, abi, address).methods[method](...args).encodeABI()
-    }
-    if (data) {
-        txObject.data = data
-    }
-
-    let [result, signedTx] = await sender(txObject)
-    if (!signedTx) {
-        console.log("No address to used")
-        return {}
-    }
-    msg = trim(msg)
-    msg = msg ? msg + ' ':''
-    console.log(`${msg}send ${signedTx.hash} ${txObject.gasPrice/1000000000}g`)
-    result = result.then(resp => {
-        console.log(infoStr(`${msg}${signedTx.hash} 交易成功`))
-        return true
-    }).catch(async e => {
-        console.log(errorStr(`${msg}${signedTx.hash} 交易失败`))
-        if (onError) {
-            return await onError(e)
-        } else {
-            console.error(String(e))
-            $log(new Error(errorStack(e)).stack)
-            return false
-        }
-    })
-    if (waitConfirm) {
-        await result
-    }
-    if (sleepSec) {
-        await sleep(sleepSec * 1000)
-    }
-    return {
-        promise: result
-    }
-}
-
-function parseInputData(abi, input) {
-    abiDecoder.addABI(abi);
-    return abiDecoder.decodeMethod(input);
-}
-
-async function forEachBlock(web3, num, fn) {
-    let blockNum = await web3.eth.getBlockNumber();
-    while (num > 0 && blockNum > 0) {
-        let blockInfo = await web3.eth.getBlock(blockNum)
-
-        await fn(blockInfo)
-
-        blockNum --
-        num --
-    }
-}
-
-async function web3BatchReq(items, batchNum = 49, asyncNum = 33, web3) {
-    web3 = web3 || global.web3
-    if (items.length <= 0) {
-        return []
-    }
-    if (batchNum) {
-        let callBatchs = splitArray(items, batchNum)
-        return (await batchAsync(callBatchs.map(item => () => _web3BatchReq(item, web3)), asyncNum))
-            .reduce((a,b) => a.concat(b))
-    }
-    return _web3BatchReq(items, web3)
-}
-
-async function _web3BatchReq(items, web3) {
-    let batcher = new web3.BatchRequest();
-    let proms = []
-    items.forEach(item => {
-        proms.push(
-            new Promise(resolve => {
-                batcher.add((item.method || item.name).request(...(item.args || item.params || []), async (error, result) => {
-                    if (item.callback) {
-                        try {
-                            await item.callback(error, result)
-                        } catch (e) {
-                            $log(new Error(errorStack(e)).stack)
-                            resolve(result || error);
-                            throw e
-                        }
-                    }
-                    if (error) {
-                        $log(new Error(errorStack(error)).stack)
-                    }
-                    resolve(result || error);
-                }));
-            }))
-    })
-    batcher.execute();
-    return await Promise.all(proms)
-}
-
-async function forEachBlockBatch(getFromAndTo, fn, web3) {
-    web3 = web3 || global.web3;
-    let arr = getFromAndTo
-    if (!Array.isArray(getFromAndTo)) {
-        let blockNum = await web3.eth.getBlockNumber();
-        arr = await getFromAndTo(blockNum);
-    }
-    let [from, to] = arr;
-
-    let items = []
-    for(let i = from; i<= to; i++) {
-        items.push({
-            method: web3.eth.getBlock,
-            args: [i],
-            callback: async (...args) => await fn(...args)
-        })
-    }
-    await web3BatchReq(items)
-}
-
-async function forEachBlockAsync(web3, num, fn) {
-    let blockNum = await web3.eth.getBlockNumber();
-    let items = []
-    while (num > 0 && blockNum > 0) {
-        items.push(eFn(async (blockNum) => {
-            let blockInfo = await web3.eth.getBlock(blockNum)
-            await fn(blockInfo)
-        }, blockNum))
-        blockNum --
-        num --
-    }
-    await Promise.all(items);
-}
-
-async function forEachEvent(con, eventName, getFromAndTo, callback, filter = {}, web3) {
-    web3 = web3 || global.web3;
-    let arr = getFromAndTo
-    if (!Array.isArray(getFromAndTo)) {
-        let blockNum = await web3.eth.getBlockNumber();
-        arr = await getFromAndTo(blockNum);
-    }
-    let [from, to] = arr;
-
-    let proms = [];
-    for(let i = from; i<= to; i+=5000) {
-        let prom = new Promise(async resolve => {
-            await con.getPastEvents(eventName, {
-                filter,
-                fromBlock: i,
-                toBlock: (i+5000) > to ? to : i+5000
-            }, async function(error, events){
-                try {
-                    await callback(error, events)
-                } catch (e) {
-                    resolve()
-                    throw e
-                }
-                resolve()
-            })
-        })
-
-        if (i % 33 === 0) {
-            await prom;
-        }
-        proms.push(prom)
-    }
-    await Promise.all(proms)
-}
-
-
-let newSender = async (item) => {
-    if (String(item).startsWith('0x')) {
-        return await initSenderWithKeys(web3, [item])
-    } else {
-        return await initSender(web3, global.$wallet, [item])
-    }
-}
-
-async function batchTranfer(ethTranserWrite, token, froms, tos, min, max) {
-    let decimals = 18
-    let symbol
-    if (token) {
-        let info = await tokenMap(token)
-        decimals = info.decimals
-        symbol = info.symbol
-    }
-    if (!vl(max)) {
-        max = min
-    }
-
-    min = Number(exDcmNum(min, decimals).toFixed(0))
-    max = Number(exDcmNum(max, decimals).toFixed(0))
-
-    let pros = []
-    for(let from of froms) {
-        let sender = await newSender(from)
-        for(let to of tos) {
-            let fromAddress = String(from).startsWith('0x') ? privateToAddress(from):global.$wallet.getAddress(from);
-            let toAddress = String(to).startsWith('0x') ? to:global.$wallet.getAddress(to);
-
-            if (token) {
-                let fb = await ethRead(token, erc20Abi, 'balanceOf', [fromAddress])
-                let tb = await ethRead(token, erc20Abi, 'balanceOf', [toAddress])
-
-                if (Number(tb) >= min) {
-                    continue
-                }
-                let transferAmt = BigNumber(bMin(max, tb)).toFixed(0)
-                if (Number(fb) < Number(transferAmt)) {
-                    continue
-                }
-                let fmtTransferAmt = exDcmNum(transferAmt, -decimals).toString()
-                pros.push(await ethTranserWrite(sender, token, {
-                    abi: erc20Abi,
-                    method: 'transfer',
-                    args: [toAddress, transferAmt],
-                    msg: from + '转' + fmtTransferAmt + symbol +'给' + to
-                }))
-            } else {
-                let fb = await web3.eth.getBalance(fromAddress);
-                let tb = await web3.eth.getBalance(toAddress);
-
-                if (Number(tb) >= min) {
-                    continue
-                }
-                let transferAmt = BigNumber(bMin(max, tb)).toFixed(0)
-                if (Number(fb) < Number(transferAmt)) {
-                    continue
-                }
-                let fmtTransferAmt = exDcmNum(transferAmt, -decimals).toString()
-                pros.push(await ethTranserWrite(sender, toAddress, {
-                    value: transferAmt,
-                    msg: from + '转' + fmtTransferAmt + '本币给' + to
-                }))
-            }
-        }
-    }
-    await Promise.all(pros.map(i => i.promise))
-}
-
-async function batchCollect(ethTranserWrite, token, froms, to, remain) {
-    let decimals = 18
-    let symbol
-    if (token) {
-        let info = await tokenMap(token)
-        decimals = info.decimals
-        symbol = info.symbol
-    }
-
-    remain = Number(exDcmNum(remain, decimals).toFixed(0))
-    let pros = []
-    for(let from of froms) {
-        let sender = await newSender(from)
-
-        let fromAddress = String(from).startsWith('0x') ? privateToAddress(from):global.$wallet.getAddress(from);
-        let toAddress = String(to).startsWith('0x') ? to:global.$wallet.getAddress(to);
-
-        if (token) {
-            let fb = await ethRead(token, erc20Abi, 'balanceOf', [fromAddress])
-
-            if (Number(fb) <= remain) {
-                continue
-            }
-            let transferAmt = BigNumber(bMin(fb, remain)).toFixed(0)
-            let fmtTransferAmt = exDcmNum(transferAmt, -decimals).toString()
-            pros.push(await ethTranserWrite(sender, token, {
-                abi: erc20Abi,
-                method: 'transfer',
-                args: [toAddress, transferAmt],
-                msg: from + '转' + fmtTransferAmt + symbol +'给' + to
-            }))
-        } else {
-            let fb = await web3.eth.getBalance(fromAddress);
-
-            if (Number(fb) <= remain) {
-                continue
-            }
-            let transferAmt = BigNumber(bMin(fb, remain)).toFixed(0)
-            let fmtTransferAmt = exDcmNum(transferAmt, -decimals).toString()
-            pros.push(await ethTranserWrite(sender, toAddress, {
-                value: transferAmt,
-                msg: from + '转' + fmtTransferAmt + '本币给' + to
-            }))
-        }
-    }
-    await Promise.all(pros.map(i => i.promise))
-}
-
-function coinNum(num, decimals) {
-    return parseFloat(String(new BigNumber(num).dividedBy(new BigNumber(`10e+${(decimals || 18) - 1}`))))
-}
-
-function exDcm(num, decimals, fixed) {
-    return new BigNumber(num).multipliedBy(new BigNumber(`1e${(decimals || 18)}`)).toFixed(fixed || 9).toString()
-}
-
-function exDcmNum(num, decimals) {
-    return new BigNumber(num).multipliedBy(new BigNumber(`1e${(decimals || 18)}`))
-}
-
-async function getContractJson(address) {
-    if (fs.existsSync(address)) {
-        return JSON.parse(String(fs.readFileSync(address)))
-    }
-    if (fs.existsSync(contractMapPath)) {
-        let obj = JSON.parse(String(fs.readFileSync(contractMapPath)))
-        if (obj[address]) {
-            return JSON.parse(String(fs.readFileSync(obj[address]['abiPath'])))
-        }
-    }
-}
-
-async function transferToken(ethTranserWrite, sender, address, token, amt, msg) {
-    if (token) {
-        await ethTranserWrite(sender, token, {
-            abi: erc20Abi,
-            method: 'transfer',
-            args: [address, amt],
-            msg
-        })
-    } else {
-        await ethTranserWrite(sender, address, {
-            value: amt,
-            msg
-        })
-    }
-}
-
-async function tokenApprove(ethWrite, sender, senderAddress, erc20, spender, opt) {
-    if (!erc20) {
-        return
-    }
-    let {amt = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff', msg} = opt
-    let bal = await ethRead(erc20, erc20Abi, 'allowance', [senderAddress, spender])
-    if (bal <Number(amt) ) {
-        return await ethWrite(sender, erc20, {
-            abi: erc20Abi,
-            method: 'approve',
-            args: [spender, amt],
-            msg
-        })
-    }
-
-    return {
-        promise: true
-    }
-}
-
-function txnInputReplacer(input, callback) {
-    let item = [input.substring(0, 10)]
-    input = input.substring(10, input.length)
-
-    let str = ''
-    while (input.length > 0) {
-        str = input.substring(0, 64);
-        input = input.substring(64, input.length);
-        if (callback) {
-            str = callback(str)
-        }
-        item.push(str)
-    }
-    return item.join('')
-}
-
-module.exports = {
-    getContractJson,
-    coinNum,
-    forEachBlock,
-    parseInputData,
-    exDcm,
-    ethQuery,
-    ethQuery1,
-    exDcmNum,
-    encodeEthAddress,
-    gasPrice,
-    tokenMap,
-    getPrice,
-    getPriceNoFee,
-    getPriceByAmt,
-    getPriceByAmtNoFee,
-    getPairAmt,
-    getPairAmtNoFee,
-    getPoolAmt,
-    getLastBlockSecTime,
-    forEachBlockAsync,
-    newContract,
-    sendTxn,
-    walletGet,
-    txnSign,
-    initSender,
-    privateToAddress,
-    initSenderWithKeys,
-    erc20Query,
-    initRootWallet,
-    ethBatchQuery,
-    newAbiInterface,
-    newWeb3Contract,
-    getTokenMap,
-    getReserves,
-    swapExactFor,
-    swapForExact,
-    ethRead,
-    ethWrite,
-    fmtErc20Amt,
-    createEthWrite,
-    forEachBlockBatch,
-    forEachEvent,
-    batchTranfer,
-    batchCollect,
-    web3BatchReq,
-    fastSwapExactFor,
-    fastSwapForExact,
-    getTokenBal,
-    transferToken,
-    tokenApprove,
-    txnInputReplacer,
-    abiDecoder,
-    saveTokenMap
-}