evolutionland/ethereum/index.js

import BigNumber from 'bignumber.js'
import EthereumTx from "ethereumjs-tx";
import {
    Env,
    getABIConfig
} from './env'
import ClientFetch from '../utils/clientFetch'
import bancorABI from './env/abi/ethereum/abi-bancor'
import actionABI from './env/abi/ethereum/abi-auction'
import ringABI from './env/abi/ethereum/abi-ring'
import withdrawABI from './env/abi/ethereum/abi-withdraw'
import bankABI from './env/abi/ethereum/abi-bank'
import ktonABI from './env/abi/ethereum/abi-kton'
import landABI from './env/abi/ethereum/abi-land'
import lotteryABI from './env/abi/ethereum/abi-lottery'
import rolesUpdaterABI from './env/abi/ethereum/abi-rolesUpdater'
import landResourceABI from './env/abi/ethereum/abi-landResource'
import apostleAuctionABI from './env/abi/ethereum/abi-apostleAuction'
import apostleTakeBackABI from './env/abi/ethereum/abi-takeBack'
import apostleSiringABI from './env/abi/ethereum/abi-apostleSiring'
import apostleBaseABI from './env/abi/ethereum/abi-apostleBase'
import tokenUseABI from './env/abi/ethereum/abi-tokenUse'
import petBaseABI from './env/abi/ethereum/abi-petbase'
import uniswapExchangeABI from './env/abi/ethereum/abi-uniswapExchangeV2'
import swapBridgeABI from './env/abi/ethereum/abi-swapBridge'
import luckyBoxABI from './env/abi/ethereum/abi-luckyBag'
import itemTreasureABI from './env/abi/ethereum/abi-itemTreasure'
import itemTakeBackABI from './env/abi/ethereum/abi-itemTakeBack'
import furnaceItemBaseABI from './env/abi/ethereum/abi-furnaceItemBase'
import Utils from '../utils/index'
import UniswapUtils from '../utils/uniswap'
import { Currency, ChainId, Token, TokenAmount, Pair, WETH, Fetcher, Percent, Route, TradeType, Trade, JSBI, CurrencyAmount } from '@uniswap/sdk'
const loop = function () { }
/**
 * @class
 * Evolution Land for Ethereum
 */
class EthereumEvolutionLand {
    /**
     * constructor function.
     * @param {object} web3js - web3js instance
     * @param {string} network
     */
    constructor(web3js, network, option = {}) {
        this.version = '1.0.0'
        this._web3js = web3js
        this.env = Env(network)
        this.ABIs = getABIConfig(network)
        this.ABIClientFetch = new ClientFetch({
            baseUrl: this.env.ABI_DOMAIN,
            chainId: 60
        })
        this.ClientFetch = new ClientFetch({
            baseUrl: this.env.DOMAIN,
            chainId: 60
        })
        this.option = {
            sign: true,
            address: null,
            ...option
        }
    }
    setCustomAccount(account) {
        this.option.address = account
    }
    /**
     * get web3js Current address.
     * @returns {Promise<any>}
     */
    getCurrentAccount() {
        return new Promise((resolve, reject) => {
            if (this.option.address) {
                resolve(this.option.address)
            }
            this._web3js.eth.getAccounts((error, accounts) => {
                if (error) {
                    reject(error)
                } else {
                    resolve(accounts[0])
                }
            })
        })
    }
    /**
     * Interact with a contract.
     * @param {string} methodName - contract method name
     * @param {string} abiKey - If the contract exists in the configuration file, you can use the key in the configuration to get it directly.
     * @param {json} abiString - ethereum ABI json
     * @param contractParams - contract function with arguments
     * @param sendParams - web3js send() arguments
     * @param beforeFetch
     * @param transactionHashCallback
     * @param confirmationCallback
     * @param receiptCallback
     * @param errorCallback
     * @returns {Promise<PromiEvent<any>>}
     */
    async triggerContract({
        methodName,
        abiKey,
        abiString,
        contractParams = [],
        sendParams = {}
    }, {
        beforeFetch = loop,
        transactionHashCallback = loop,
        confirmationCallback = loop,
        receiptCallback = loop,
        errorCallback = loop,
        receiptFinal = loop,
        unSignedTx = loop,
        payload = {}
    } = {}) {
        try {
            beforeFetch && beforeFetch();
            let _contract = null;
            let contractAddress = await this.getContractAddress(abiKey);
            _contract = new this._web3js.eth.Contract(abiString, contractAddress);
            const extendPayload = { ...payload, _contractAddress: contractAddress };
            const _method = _contract.methods[methodName].apply(this, contractParams)
            const from = await this.getCurrentAccount()
            const gasRes = await this.ClientFetch.apiGasPrice({ wallet: this.option.address || from })
            let estimateGas = 300000;
            try {
                let hexSendParams = { value: 0 }
                Object.keys(sendParams).forEach((item) => {
                    hexSendParams[item] = Utils.toHex(sendParams[item])
                })
                estimateGas = await this.estimateGas(_method, this.option.address || from, gasRes.data.gas_price.standard, hexSendParams.value) || 300000;
            } catch (e) {
                console.log('estimateGas', e)
            }
            if (!this.option.sign) {
                if (!this.option.address) {
                    throw Error('from account is empty!')
                }
                let hexSendParams = {}
                Object.keys(sendParams).forEach((item) => {
                    hexSendParams[item] = Utils.toHex(sendParams[item])
                })
                const tx = new EthereumTx({
                    to: contractAddress,
                    value: 0,
                    nonce: gasRes.data.nonce,
                    gasPrice: gasRes.data.gas_price.standard,
                    gasLimit: Utils.toHex(estimateGas + 30000),
                    chainId: parseInt(await this.getNetworkId()),
                    data: _method ? _method.encodeABI() : '',
                    ...hexSendParams
                })
                const serializedTx = tx.serialize().toString("hex")
                unSignedTx && unSignedTx(serializedTx, extendPayload)
                return serializedTx;
            }
            return _method.send({
                from: await this.getCurrentAccount(),
                value: 0,
                gasLimit: Utils.toHex(estimateGas + 30000),
                ...sendParams
            })
                .once('transactionHash', (hash) => {
                    transactionHashCallback && transactionHashCallback(hash, extendPayload)
                })
                .once('confirmation', (confirmationNumber, receipt) => {
                    confirmationCallback && confirmationCallback(confirmationNumber, receipt, extendPayload)
                })
                .once('receipt', (receipt) => {
                    receiptCallback && receiptCallback(receipt, extendPayload)
                })
                .once('error', (error) => {
                    errorCallback && errorCallback(error, extendPayload)
                })
                // .then((receipt) =>{
                //     receiptFinal && receiptFinal(receipt, extendPayload);
                // })
        } catch (e) {
            console.error('triggerContract', e)
            const extendPayload = { ...payload, _contractAddress: contractAddress };
            errorCallback && errorCallback(e, extendPayload)
        }
        // return _method.send.bind(this,{
        //     from: await this.getCurrentAccount(),
        //     value: 0,
        //     ...sendParams
        // })
    }
    /**
     * Interact with a contract.
     * @param {string} methodName - contract method name
     * @param {string} abiKey - If the contract exists in the configuration file, you can use the key in the configuration to get it directly.
     * @param {json} abiString - ethereum ABI json
     * @param contractParams - contract function with arguments
     * @param sendParams - web3js send() arguments
     * @param beforeFetch
     * @param transactionHashCallback
     * @param confirmationCallback
     * @param receiptCallback
     * @param errorCallback
     * @returns {Promise<PromiEvent<any>>}
     */
    async callContract({
        methodName,
        abiKey,
        abiString,
        contractParams = [],
    }, {
        beforeFetch = loop,
        errorCallback = loop
    } = {}) {
        try {
            beforeFetch && beforeFetch()
            let _contract = null
            let contractAddress = await this.getContractAddress(abiKey);
            _contract = new this._web3js.eth.Contract(abiString, contractAddress);
            const _method = _contract.methods[methodName].apply(this, contractParams)
            return _method.call({
                from: await this.getCurrentAccount(),
            })
        } catch (e) {
            console.error('triggerContract', e)
            errorCallback && errorCallback(e)
        }
    }
    /**
     * Get the contract address of evolution land by key.
     * @param {*} tokenKey ring | kton | gold ... 
     */
    async getContractAddress(tokenKey) {
        let token = (this.ABIs[tokenKey] && this.ABIs[tokenKey].address) || tokenKey;
        // if(Array.isArray(tokenKey) && tokenKey.length === 2) {
        //     const pair = await this.getDerivedPairInfo(...tokenKey)
        //     token = pair.liquidityToken.address
        // }
        
        return token;
    }
    /**
     * Query if an address is an authorized operator for another address
     * @param {*} owner The address that owns the NFTs
     * @param {*} operator The address that acts on behalf of the owner
     * @param {*} contractAddress ERC721 contract address
     */
    erc721IsApprovedForAll(owner, operator, contractAddress, callback={}) {
        return this.callContract({
            methodName: 'isApprovedForAll',
            abiKey: contractAddress,
            abiString: this.ABIs['erc721'].abi,
            contractParams: [owner, operator],
        }, callback)
    }
    /**
     * Returns whether `spender` is allowed to manage `tokenId`.
     * @param {*} spender The address that acts on behalf of the owner
     * @param {*} contractAddress The factory of tokenId.
     * @param {*} tokenId ERC721 token Id;
     */
    async erc721IsApprovedOrOwner(spender, contractAddress, tokenId) {
        const owner = await this.callContract({
            methodName: 'ownerOf',
            abiKey: contractAddress,
            abiString: this.ABIs['erc721'].abi,
            contractParams: [tokenId],
        });
        const approvedAddress = await this.callContract({
            methodName: 'getApproved',
            abiKey: contractAddress,
            abiString: this.ABIs['erc721'].abi,
            contractParams: [tokenId],
        });
        const isApprovedForAll = await this.erc721IsApprovedForAll(owner, spender, contractAddress);
        return (owner.toLowerCase() === spender.toLowerCase() || approvedAddress.toLowerCase() === spender.toLowerCase() || isApprovedForAll);
    }
    /**
     * 
     * @param {*} owner 
     * @param {*} operator 
     * @param {*} contractAddress 
     * @param {*} callback 
     */    
    erc721IsApprovedForAll(owner, operator, contractAddress, callback={}) {
        return this.callContract({
            methodName: 'isApprovedForAll',
            abiKey: contractAddress,
            abiString: this.ABIs['erc721'].abi,
            contractParams: [owner, operator],
        }, callback)
    }
    /**
     * Change or reaffirm the approved address for an NFT
     * @param {*} to The new approved NFT controller
     * @param {*} tokenId The NFT to approve
     */
    async erc721Approve(to, tokenId, contractAddress, callback={}) {
        return this.triggerContract({
            methodName: 'approve',
            abiKey: contractAddress,
            abiString: this.ABIs['erc721'].abi,
            contractParams: [to, tokenId],
        }, callback)
    }
    /**
     * Enable or disable approval for a third party ("operator") to manage
     * @param {*} to Address to add to the set of authorized operators
     * @param {*} approved True if the operator is approved, false to revoke approval
     * @param {*} contractAddress ERC721 contract address
     * @param {*} callback 
     */
    async erc721SetApprovalForAll(to, approved, contractAddress, callback={}) {
        return this.triggerContract({
            methodName: 'setApprovalForAll',
            abiKey: contractAddress,
            abiString: this.ABIs['erc721'].abi,
            contractParams: [to, approved],
        }, callback)
    }
    /**
     * Atlantis swap fee
     * @param {string} value amount of rings to be swaped
     * @param {*} callback 
     */
    async fetchAtlantisSwapFee(value, callback = {}) {
        return this.callContract({
            methodName: 'querySwapFee',
            abiKey: 'swapBridge',
            abiString: swapBridgeABI,
            contractParams: [value],
        }, callback)
    }
    getSimpleBridgeStatus(callback = {}) {
        return this.callContract({
            methodName: 'paused',
            abiKey: 'swapBridge',
            abiString: swapBridgeABI,
            contractParams: [],
        }, callback)
    }
    /**
     * Atlantis ring transfer to Byzantium
     * @param {string} value amount of rings to be swaped
     * @param {string} value tron address (bs58)
     * @param {*} callback 
     */
    async AtlantisSwapBridge(value, targetAddress, symbol = 'ring', callback = {}) {
        if (!targetAddress) {
            throw Error('empty targetAddress')
        }
        const fee = await this.fetchAtlantisSwapFee(value)
        const hexTargetAddress = Utils.decodeBase58Address(targetAddress);
        const extraData = `${Utils.toHexAndPadLeft(value)}${Utils.toHexAndPadLeft(2).slice(2)}${Utils.padLeft(hexTargetAddress.substring(2), 64, '0')}`
        return this.triggerContract({
            methodName: 'approveAndCall',
            abiKey: symbol.toLowerCase(),
            abiString: ringABI,
            contractParams: [this.ABIs['swapBridge'].address, new BigNumber(fee).plus(1).plus(new BigNumber(value)).toFixed(0), extraData],
        }, callback)
    }
    /**
     * Swap Ether to Ring token - Powered by uniswap.
     * @param {string} value - amount for Ring， unit of measurement(wei)
     * @returns {Promise<PromiEvent<any>>}
     */
    async buyRingUniswap(value, callback = {}) {
        const RING = new Token(parseInt(this.env.CONTRACT.NETWORK), this.env.CONTRACT.TOKEN_RING, 18, "RING", "Darwinia Network Native Token")
        const pair = await Fetcher.fetchPairData(WETH[RING.chainId], RING)
        const route = new Route([pair], WETH[RING.chainId])
        const amountIn = value
        const trade = new Trade(route, new TokenAmount(RING, amountIn), TradeType.EXACT_OUTPUT)
        const slippageTolerance = new Percent('0', '10000') // 30 bips, or 0.30%
        const amountInMax = trade.maximumAmountIn(slippageTolerance).raw // needs to be converted to e.g. hex
        const path = [WETH[RING.chainId].address, RING.address]
        const to = await this.getCurrentAccount() // should be a checksummed recipient address
        const deadline = Math.floor(Date.now() / 1000) + 60 * 20 // 20 minutes from the current Unix time
        const outputAmount = trade.outputAmount.raw // // needs to be converted to e.g. hex
        return this.triggerContract({
            methodName: 'swapETHForExactTokens',
            abiKey: 'uniswapExchange',
            abiString: uniswapExchangeABI,
            contractParams: [
                outputAmount.toString(10),
                path,
                to,
                deadline
            ],
            sendParams: {
                value: amountInMax.toString(10)
            }
        }, callback)
    }
    /**
     * Swap Ring token to Ether - Powered by uniswap.
     * @param {string} value - amount for Ring， unit of measurement(wei)
     * @returns {Promise<PromiEvent<any>>}
     */
    async sellRingUniswap(value, callback = {}) {
        const RING = new Token(parseInt(this.env.CONTRACT.NETWORK), this.env.CONTRACT.TOKEN_RING, 18, "RING", "Darwinia Network Native Token")
        const pair = await Fetcher.fetchPairData(RING, WETH[RING.chainId])
        const route = new Route([pair], RING)
        const amountIn = value
        const trade = new Trade(route, new TokenAmount(RING, amountIn), TradeType.EXACT_INPUT)
        const slippageTolerance = new Percent('0', '10000') // 30 bips, or 0.30%
        const amountOutMin = trade.minimumAmountOut(slippageTolerance).raw // needs to be converted to e.g. hex
        const path = [RING.address, WETH[RING.chainId].address]
        const to = await this.getCurrentAccount() // should be a checksummed recipient address
        const deadline = Math.floor(Date.now() / 1000) + 60 * 20 // 20 minutes from the current Unix time
        const inputAmount = trade.inputAmount.raw // // needs to be converted to e.g. hex
        return this.triggerContract({
            methodName: 'swapExactTokensForETH',
            abiKey: 'uniswapExchange',
            abiString: uniswapExchangeABI,
            contractParams: [
                inputAmount.toString(10),
                amountOutMin.toString(10),
                path,
                to,
                deadline
            ],
            sendParams: {
                value: 0
            }
        }, callback)
    }
    /**
     * Transfers value amount of tokens to address to
     * @param {string} value - amount of tokens
     * @param {string} to - receiving address
     * @param {string} symbol - symbol of token [ring, kton, gold, wood, water, fire, soil]
     * @param {*} callback
     */
    async tokenTransfer(value, to, symbol, callback = {}) {
        if (!to || to === "0x0000000000000000000000000000000000000000") return;
        let abiString = ''
        if (symbol === 'kton') {
            abiString = ktonABI
        } else {
            abiString = ringABI
        }
        return this.triggerContract({
            methodName: 'transfer',
            abiKey: symbol,
            abiString: abiString,
            contractParams: [to, value],
        }, callback)
    }
    /**
     * Ethereum Function, Approve Ring to Uniswap Exchange
     * @param {*} callback 
     */
    async approveRingToUniswap(callback = {}, value="20000000000000000000000000") {
        return this.triggerContract({
            methodName: 'approve',
            abiKey: 'ring',
            abiString: ringABI,
            contractParams: [this.ABIs['uniswapExchange'].address, value],
        }, callback)
    }
    /**
     * Allows Uniswap to withdraw from your account multiple times, up to the value amount. 
     * @param {*} addressOrType ERC20 token contract address.
     * @param {*} value
     * @param {*} callback 
     */
    approveTokenToUniswap(addressOrType, value="0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", callback = {}) {
        if(!addressOrType) {
            throw 'ethereum::approveTokenToUniswap: missing addressOrType param'
        }
        return this.triggerContract({
            methodName: 'approve',
            abiKey: addressOrType,
            abiString: ringABI,
            contractParams: [this.ABIs['uniswapExchange'].address, value],
        }, callback)
    }
    /**
     * Approve liquidity to uniswap
     * @param {*} tokenAType Token 0 contract address 
     * @param {*} tokenBType Token 1 contract address 
     * @param {*} value Approved value
     * @param {*} callback 
     */
    async approveLiquidityTokenToUniswap(tokenAType, tokenBType, value="0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", callback = {}) {
        if(!tokenAType || !tokenBType) {
            throw 'ethereum::approveLiquidityTokenToUniswap: missing addressOrType param'
        }
        const pair = await this.getDerivedPairInfo(tokenAType, tokenBType);
        return this.approveTokenToUniswap(pair.liquidityToken.address, value, callback);
    }
    /**
     * Allows spender to withdraw from your account multiple times, up to the value amount. If this function is called again it overwrites the current allowance with value.
     * @param {*} tokenContractOrType Erc20 token contract address
     * @param {*} spender
     * @param {*} value
     * @param {*} callback 
     */
    async approveToken(tokenContractOrType, spender, value="0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", callback = {}) {
        if(!spender) {
            return;
        }
        return this.triggerContract({
            methodName: 'approve',
            abiKey: tokenContractOrType,
            abiString: ringABI,
            contractParams: [spender, value],
        }, callback)
    }
    /**
     * Approve uniswap liquidity token to spender.
     * @param {*} tokenAType 
     * @param {*} tokenBType 
     * @param {*} value 
     * @param {*} callback 
     */
    async approveUniswapLiquidityToken(tokenAType, tokenBType, spender, value="0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", callback = {}) {
        if(!tokenAType || !tokenBType) {
            throw 'ethereum::approveUniswapLiquidityToken: missing addressOrType param'
        }
        const pair = await this.getDerivedPairInfo(tokenAType, tokenBType);
        return this.triggerContract({
            methodName: 'approve',
            abiKey: pair.liquidityToken.address,
            abiString: ringABI,
            contractParams: [spender, value],
        }, callback)
    }
    /**
     * Check if uniswap has sufficient transfer authority
     * @param {*} amount
     * @param {*} tokenAddressOrType
     * @param {*} account
     */
    async checkUniswapAllowance(amount, tokenAddressOrType = 'ring', account) {
        const from = account || await this.getCurrentAccount();
        const token = await this.getContractAddress(tokenAddressOrType);
        const erc20Contract = new this._web3js.eth.Contract(ringABI, token)
        const allowanceAmount = await erc20Contract.methods.allowance(from, this.ABIs['uniswapExchange'].address).call()
        return !Utils.toBN(allowanceAmount).lt(Utils.toBN(amount || '1000000000000000000000000'))
    }
    /**
     * Check if spender has sufficient transfer authority
     * @param {*} amount 
     * @param {*} tokenAddressOrType,
     * @param {*} account
     * @param {*} spender
     */
    async checkTokenAllowance(amount, tokenAddressOrType, account, spender) {
        if(!amount || !tokenAddressOrType || !spender) {
            throw 'ethereum::checkTokenAllowance: missing param'
        }
        const from = account || await this.getCurrentAccount();
        const token = await this.getContractAddress(tokenAddressOrType);
        const erc20Contract = new this._web3js.eth.Contract(ringABI, token)
        const allowanceAmount = await erc20Contract.methods.allowance(from, spender).call()
        return !Utils.toBN(allowanceAmount).lt(Utils.toBN(amount || '1000000000000000000000000'))
    }
    /**
     * get amount of ether in uniswap exchange 
     */
    async getUniswapEthBalance() {
        const RING = new Token(parseInt(this.env.CONTRACT.NETWORK), this.env.CONTRACT.TOKEN_RING, 18, "RING", "Darwinia Network Native Token")
        const pair = await Fetcher.fetchPairData(WETH[RING.chainId], RING)
        return pair.tokenAmounts[1].raw.toString(10)
    }
    /**
    * get amount of ring in uniswap exchange 
    */
    async getUniswapTokenBalance() {
        const RING = new Token(parseInt(this.env.CONTRACT.NETWORK), this.env.CONTRACT.TOKEN_RING, 18, "RING", "Darwinia Network Native Token")
        const pair = await Fetcher.fetchPairData(WETH[RING.chainId], RING)
        return pair.tokenAmounts[0].raw.toString(10)
    }
    /**
     * Eth will be cost to swap 1 Ring
     * @param {*} tokens_bought
     */
    async getEthToTokenOutputPrice(tokens_bought = '1000000000000000000') {
        const RING = new Token(parseInt(this.env.CONTRACT.NETWORK), this.env.CONTRACT.TOKEN_RING, 18, "RING", "Darwinia Network Native Token")
        const pair = await Fetcher.fetchPairData(WETH[RING.chainId], RING)
        const route = new Route([pair], WETH[RING.chainId])
        const amountIn = tokens_bought
        const trade = new Trade(route, new TokenAmount(RING, amountIn), TradeType.EXACT_OUTPUT)
        const slippageTolerance = new Percent('0', '10000') 
        const amountInMax = trade.maximumAmountIn(slippageTolerance).raw
        return [new BigNumber(amountInMax.toString(10)).times('1000000000000000000').div(tokens_bought).toFixed(0), amountInMax.toString(10)];
    }
    /**
    * Eth will be got to swap 1 Ring
    * @param {*} tokens_bought
    */
    async getTokenToEthInputPrice(tokens_bought = '1000000000000000000') {
        const RING = new Token(parseInt(this.env.CONTRACT.NETWORK), this.env.CONTRACT.TOKEN_RING, 18, "RING", "Darwinia Network Native Token")
        const pair = await Fetcher.fetchPairData(RING, WETH[RING.chainId])
        const route = new Route([pair], RING)
        const amountIn = tokens_bought // 1 WETH
        const trade = new Trade(route, new TokenAmount(RING, amountIn), TradeType.EXACT_INPUT)
        const slippageTolerance = new Percent('0', '10000') // 50 bips, or 0.50%
        const amountOutMin = trade.minimumAmountOut(slippageTolerance).raw // needs to be converted to e.g. hex
        return [new BigNumber(amountOutMin.toString(10)).times('1000000000000000000').div(tokens_bought).toFixed(0), amountOutMin.toString(10)];
    }
    /**
     * Buy ring token with Ether.
     * @param {string} value - amount for Ether， unit of measurement(wei)
     * @returns {Promise<PromiEvent<any>>}
     */
    buyRing(value, callback = {}) {
        return this.triggerContract({
            methodName: 'buyRING',
            abiKey: 'bancor',
            abiString: bancorABI,
            contractParams: [1],
            sendParams: {
                value: value
            }
        }, callback)
    }
    /**
     * Claim land asset
     * @param tokenId - Land tokenId
     * @returns {Promise<PromiEvent<any>>}
     */
    claimLandAsset(tokenId, callback = {}) {
        return this.triggerContract({
            methodName: 'claimLandAsset',
            abiKey: 'auction',
            abiString: actionABI,
            contractParams: ['0x' + tokenId],
        }, callback)
    }
    /**
     * Bid Land Assets with Ring token.
     * @param amount - bid price with ring token
     * @param tokenId - tokenid of land
     * @param referrer - Referrer address
     * @returns {Promise<PromiEvent<any>>}
     */
    buyLandContract(amount, tokenId, referrer, callback = {}) {
        const finalReferrer = referrer
        const data =
            finalReferrer && Utils.isAddress(finalReferrer) ?
                `0x${tokenId}${Utils.padLeft(finalReferrer.substring(2), 64, '0')}` :
                `0x${tokenId}`
        return this.triggerContract({
            methodName: 'transfer',
            abiKey: 'ring',
            abiString: ringABI,
            contractParams: [this.ABIs['auction'].address, amount, data],
        }, callback)
    }
    /**
     * Sell land asset
     * @param tokenId - Land tokenId
     * @param start - start price
     * @param end - end price
     * @param duration - bid duration time in second
     * @returns {Promise<PromiEvent<any>>}
     */
    async setLandPrice(tokenId, start, end, duration, callback = {}) {
        const from = await this.getCurrentAccount()
        const _from = Utils.padLeft(from.slice(2), 64, '0')
        const _start = Utils.toHexAndPadLeft(start).slice(2)
        const _end = Utils.toHexAndPadLeft(end).slice(2)
        const _duration = Utils.toHexAndPadLeft(duration).slice(2)
        const data = `0x${_start}${_end}${_duration}${_from}`
        return this.triggerContract({
            methodName: 'approveAndCall',
            abiKey: 'land',
            abiString: landABI,
            contractParams: [this.ABIs['auction'].address, '0x' + tokenId, data],
        }, callback)
    }
    /**
     * Bid Land Assets with Ether.
     * @param tokenId - tokenid of land
     * @param referer - Referrer address
     * @param value - bid price with ether
     * @returns {Promise<PromiEvent<any>>}
     */
    buyLandWithETHContract(tokenId, referer, value, callback = {}) {
        return this.triggerContract({
            methodName: "bidWithETH",
            abiString: actionABI,
            contractParams: ['0x' + tokenId, referer],
            abiKey: "auction",
            sendParams: {
                value: value
            }
        }, callback)
    }
    /**
     *  Withdraw ring from the channel
     * @param nonce
     * @param value
     * @param hash
     * @param v
     * @param r
     * @param s
     * @returns {Promise<PromiEvent<any>>}
     */
    withdrawRing({
        nonce,
        value,
        hash,
        v,
        r,
        s
    }, callback = {}) {
        return this.triggerContract({
            methodName: "takeBack",
            abiString: withdrawABI,
            contractParams: [nonce, value, hash, v, r, s],
            abiKey: "withdraw",
        }, callback);
    }
    /**
     *  Withdraw kton from the channel
     * @param nonce
     * @param value
     * @param hash
     * @param v
     * @param r
     * @param s
     * @returns {Promise<PromiEvent<any>>}
     */
    withdrawKton({
        nonce,
        value,
        hash,
        v,
        r,
        s
    }, callback = {}) {
        return this.triggerContract({
            methodName: "takeBack",
            abiString: withdrawABI,
            contractParams: [nonce, value, hash, v, r, s],
            abiKey: "withdrawKton",
        }, callback);
    }
    /**
     *  Cancel the Land being auctioned.
     * @param {string} tokenId - tokenid of land
     * @returns {Promise<PromiEvent<any>>}
     */
    cancelAuction(tokenId, callback = {}) {
        return this.triggerContract({
            methodName: "cancelAuction",
            abiString: actionABI,
            contractParams: ['0x' + tokenId],
            abiKey: "auction",
        }, callback);
    }
    /**
     * Convert Ring token to Ether via bancor exchange
     * @param amount - ring token amount
     * @returns {Promise<PromiEvent<any>>}
     */
    sellRing(amount, callback = {}) {
        return this.triggerContract({
            methodName: 'transfer',
            abiKey: 'ring',
            abiString: ringABI,
            contractParams: [this.ABIs['bancor'].address, amount, '0x0000000000000000000000000000000000000000000000000000000000000001'],
        }, callback)
    }
    /**
     * Lock ring token to get Kton token
     * @param amount - ring amount
     * @param month - Locking time(unit: month)
     * @returns {Promise<PromiEvent<any>>}
     */
    saveRing(amount, month, callback = {}) {
        return this.triggerContract({
            methodName: 'transfer',
            abiKey: 'ring',
            abiString: ringABI,
            contractParams: [this.ABIs['bank'].address, amount, Utils.toTwosComplement(month)],
        }, callback)
    }
    /**
     * Redemption of unexpired ring.
     * @param amount - penalty Kton amount
     * @param id - deposit ID
     * @returns {Promise<PromiEvent<any>>}
     */
    redeemRing(amount, id, callback = {}) {
        return this.triggerContract({
            methodName: 'transfer',
            abiKey: 'kton',
            abiString: ktonABI,
            contractParams: [this.ABIs['bank'].address, amount, Utils.toTwosComplement(id)],
        }, callback)
    }
    /**
     * Redemption ring without penalty kton
     * @param id - deposit ID
     * @returns {Promise<PromiEvent<any>>}
     */
    withdrawBankRing(id, callback = {}) {
        return this.triggerContract({
            methodName: 'claimDeposit',
            abiKey: 'bank',
            abiString: bankABI,
            contractParams: [Utils.toTwosComplement(id)],
        }, callback)
    }
    /**
     * Play a ticket game
     * @param type - ['small':playWithSmallTicket , 'large': playWithLargeTicket]
     * @returns {Promise<PromiEvent<any>>}
     */
    lotteryFromPoint(type = "small", callback = {}) {
        return this.triggerContract({
            methodName: type === "small" ? "playWithSmallTicket" : "playWithLargeTicket",
            abiKey: 'lottery',
            abiString: lotteryABI,
            contractParams: [],
        }, callback)
    }
    /**
     * Binding tester code
     * @param _nonce
     * @param _testerCodeHash
     * @param _hashmessage
     * @param _v
     * @param _r
     * @param _s
     * @returns {Promise<PromiEvent<any>>}
     */
    updateTesterRole(_nonce, _testerCodeHash, _hashmessage, _v, _r, _s, callback = {}) {
        return this.triggerContract({
            methodName: 'updateTesterRole',
            abiKey: 'rolesUpdater',
            abiString: rolesUpdaterABI,
            contractParams: [_nonce, _testerCodeHash, _hashmessage, _v, _r, _s],
        }, callback)
    }
    /**
     * create a red package
     * @param amount - amount of red package
     * @param number - number of received
     * @param packetId - packet ID
     * @returns {Promise<PromiEvent<any>>}
     */
    createRedPackageContract(amount, number, packetId, callback = {}) {
        const model = 0;
        const _data = `0x${Utils.toHexAndPadLeft(number).slice(2)}${Utils.toHexAndPadLeft(model).slice(2)}${Utils.toHexAndPadLeft(packetId).slice(2)}`
        return this.triggerContract({
            methodName: 'transfer',
            abiKey: 'ring',
            abiString: ringABI,
            contractParams: [this.ABIs['redPackage'].address, amount, _data],
        }, callback)
    }
    /**
     * tansfer the Land
     * @param {address} from - sender address
     * @param {address} to - receiver
     * @param {string} tokenId - Land token ID
     * @returns {*}
     */
    async transferFromLand(to, tokenId, callback = {}) {
        if (!to) {
            return null
        }
        const from = await this.getCurrentAccount()
        return this.triggerContract({
            methodName: 'transferFrom',
            abiKey: 'land',
            abiString: landABI,
            contractParams: [from, to, '0x' + tokenId],
        }, callback)
    }
    /**
     *  claim resource on the Land
     * @param tokenId Land token Id.
     * @returns {Promise<PromiEvent<any>>}
     */
    claimLandResource(tokenId, callback = {}) {
        return this.triggerContract({
            methodName: 'claimLandResource',
            abiKey: 'apostleLandResource',
            abiString: landResourceABI,
            contractParams: ['0x' + tokenId],
        }, callback)
    }
    /**
     * Bid apostle by RING token
     * @param amount - RING amount
     * @param tokenId - Apostle token ID
     * @param referrer - refer address
     * @returns {Promise<PromiEvent<any>>}
     */
    apostleBid(amount, tokenId, referrer, callback = {}) {
        const finalReferrer = referrer
        const data =
            finalReferrer && Utils.isAddress(finalReferrer) ?
                `0x${tokenId}${Utils.padLeft(finalReferrer.substring(2), 64, '0')}` :
                `0x${tokenId}`
        return this.triggerContract({
            methodName: 'transfer',
            abiKey: 'ring',
            abiString: ringABI,
            contractParams: [this.ABIs['apostleAuction'].address, amount, data],
        }, callback)
    }
    /**
     * Receive apostle
     * @param tokenId - Apostle Token ID
     * @returns {Promise<PromiEvent<any>>}
     */
    apostleClaim(tokenId, callback = {}) {
        return this.triggerContract({
            methodName: 'claimApostleAsset',
            abiKey: 'apostleAuction',
            abiString: apostleAuctionABI,
            contractParams: ['0x' + tokenId],
        }, callback)
    }
    /**
     * Sell apostle
     * @param tokenId - Apostle Token ID
     * @param start - auction start price
     * @param end - auction end price
     * @param duration - duration time
     * @returns {Promise<PromiEvent<any>>}
     */
    async apostleSell(tokenId, start, end, duration, callback = {}) {
        const from = await this.getCurrentAccount()
        const _from = Utils.padLeft(from.slice(2), 64, '0')
        const _start = Utils.toHexAndPadLeft(start).slice(2)
        const _end = Utils.toHexAndPadLeft(end).slice(2)
        const _duration = Utils.toHexAndPadLeft(duration).slice(2)
        const data = `0x${_start}${_end}${_duration}${_from}`
        return this.triggerContract({
            methodName: 'approveAndCall',
            abiKey: 'land',
            abiString: landABI,
            contractParams: [this.ABIs['apostleAuction'].address, '0x' + tokenId, data],
        }, callback)
    }
    /**
     * Cancel the auction by apostle token ID
     * @param tokenId - apostle token ID
     * @returns {Promise<PromiEvent<any>>}
     */
    apostleCancelSell(tokenId, callback = {}) {
        return this.triggerContract({
            methodName: 'cancelAuction',
            abiKey: 'apostleAuction',
            abiString: apostleAuctionABI,
            contractParams: ['0x' + tokenId],
        }, callback)
    }
    /**
     *
     * @param tokenId
     * @param nftData
     * @returns {Promise<PromiEvent<any>>}
     */
    apostleRewardClaim(tokenId, nftData, callback = {}) {
        return this.triggerContract({
            methodName: 'takeBackNFT',
            abiKey: 'apostleTakeBack',
            abiString: apostleTakeBackABI,
            contractParams: [
                nftData.nonce,
                '0x' + tokenId,
                this.ABIs['land'].address,
                nftData.expireTime,
                nftData.hash_text,
                nftData.v,
                nftData.r,
                nftData.s
            ],
        }, callback)
    }
    /**
     * Apostle reproduction in own
     * @param tokenId
     * @param targetTokenId
     * @param amount
     * @returns {Promise<PromiEvent<any>>}
     */
    apostleBreed(tokenId, targetTokenId, amount, callback = {}) {
        return this.triggerContract({
            methodName: 'transfer',
            abiKey: 'ring',
            abiString: ringABI,
            contractParams: [
                this.ABIs["apostleBase"].address,
                amount,
                `0x${tokenId}${targetTokenId}`
            ]
        }, callback)
    }
    /**
     * Apostle reproduction
     * @param tokenId
     * @param targetTokenId
     * @param amount
     */
    apostleBreedBid(tokenId, targetTokenId, amount, callback = {}) {
        return this.triggerContract({
            methodName: 'transfer',
            abiKey: 'ring',
            abiString: ringABI,
            contractParams: [
                this.ABIs["apostleSiringAuction"].address,
                amount,
                `0x${tokenId}${targetTokenId}`
            ]
        }, callback)
    }
    /**
     * Apostle Breed Auction
     * @param tokenId - Apostle tokenId
     * @param start - start price
     * @param end - end price
     * @param duration - auction duration time
     * @returns {Promise<PromiEvent<any>>}
     */
    async apostleBreedAuction(tokenId, start, end, duration, callback = {}) {
        const from = await this.getCurrentAccount()
        const _from = Utils.padLeft(from.slice(2), 64, '0')
        const _start = Utils.toHexAndPadLeft(start).slice(2)
        const _end = Utils.toHexAndPadLeft(end).slice(2)
        const _duration = Utils.toHexAndPadLeft(duration).slice(2)
        const data = `0x${_start}${_end}${_duration}${_from}`
        return this.triggerContract({
            methodName: 'approveAndCall',
            abiKey: 'land',
            abiString: landABI,
            contractParams: [this.ABIs['apostleSiringAuction'].address, '0x' + tokenId, data],
        }, callback)
    }
    /**
     * Cancel apostle breed auction
     * @param tokenId
     * @returns {Promise<PromiEvent<any>>}
     */
    apostleCancelBreedAuction(tokenId, callback = {}) {
        return this.triggerContract({
            methodName: 'cancelAuction',
            abiKey: 'apostleSiringAuction',
            abiString: apostleSiringABI,
            contractParams: [
                '0x' + tokenId
            ]
        }, callback)
    }
    /**
     * Transfer apostle
     * @param toAddress
     * @param tokenId
     * @returns {Promise<PromiEvent<any>>}
     */
    async apostleTransfer(toAddress, tokenId, callback = {}) {
        const from = await this.getCurrentAccount()
        return this.triggerContract({
            methodName: 'transferFrom',
            abiKey: 'land',
            abiString: landABI,
            contractParams: [
                from, toAddress, '0x' + tokenId
            ]
        }, callback)
    }
    /**
     * Let apostle go to work
     * @param tokenId - Apostle tokenId
     * @param landTokenId - Land tokenId
     * @param element - ['gold', 'wood', 'water', 'fire' ,'soil']
     */
    apostleWork(tokenId, landTokenId, element, callback = {}) {
        const elementAddress = this.ABIs[element.toLowerCase() || 'token'].address
        return this.triggerContract({
            methodName: 'startMining',
            abiKey: 'apostleLandResource',
            abiString: landResourceABI,
            contractParams: [
                '0x' + tokenId, '0x' + landTokenId, elementAddress
            ]
        }, callback)
    }
    /**
     * Stop apostle mining
     * @param tokenId - Apostle tokenId
     */
    apostleStopWorking(tokenId, callback = {}) {
        return this.triggerContract({
            methodName: 'stopMining',
            abiKey: 'apostleLandResource',
            abiString: landResourceABI,
            contractParams: [
                '0x' + tokenId
            ]
        }, callback)
    }
    /**
     * Claim an apostle that expires at work
     * @param tokenId - Apostle TokenId
     * @returns {Promise<PromiEvent<any>>}
     */
    apostleHireClaim(tokenId, callback = {}) {
        return this.triggerContract({
            methodName: 'removeTokenUseAndActivity',
            abiKey: 'apostleTokenUse',
            abiString: tokenUseABI,
            contractParams: [
                '0x' + tokenId
            ]
        }, callback)
    }
    /**
     * Renting apostles to work
     * @param tokenId - Apostle TokenId
     * @param duration - Duration in second
     * @param price - Hire Price
     */
    apostleHire(tokenId, duration, price, callback = {}) {
        const address = this.ABIs['apostleLandResource'].address
        const _resourceAddress = Utils.padLeft(address.slice(2), 64, '0')
        const _price = Utils.toHexAndPadLeft(price).slice(2)
        const _duration = Utils.toHexAndPadLeft(duration).slice(2)
        const data = `0x${_duration}${_price}${_resourceAddress}`
        return this.triggerContract({
            methodName: 'approveAndCall',
            abiKey: 'land',
            abiString: landABI,
            contractParams: [
                this.ABIs['apostleTokenUse'].address,
                '0x' + tokenId,
                data
            ]
        }, callback)
    }
    /**
     * Cancel an apostle on Renting
     * @param tokenId - Apostle tokenId
     */
    apostleCancelHire(tokenId, callback = {}) {
        return this.triggerContract({
            methodName: 'cancelTokenUseOffer',
            abiKey: 'apostleTokenUse',
            abiString: tokenUseABI,
            contractParams: [
                '0x' + tokenId
            ]
        }, callback)
    }
    /**
     * Bid apostle on Renting
     * @param tokenId - Apostle tokenId
     * @param price - bid price
     */
    apostleHireBid(tokenId, price, callback = {}) {
        return this.triggerContract({
            methodName: 'transfer',
            abiKey: 'ring',
            abiString: ringABI,
            contractParams: [
                this.ABIs['apostleTokenUse'].address,
                price,
                `0x${tokenId}`
            ]
        }, callback)
    }
    /**
     * Apostle Born without element
     * @param motherTokenId
     */
    apostleBorn(motherTokenId, callback = {}) {
        return this.triggerContract({
            methodName: 'giveBirth',
            abiKey: 'apostleBase',
            abiString: apostleBaseABI,
            contractParams: [
                '0x' + motherTokenId,
                Utils.padLeft(0, 40, '0'),
                0
            ]
        }, callback)
    }
    /**
     * Apostle Born with element
     * @param motherTokenId
     * @param element
     * @param level
     * @param levelUnitPrice
     */
    apostleBornAndEnhance(
        motherTokenId,
        element,
        level,
        levelUnitPrice,
        callback = {}
    ) {
        return this.triggerContract({
            methodName: 'transfer',
            abiKey: element.toLowerCase(),
            abiString: ringABI,
            contractParams: [
                this.ABIs['apostleBase'].address,
                new BigNumber(level).times(new BigNumber(levelUnitPrice)).toFixed(),
                `0x${motherTokenId}${Utils.toHexAndPadLeft(level).slice(2)}`
            ]
        }, callback)
    }
    /**
     * Bind pet
     * @param originNftAddress
     * @param originTokenId
     * @param apostleTokenId
     * @returns {Promise<PromiEvent<any>>}
     */
    bridgeInAndTie(originNftAddress, originTokenId, apostleTokenId, callback = {}) {
        return this.triggerContract({
            methodName: 'bridgeInAndTie',
            abiKey: 'petBase',
            abiString: petBaseABI,
            contractParams: [originNftAddress, originTokenId, '0x' + apostleTokenId]
        }, callback)
    }
    /**
     * Unbind pet
     * @param petTokenId
     * @returns {Promise<PromiEvent<any>>}
     */
    untiePetToken(petTokenId, callback = {}) {
        return this.triggerContract({
            methodName: 'untiePetToken',
            abiKey: 'petBase',
            abiString: petBaseABI,
            contractParams: ['0x' + petTokenId]
        }, callback)
    }
    /**
     * buy lucky box
     * @param {*} buyer - Receiver
     * @param {*} goldBoxAmount - gold box amount
     * @param {*} silverBoxAmount - silver box amount
     */
    async buyLuckyBox(buyer, goldBoxAmount, silverBoxAmount, callback) {
        const luckyBoxInfo = await this.getLuckyBoxInfo()
        const cost = Utils.toBN(luckyBoxInfo[0]).muln(goldBoxAmount).add(Utils.toBN(luckyBoxInfo[1]).muln(silverBoxAmount))
        return this.triggerContract({
            methodName: 'buyBoxs',
            abiKey: 'luckybag',
            abiString: luckyBoxABI,
            contractParams: [buyer, goldBoxAmount, silverBoxAmount],
            sendParams: {
                value: cost
            }
        }, callback)
    }
    /**
     * lucky box information
     * @returns {Array} - promise -> [goldBoxPrice, silverBoxPrice, goldBoxAmountForSale, silverBoxAmountForSale, goldSaleLimit, silverSaleLimit]
     */
    getLuckyBoxInfo() {
        const _contract = new this._web3js.eth.Contract(luckyBoxABI, this.ABIs['luckybag'].address)
        return Promise.all([
            _contract.methods.goldBoxPrice().call(),
            _contract.methods.silverBoxPrice().call(),
            _contract.methods.goldBoxAmountForSale().call(),
            _contract.methods.silverBoxAmountForSale().call(),
            _contract.methods.goldSaleLimit().call(),
            _contract.methods.silverSaleLimit().call(),
        ])
    }
    /**
     * Number of lucky box already purchased at this address
     * @param {*} address - buyer
     * @returns {Array} - promise -> [goldSalesRecord, silverSalesRecord]
     */
    getLuckyBoxSalesRecord(address) {
        const _contract = new this._web3js.eth.Contract(luckyBoxABI, this.ABIs['luckybag'].address)
        return Promise.all([
            _contract.methods.goldSalesRecord(address).call(),
            _contract.methods.silverSalesRecord(address).call(),
        ])
    }
    /**
     * get furnace treasure price
     * @returns {} - promise -> {0: "1026000000000000000000", 1: "102000000000000000000", priceGoldBox: "1026000000000000000000", priceSilverBox: "102000000000000000000"}
     */
    getFurnaceTreasurePrice() {
        const _contract = new this._web3js.eth.Contract(itemTreasureABI, this.ABIs['itemTreasure'].address)
        return _contract.methods.getPrice().call()
    }
    getFurnaceTakeBackNonce(address) {
        const _contract = new this._web3js.eth.Contract(itemTakeBackABI, this.ABIs['itemTakeBack'].address)
        return _contract.methods.userToNonce(address).call()
    }
    /**
     * buy lucky box
     * @param {*} goldBoxAmount - gold box amount
     * @param {*} silverBoxAmount - silver box amount
     */
    async buyFurnaceTreasure(goldBoxAmount = 0, silverBoxAmount = 0, callback) {
        const treasurePrice = await this.getFurnaceTreasurePrice()
        const cost = Utils.toBN(treasurePrice.priceGoldBox).muln(goldBoxAmount).add(Utils.toBN(treasurePrice.priceSilverBox).muln(silverBoxAmount))
        // Function: transfer(address _to, uint256 _value, bytes _data) ***
        // data
        // 0000000000000000000000000000000000000000000000000000000000000001 gold box amount
        // 0000000000000000000000000000000000000000000000000000000000000002 silver box amount
        const data = Utils.toTwosComplement(goldBoxAmount) + Utils.toTwosComplement(silverBoxAmount).substring(2, 66)
        return this.triggerContract({
            methodName: 'transfer',
            abiKey: 'ring',
            abiString: ringABI,
            contractParams: [this.ABIs['itemTreasure'].address, cost.toString(10), data],
            sendParams: {
                value: 0
            }
        }, callback)
    }
     /**
     *  open furnace treasure
     * @returns {Promise<PromiEvent<any>>}
     */
    openFurnaceTreasure({
        boxIds,
        amounts,
        hashmessage,
        v,
        r,
        s
    }, callback = {}) {
        // During the process of opening the treasure chest, there is the logic of randomly gifting rings, 
        // which leads to inaccurate gas estimation, so manually set it to avoid out of gas.
        // https://etherscan.io/tx/0xe71f54aee8f7ab1dd15df955d09c79af5060f20e91c0c5ecfcf17f20c9bf02b3
        // https://etherscan.io/tx/0x7b04df9b55f33b6edcc402a5733dbc753a6bbe2f78af7c7bef6f3f4d8dce7491
        // no return ring - gas used - 229,289
        // https://etherscan.io/tx/0x4e1fc1dcec64bb497405126e55ab743368f1cb1cede945936937e0cde1d254e7
        // prize ring - gas used - 254,776 
        // https://etherscan.io/tx/0xd2b3f05b19e74627940edfe98daee31eeab84b67e88dcf0e77d595430b3b1afc
        let gasLimit = new BigNumber(amounts[0]).lt('1000000000000000000000') ? new BigNumber(260000) : new BigNumber(300000);
        if(amounts.length > 1) {
            for (let index = 1; index < amounts.length; index++) {
                const amount = amounts[index];
                gasLimit = gasLimit.plus(new BigNumber(amount).lt('1000000000000000000000') ? new BigNumber(260000) : new BigNumber(260000));
            }
        }
        
        return this.triggerContract({
            methodName: "openBoxes",
            abiString: itemTakeBackABI,
            contractParams: [
                boxIds,
                amounts,
                hashmessage,
                v,
                r,
                s
            ],
            sendParams: {
                value: 0,
                gasLimit: gasLimit.toFixed(0)
            },
            abiKey: "itemTakeBack",
        }, callback);
    }
    checkFurnaceTreasureStatus(id) {
        const _contract = new this._web3js.eth.Contract(itemTakeBackABI, this.ABIs['itemTakeBack'].address)
        return _contract.methods.ids(id).call()
    }
    /**
     * Returns the amount of RING owned by account
     * @param {*} address 
     */
    getRingBalance(address) {
        const _contract = new this._web3js.eth.Contract(ringABI, this.ABIs['ring'].address)
        return _contract.methods.balanceOf(address).call()
    }
    /**
     * Returns the amount of KTON owned by account
     * @param {*} address 
     */
    getKtonBalance(address) {
        const _contract = new this._web3js.eth.Contract(ktonABI, this.ABIs['kton'].address)
        return _contract.methods.balanceOf(address).call()
    }
    /**
     * Returns the amount of tokens owned by account
     * @param {*} account 
     * @param {*} contractAddress 
     */
    getTokenBalance(account, contractAddress) {
        const _contract = new this._web3js.eth.Contract(ringABI, contractAddress)
        return _contract.methods.balanceOf(account).call()
    }
    /**
     * Get total supply of erc20 token
     * @param {*} contractAddress Erc20 contract address
     */
    getTokenTotalSupply(contractAddress) {
        const _contract = new this._web3js.eth.Contract(ringABI, contractAddress)
        return _contract.methods.totalSupply().call()
    }
    /**
     * transfer evo land 721 object
     * @param {*} to recevier
     * @param {*} tokenId 721 tokenid
     * @param {*} callback 
     */
    async transferFromObjectOwnership(to, tokenId, callback = {}) {
        if (!to) {
            return null
        }
        const from = await this.getCurrentAccount()
        return this.triggerContract({
            methodName: 'transferFrom',
            abiKey: 'land',
            abiString: landABI,
            contractParams: [from, to, '0x' + tokenId],
        }, callback)
    }
    /**
     * Get uniswap Token info by lowercase symbol
     * 
     * Token - https://uniswap.org/docs/v2/SDK/token/
     * 
     * @param {*} tokenType  ring kton gold wood water fire soil
     */
    getUniswapToken(tokenType) {
        switch (tokenType.toLowerCase()) {
            case 'ring':
                return new Token(parseInt(this.env.CONTRACT.NETWORK), this.env.CONTRACT.TOKEN_RING, 18, "RING", "Darwinia Network Native Token");
            case 'kton':
                return new Token(parseInt(this.env.CONTRACT.NETWORK), this.env.CONTRACT.TOKEN_KTON, 18, "KTON", "KTON");
            case 'gold':
                return new Token(parseInt(this.env.CONTRACT.NETWORK), this.env.CONTRACT.TOKEN_ELEMENT_GOLD, 18, "GOLD", "GOLD");
            case 'wood':
                return new Token(parseInt(this.env.CONTRACT.NETWORK), this.env.CONTRACT.TOKEN_ELEMENT_WOOD, 18, "WOOD", "WOOD");
            case 'water':
                return new Token(parseInt(this.env.CONTRACT.NETWORK), this.env.CONTRACT.TOKEN_ELEMENT_WATER, 18, "WATER", "WATER");
            case 'fire':
                return new Token(parseInt(this.env.CONTRACT.NETWORK), this.env.CONTRACT.TOKEN_ELEMENT_FIRE, 18, "FIRE", "FIRE");
            case 'soil':
                return new Token(parseInt(this.env.CONTRACT.NETWORK), this.env.CONTRACT.TOKEN_ELEMENT_SOIL, 18, "SOIL", "SOIL");
            default:
                break;
        }
    }
    /**
     * Get uniswap pair info
     * @param {*} tokenA token address or lowercase symbol (ring kton gold wood water fire soil)
     * @param {*} tokenB token address or lowercase symbol (ring kton gold wood water fire soil)
     * @returns { pair } pair - https://uniswap.org/docs/v2/SDK/pair/
     */
    async getDerivedPairInfo(tokenA, tokenB) {
        if(!tokenA || !tokenB) {
            return;
        }
        const currencyA = this.getUniswapToken(tokenA);
        const currencyB = this.getUniswapToken(tokenB);
        const pair = await Fetcher.fetchPairData(currencyA, currencyB);
        return pair;
    }
    /**
     * Support for addUniswapLiquidity function, and the return router pair instances and elements are returned.
     * 
     * Only one account needs to be provided, and the other quantity needs to be provided according to the current pool price
     * 
     * tokenType - token address or lowercase symbol (ring kton gold wood water fire soil)
     * 
     * amount - amount in WEI
     * 
     * @param {*} param0 {token: tokenAType, amount: amountA}  
     * @param {*} param1 {token: tokenBType, amount: amountB}
     * @returns {*} {pair, parsedAmounts}  pair - https://uniswap.org/docs/v2/SDK/pair/   parsedAmounts - {token0address: amount, token1address: amount}
     */
    async getDerivedMintInfo({token: tokenAType, amount: amountA}, {token: tokenBType, amount: amountB}) {
        const pair = await this.getDerivedPairInfo(tokenAType, tokenBType);
        const totalSupply = new TokenAmount(pair.liquidityToken, await this.getTokenTotalSupply(pair.liquidityToken.address));
        const independentToken = amountA ? 
        { token: this.getUniswapToken(tokenAType), amount: amountA} : 
        { token: this.getUniswapToken(tokenBType), amount: amountB};
        const parsedAmounts = {
            [pair.liquidityToken.address]: totalSupply,
            [pair.token0.address]: new TokenAmount(pair.token0, independentToken.token.equals(pair.token0) ? JSBI.BigInt(independentToken.amount) : pair.priceOf(independentToken.token).quote(new CurrencyAmount(independentToken.token, JSBI.BigInt(independentToken.amount))).raw),
            [pair.token1.address]: new TokenAmount(pair.token1, independentToken.token.equals(pair.token1) ? JSBI.BigInt(independentToken.amount) : pair.priceOf(independentToken.token).quote(new CurrencyAmount(independentToken.token, JSBI.BigInt(independentToken.amount))).raw),
        }
        return { pair, parsedAmounts }
    }
    /**
     * Support for removeUniswapLiquidity function, assuming removal percentage of liquidity and the return router pair instances and elements are returned.
     * 
     * tokenType - token address or lowercase symbol (ring kton gold wood water fire soil)
     * 
     * pair - https://uniswap.org/docs/v2/SDK/pair/
     * 
     * TokenAmount - https://github.com/Uniswap/uniswap-sdk/blob/v2/src/entities/fractions/tokenAmount.ts
     * 
     * parsedAmounts - {
     * 
     *  LIQUIDITY_PERCENT: percent,
     * 
     *  liquidityTokenAddress: TokenAmount,
     * 
     *  token0Address: TokenAmount,
     * 
     *  token1Address: TokenAmount
     * 
     * }
     * 
     * @param {*} tokenAType 
     * @param {*} tokenBType 
     * @param {*} liquidityValue The value of liquidity removed
     * @param {*} to 
     * @returns {*} {pair, parsedAmounts}
     */
    async getDerivedBurnInfo(tokenAType, tokenBType, liquidityValue, to) {
        const pair = await this.getDerivedPairInfo(tokenAType, tokenBType);
        if(!to) {
            to = await this.getCurrentAccount();    
        }
        const lpBalanceStr = await this.getTokenBalance(to, pair.liquidityToken.address);
        const userLiquidity = new TokenAmount(pair.liquidityToken, JSBI.BigInt(lpBalanceStr));
        const totalSupply = new TokenAmount(pair.liquidityToken, await this.getTokenTotalSupply(pair.liquidityToken.address));
        const liquidityValueA = pair &&
        totalSupply &&
        userLiquidity &&
        pair.token0 && new TokenAmount(pair.token0, pair.getLiquidityValue(pair.token0, totalSupply, userLiquidity, false).raw);
        const liquidityValueB = pair &&
        totalSupply &&
        userLiquidity &&
        pair.token1 && new TokenAmount(pair.token1, pair.getLiquidityValue(pair.token1, totalSupply, userLiquidity, false).raw);
        const percentToRemove = new Percent(JSBI.BigInt(liquidityValue), userLiquidity.raw);
        const parsedAmounts = {
            LIQUIDITY_PERCENT: percentToRemove,
            [pair.liquidityToken.address]: new TokenAmount(userLiquidity.token, percentToRemove.multiply(userLiquidity.raw).quotient),
            [pair.token0.address]: new TokenAmount(pair.token0, percentToRemove.multiply(liquidityValueA.raw).quotient),
            [pair.token1.address]: new TokenAmount(pair.token1, percentToRemove.multiply(liquidityValueB.raw).quotient),
        }
        return { pair, parsedAmounts }
    }
    /**
     * Adds liquidity to an ERC-20⇄ERC-20 pool
     * 
     * msg.sender should have already given the router an allowance of at least amount on tokenA/tokenB.
     * 
     * Always adds assets at the ideal ratio, according to the price when the transaction is executed.
     * 
     * @param {*} param0 {token: tokenAType, amount: amountA}
     * @param {*} param1 {token: tokenBType, amount: amountB}
     * @param {*} to Recipient of the liquidity tokens.
     * @param {*} slippage The amount the price moves in a trading pair between when a transaction is submitted and when it is executed.
     * @param {*} callback 
     */
    async addUniswapLiquidity({token: tokenAType, amount: amountA}, {token: tokenBType, amount: amountB}, to, slippage = 100, callback = {}) {
        const { pair, parsedAmounts } = await this.getDerivedMintInfo({token: tokenAType, amount: amountA}, {token: tokenBType, amount: amountB});
        if(!pair || !pair.token0.address || !pair.token1.address) {
            return;
        }
        if(!to) {
            to = await this.getCurrentAccount();    
        }
        const amountsMin = {
            [pair.token0.address]: UniswapUtils.calculateSlippageAmount(parsedAmounts[pair.token0.address].raw, slippage)[0],
            [pair.token1.address]: UniswapUtils.calculateSlippageAmount(parsedAmounts[pair.token1.address].raw, slippage)[0]
        }
        const deadline = Math.floor(Date.now() / 1000) + 60 * 120 // 120 minutes from the current Unix time
        //  https://uniswap.org/docs/v2/smart-contracts/router02/#addliquidity
        return this.triggerContract({
            methodName: 'addLiquidity',
            abiKey: 'uniswapExchange',
            abiString: uniswapExchangeABI,
            contractParams: [
                pair.token0.address,
                pair.token1.address,
                parsedAmounts[pair.token0.address].raw.toString(),
                parsedAmounts[pair.token1.address].raw.toString(),
                amountsMin[pair.token0.address].toString(),
                amountsMin[pair.token1.address].toString(),
                to,
                deadline
            ],
            sendParams: {
                value: 0
            }
        }, callback)
    }
    /**
     * Removes liquidity from an ERC-20⇄ERC-20 pool.
     * 
     * msg.sender should have already given the router an allowance of at least liquidity on the pool.
     * 
     * @param {*} tokenAType A pool token.
     * @param {*} tokenBType A pool token.
     * @param {*} liquidityValue The value of liquidity tokens to remove.
     * @param {*} to Recipient of the underlying assets.
     * @param {*} slippage The amount the price moves in a trading pair between when a transaction is submitted and when it is executed.
     * @param {*} callback 
     */
    async removeUniswapLiquidity(tokenAType, tokenBType, liquidityValue, to, slippage = 100, callback = {}) {
        if(!to) {
            to = await this.getCurrentAccount();    
        }
        const { pair, parsedAmounts } = await this.getDerivedBurnInfo(tokenAType, tokenBType, liquidityValue, to);
        if(!pair || !pair.token0.address || !pair.token1.address) {
            return;
        }
        const amountsMin = {
            [pair.token0.address]: UniswapUtils.calculateSlippageAmount(parsedAmounts[pair.token0.address].raw, slippage)[0],
            [pair.token1.address]: UniswapUtils.calculateSlippageAmount(parsedAmounts[pair.token1.address].raw, slippage)[0]
        }
        const deadline = Math.floor(Date.now() / 1000) + 60 * 120 // 20 minutes from the current Unix time
        // https://uniswap.org/docs/v2/smart-contracts/router02/#removeliquidity
        return this.triggerContract({
            methodName: 'removeLiquidity',
            abiKey: 'uniswapExchange',
            abiString: uniswapExchangeABI,
            contractParams: [
                pair.token0.address,
                pair.token1.address,
                parsedAmounts[pair.liquidityToken.address].raw.toString(),
                amountsMin[pair.token0.address].toString(),
                amountsMin[pair.token1.address].toString(),
                to,
                deadline
            ],
            sendParams: {
                value: 0
            }
        }, callback)
    }
    /**
     * Use nft and elements or LP tokens in the furnace formula to the props.
     * @param {*} formulaIndex Formula for props - https://github.com/evolutionlandorg/furnace/blob/dev/src/Formula.sol
     * @param {*} majorTokenId ERC721 token Id
     * @param {*} minorTokenAddress Elements or LP tokens contract address
     * @param {*} callback callback
     */
    enchantFurnanceProps( formulaIndex, majorTokenId, minorTokenAddress, callback = {}) {
        return this.triggerContract({
            methodName: 'enchant',
            abiKey: 'furnaceItemBase',
            abiString: furnaceItemBaseABI,
            contractParams: [
                formulaIndex,
                majorTokenId,
                minorTokenAddress
            ],
            sendParams: {
                value: 0
            }
        }, callback)
    }
    /**
     * Disenchant furnace props, and will get elements or LP and nft
     * @param {*} propsTokenId Token Id of the Props
     * @param {*} depth Supports one-time decomposition of high-level props. If a prop is in the second level, it needs to be restored to its original state, and the depth needs to be passed in 2
     * @param {*} callback 
     */
    disenchantFurnanceProps( propsTokenId, depth, callback = {}) {
        return this.triggerContract({
            methodName: 'disenchant',
            abiKey: 'furnaceItemBase',
            abiString: furnaceItemBaseABI,
            contractParams: [
                propsTokenId,
                depth
            ],
            sendParams: {
                value: 0
            }
        }, callback)
    }
    /**
     * Transfers the ownership of an NFT from one address to another address
     * @param {*} from The current owner of the NFT
     * @param {*} to The new owner
     * @param {*} tokenId The NFT to transfer
     * @param {*} callback 
     */
    safeTransferFromEvoErc721(from, to, tokenId, callback = {}) {
        return this.triggerContract({
            methodName: 'safeTransferFrom',
            abiKey: 'objectOwnership',
            abiString: this.ABIs['erc721'].abi,
            contractParams: [
                from,
                to,
                tokenId
            ]
        }, callback)
    }
    /**
     * Equip function, A NFT can equip to EVO Bar (LandBar or ApostleBar).
     * @param {*} tokenId Land token Id which to be quiped.
     * @param {*} resource Which resouce appply to.
     * @param {*} index Index of the Bar.
     * @param {*} token Props token address which to quip.
     * @param {*} id Props token Id which to quip.
     * @param {*} callabck 
     */
    async equipLandResource(tokenId, resource, index, token, id, callback = {}) {
        const resourceAddress = await this.getContractAddress(resource);
        return this.triggerContract({
            methodName: 'equip',
            abiKey: 'apostleLandResource',
            abiString: this.ABIs['apostleLandResource'].abi,
            contractParams: [
                tokenId, resourceAddress, index, token, id
            ]
        }, callback) 
    }
    /**
     * Divest the props on the index slot on the tokenid land
     * @param {*} tokenId The tokenId of land
     * @param {*} index The index slot
     * @param {*} callback 
     */
    divestLandProps(tokenId, index, callback = {}) {
        return this.triggerContract({
            methodName: 'divest',
            abiKey: 'apostleLandResource',
            abiString: this.ABIs['apostleLandResource'].abi,
            contractParams: [
                tokenId, index
            ]
        }, callback) 
    }
    /**
     *  claim resource on the Land
     * @param tokenAddress The nft of props contract address
     * @param tokenId Land token Id
     * @returns {Promise<PromiEvent<any>>}
     */
    claimFurnaceItemResource(tokenAddress, tokenId, callback = {}) {
        return this.triggerContract({
            methodName: 'claimItemResource',
            abiKey: 'apostleLandResource',
            abiString: landResourceABI,
            contractParams: [tokenAddress, Utils.pad0x(tokenId)],
        }, callback)
    }
    estimateGas(method, address, gasPrice, value = 0) {
        if (!this._web3js) return;
        return (method || this._web3js.eth).estimateGas({ from: address, gasLimit: 0, gasPrice: gasPrice, value });
    }
    getNetworkId() {
        return this._web3js.eth.net.getId()
    }
    /**
     * check address info
     * @param address - Ethereum address
     */
    checkAddress(address) {
        return this.ClientFetch.$get('/api/verified_wallet', {
            wallet: address
        })
    }
    challengeAddress(address) {
        return this.ClientFetch.$get('/api/challenge', {
            wallet: address
        })
    }
    async _sign({
        data,
        name
    }, from) {
        let signature;
        try {
            signature = await this._web3js.eth.personal.sign(
                name + " " + data,
                from
            );
        } catch (e) {
        }
        return {
            address: from,
            signature
        };
    }
    /**
     * Login Evolution Land
     * @param address - Ethereum address
     * @returns {Promise<*>}
     */
    async login(address) {
        return new Promise((resolve, reject) => {
            this.challengeAddress(address).then((res) => {
                const {
                    code,
                    data,
                    name
                } = res
                if (code === 0) {
                    this._sign({
                        data,
                        name
                    }, address)
                        .then(info => {
                            if (info.signature) {
                                this.ClientFetch.$post('/api/login', {
                                    wallet: address,
                                    sign: info.signature
                                }).then((res) => {
                                    resolve(res)
                                })
                            } else {
                                reject({
                                    code,
                                    data
                                })
                            }
                        })
                        .catch(err => reject(err))
                }
            })
        })
    }
}
export default EthereumEvolutionLand