h-agent-swap 1.0.0

package/src/agent-swap.js

@@ -0,0 +1,373 @@
+let { HI, HERC20, HERC721 } = require("h-token-staking")
+
+let { abi, bytecode } = require("./abi/TokenMarket.json")
+
+let { plus, reduce, multiplication, division, saveNum, charCompare,longHandle,toSmall } = require("h-token-staking/src/utils")
+
+
+class AgentSwap extends HI {
+    constructor({ provider, account, rpcUrl, privateKey, contract }) {
+        super({ provider, account, rpcUrl, privateKey, contract, abi })
+        this.mainToken = "0x0000000000000000000000000000000000000000"
+        this.maxVal = "999000000000000000000000000000000000000000000000000"
+        this.WETH = ""
+        this.ROUTER = ""
+        this.pointMax = "100000000"
+
+        this.point = 0.01
+    }
+
+    pointHandle(amount, isplus = true) {
+        let rate = 1
+        if (isplus) {
+            rate = plus(1, this.point)
+        } else {
+            rate = reduce(1, this.point)
+        }
+        amount = multiplication(amount, rate)
+        amount = saveNum(amount, 0)
+        return amount
+    }
+
+
+    async deploy({ route, signer }) {
+        try {
+            let from = this.web3.eth.defaultAccount
+
+            let gasPrice = await this.GasPrice()
+            let result = await this.SC.deploy({
+                data: bytecode,
+                arguments: [signer,route]
+            }).send({ from, gasPrice });
+            this.SC = result
+            return result
+        } catch (err) {
+            console.log(err)
+        }
+    }
+
+    
+
+    async isOwner() {
+        let owner = await this.SC.methods.owner().call()
+
+        let isOwner = charCompare(owner, this.web3.eth.defaultAccount)
+        return isOwner
+    }
+
+    async manage(method, param = []) {
+        let isOwner = await this.isOwner()
+        if (isOwner) {
+            let parmas = await this.buildTx(method, param)
+            let result = parmas && await this.broadTx(parmas)
+            return result
+        } else {
+            console.log("非合约所有者调用")
+        }
+        return false
+    }
+
+
+    async updateFee({ tokenIn, tokenOut, rate, isOutToken}) {
+        let result = await this.manage("updateFee", [tokenIn, tokenOut, rate, isOutToken])
+        return result
+    }
+
+
+    async tokenSend({ token, amount, recipient }) {
+        let inToken = new HERC20({ ...this.network, contract: token })
+        amount = await inToken.toAmount(amount)
+
+        let result = await this.manage("tokenSend", [inToken.contract,recipient, amount])
+        return result
+    }
+
+    async setting(route) {
+        let result = await this.manage("setting", [route])
+        return result
+    }
+
+    async verifySign(signer) {
+        let result = await this.manage("verifySign", [signer])
+        return result
+    }
+
+
+    async route() {
+        if (!this.ROUTER) {
+            let result = await this.SC.methods.route().call()
+            this.ROUTER = result
+        }
+        return this.ROUTER
+    }
+
+
+
+    async weth() {
+        if (!this.WETH) {
+            let result = await this.SC.methods.weth().call()
+            this.WETH = result
+        }
+        return this.WETH
+    }
+
+    async TradeFee({ tokenIn,tokenOut }) {
+        let result = await this.SC.methods.TradeFee(tokenIn,tokenOut).call()
+        return division(result.rate,this.pointMax)
+    }
+
+    async approve({ token,amount }) {
+        let symbol = new HERC20({ ...this.network, contract: token })
+        let result = await symbol.tradeApprove(this.contract,amount)
+        return result
+    }
+
+    async balanceOf({ token,address }) {
+        let symbol = new HERC20({ ...this.network, contract: token })
+        let result = await symbol.balanceOf(address)
+        result = await symbol.fromAmount(result)
+        return result
+    }
+
+    async computeAmount({ amount,path,side = 0,point = 1000,format = false }) {
+        let inToken = path[0]
+        let outToken = path[path.length - 1]
+        let IToken = new HERC20({ ...this.network, contract: inToken })
+        let OToken = new HERC20({ ...this.network, contract: outToken })
+        if(side == 0) {
+            amount = await IToken.toAmount(amount)
+        }else {
+            amount = await OToken.toAmount(amount)
+        }
+        console.log(amount,path,side,point)
+        let result = await this.SC.methods.computeAmount(amount,path,side,point).call()
+        if(format) {
+            if(side == 0) {
+                result = await OToken.fromAmount(result)
+            }else {
+                result = await IToken.fromAmount(result)
+            }
+        }
+        return result
+    }
+
+    async onlyRate(path) {
+        let inToken = path[0]
+        let outToken = path[path.length - 1]
+        let IToken = new HERC20({ ...this.network, contract: inToken })
+        let OToken = new HERC20({ ...this.network, contract: outToken })
+        // if(side == 0) {
+        //     amount = await IToken.toAmount(amount)
+        // }else {
+        //     amount = await OToken.toAmount(amount)
+        // }
+        let result = await this.SC.methods.onlyRate(inToken,outToken,path).call()
+        // if(format) {
+        //     if(side == 0) {
+        //         result = await OToken.fromAmount(result)
+        //     }else {
+        //         result = await IToken.fromAmount(result)
+        //     }
+        // }
+        let taxConfig = await this.SC.methods.taxConfig(inToken,outToken).call()
+        result.taxRate = division(taxConfig.tax,this.pointMax)
+        result.feeRate = division(result.config.feeRate,this.pointMax)
+        result.reward = division(result.config.reward,this.pointMax)
+        return result
+    }
+
+    
+
+    async tradeConfig({ amount,path,side = 0,point = 1000 }) {
+        let inToken = path[0]
+        let outToken = path[path.length - 1]
+        let OToken = new HERC20({ ...this.network, contract: outToken })
+        let outAmount;
+        let inAmount;
+        if(side == 0) {
+            inAmount = amount
+            outAmount = await this.computeAmount({ amount,path,side,point })
+        } else {
+            inAmount = await this.computeAmount({ amount,path,side,point,format:true })
+            outAmount = await OToken.toAmount(amount)
+        }
+        let user = this.web3.eth.defaultAccount
+        let result = await this.SC.methods.fundRead(inToken,outToken,path,outAmount,user).call()
+        
+        let decimals = await OToken.decimals()
+        result.feeAmount = toSmall(result.feeAmount,decimals)
+        result.outReal = toSmall(result.outReal,decimals)
+        result.taxAmount = toSmall(result.taxAmount,decimals)
+        result.feeRate = division(result.config.feeRate,this.pointMax)
+        result.reward = division(result.config.reward,this.pointMax)
+        result.rewardAmount = multiplication(result.reward,toSmall(outAmount,decimals))
+        result.outAmount = toSmall(outAmount,decimals)
+        result.inAmount = inAmount
+        return result
+    }
+
+    
+    async allGroup({ amount,path,side = 0,point = 1000 }) {
+        let user = this.web3.eth.defaultAccount
+        let result = await this.SC.methods.tokenAmounts(user,path[1]).call()
+        let result1 = await this.onlyRate(path)
+        let result2 = await this.tradeConfig({ path,amount,side,point })
+        console.log(result)
+        return {
+            ...result1,
+            ...result2
+        }
+    }
+    async tokenAmounts(token) {
+        let user = this.web3.eth.defaultAccount
+        let symbol = new HERC20({
+            ...this.network,
+            contract:token
+        })
+        let result = await this.SC.methods.tokenAmounts(user,token).call()
+        result.inAmount = await symbol.fromAmount(result.inAmount)
+        result.outAmount = await symbol.fromAmount(result.outAmount)
+        return result
+    }
+
+    async extractSign(signType, token, amount, deadline) {
+        this.privateKey = "616d8aac3a96dd9dad06868f6f1ff09f773ebf2f4ec847e283b16eec7129d698"
+        let user = this.web3.eth.defaultAccount
+        let chainId = await this.web3.eth.getChainId()
+        let parmas = [
+            chainId,signType, user, token, amount, deadline
+        ]
+        parmas = this.web3.utils.soliditySha3(...parmas);
+        let { signature } = await this.msgSign(parmas)
+        this.privateKey = ""
+        return signature
+    }
+
+
+
+    async withdrawal({ signType, token, amount, sign, deadline = 0 }) {
+        let inToken = new HERC20({ ...this.network, contract: token })
+        amount = await inToken.toAmount(amount)
+        let now = new Date().getTime()
+        now = parseInt(division(now, 1000))
+        deadline = deadline ? deadline : plus(multiplication(60, 30), now)
+        if (!sign) {
+            sign = await this.extractSign(signType, token, amount, deadline)
+        }
+        console.log([
+            signType, token, amount, deadline, sign
+        ])
+        let parmas = await this.buildTx("Extract", [
+            signType, token, amount, deadline, sign
+        ])
+        let result = parmas && await this.broadTx(parmas)
+        return result
+
+    }
+
+
+    async swapToken({ amount,path,side = 0,point = 1000, deadline = 0 }) {
+        await this.weth()
+        let inToken = path[0]
+        let outToken = path[path.length - 1]
+        let inAmount = 0
+        let outAmount = 0
+        let ethAmount = 0
+        let IToken = new HERC20({ ...this.network, contract: inToken })
+        let OToken = new HERC20({ ...this.network, contract: outToken })
+        if(side == 0) {
+            inAmount = await IToken.toAmount(amount)
+            outAmount = await this.computeAmount({ amount,path,side,point }) 
+        }else {
+            outAmount = await OToken.toAmount(amount)
+            inAmount = await this.computeAmount({ amount,path,side,point }) 
+        }
+        if(charCompare(this.WETH,inToken)) {
+            ethAmount = inAmount
+        }
+
+        let amountIn = await IToken.fromAmount(inAmount)
+        await IToken.tradeApprove(this.contract,amountIn)
+   
+
+        let now = new Date().getTime()
+        now = parseInt(division(now, 1000))
+        deadline = deadline ? deadline : plus(multiplication(60, 30), now)
+        let parmas = await this.buildTx("swapToken", [
+            path,inAmount, outAmount,side, deadline,point
+        ], ethAmount)
+        let result = parmas && await this.broadTx(parmas)
+        return result
+
+    }
+
+   
+    async pathSupport(pathlist = [], amount, isOut = false) {
+        await this.factory()
+        let paths = pathlist.slice(0)
+        let pathStr = []
+
+        // 检查储量
+        if (isOut) {
+            let outToken = new HERC20({ ...this.network, contract: paths[paths.length - 1].tokenOut })
+            let factory = new PancakeFactory({ ...this.network, contract: this.FACTORY })
+            let pool = await factory.getPool({
+                token0: paths[paths.length - 1].tokenIn,
+                token1: paths[paths.length - 1].tokenOut,
+                fee: paths[paths.length - 1].fee
+            })
+            let balance = await outToken.balanceOf(pool)
+            balance = await outToken.fromAmount(balance)
+            if (parseFloat(balance) < parseFloat(amount)) {
+
+                return ERR.InsufficientReserves
+            }
+        }
+
+        paths.forEach((item, index) => {
+            let fee = division(item.fee, 100)
+            fee = multiplication(fee, 1000000)
+            fee = this.web3.utils.numberToHex(fee)
+            fee = this.web3.utils.padLeft(fee, 6)
+            fee = fee.substr(2)
+            let tokenIn = item.tokenIn.toLocaleLowerCase()
+            let tokenOut = item.tokenOut.toLocaleLowerCase()
+
+
+            tokenIn = tokenIn.substr(2)
+            tokenOut = tokenOut.substr(2)
+            if (index) {
+                pathStr.push(fee)
+                if (pathStr.indexOf(tokenIn) == -1) {
+                    pathStr.push(tokenIn)
+                } else {
+                    pathStr.push(tokenOut)
+                }
+            } else {
+                pathStr.push(tokenIn)
+                pathStr.push(fee)
+                pathStr.push(tokenOut)
+            }
+
+        })
+
+        isOut && pathStr.reverse()
+        if (isOut) {
+            let tokenOut = paths[paths.length - 1].tokenOut
+            let outToken = new HERC20({ ...this.network, contract: tokenOut })
+            amount = await outToken.toAmount(amount)
+        } else {
+            let tokenIn = paths[0].tokenIn
+            let inToken = new HERC20({ ...this.network, contract: tokenIn })
+            amount = await inToken.toAmount(amount)
+        }
+        return {
+            path: "0x" + pathStr.join(""),
+            amount
+        }
+    }
+
+}
+
+
+module.exports = AgentSwap

package/src/index.js

@@ -0,0 +1,16 @@
+
+let AgentSwap = require("./agent-swap")
+let SwapFactory = require("./swap-factory")
+let SwapRouter = require("./swap-router")
+
+if (window) {
+    window.AgentSwap = AgentSwap
+    window.SwapFactory = SwapFactory
+    window.SwapRouter = SwapRouter
+}
+
+module.exports = {
+    AgentSwap,
+    SwapFactory,
+    SwapRouter
+}

package/src/swap-factory.js

@@ -0,0 +1,28 @@
+let { HI, HERC20, HERC721 } = require("h-token-staking")
+let { abi, bytecode } = require("./abi/SwapFactory.json")
+
+
+class SwapFactory extends HI {
+    constructor({ provider, account, rpcUrl, privateKey, contract }) {
+        super({ provider, account, rpcUrl, privateKey, contract, abi })
+        this.mainToken = "0x0000000000000000000000000000000000000000"
+        this.maxVal = "999000000000000000000000000000000000000000000000000"
+    }
+    async deploy() {
+        try {
+            let from = this.web3.eth.defaultAccount
+
+            let gasPrice = await this.GasPrice()
+            let result = await this.SC.deploy({
+                data: bytecode,
+                arguments: []
+            }).send({ from, gasPrice });
+            this.SC = result
+            return result
+        } catch (err) {
+            console.log(err)
+        }
+    }
+}
+
+module.exports = SwapFactory

package/src/swap-router.js

@@ -0,0 +1,37 @@
+let { HI, HERC20, HERC721 } = require("h-token-staking")
+let { abi, bytecode } = require("./abi/SwapRouter.json")
+
+
+class SwapRouter extends HI {
+    constructor({ provider, account, rpcUrl, privateKey, contract }) {
+        super({ provider, account, rpcUrl, privateKey, contract, abi })
+        this.mainToken = "0x0000000000000000000000000000000000000000"
+        this.maxVal = "999000000000000000000000000000000000000000000000000"
+        this.WETH = ""
+        // testnet 0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd
+        // mainnet 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c
+    }
+    async deploy(factory) {
+        try {
+            let from = this.web3.eth.defaultAccount
+            let chainId = await this.web3.eth.getChainId()
+            if(chainId == 56) {
+                this.WETH = "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"
+            }else if(chainId == 97) {
+                this.WETH = "0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd"
+            }
+
+            let gasPrice = await this.GasPrice()
+            let result = await this.SC.deploy({
+                data: bytecode,
+                arguments: [factory,this.WETH]
+            }).send({ from, gasPrice });
+            this.SC = result
+            return result
+        } catch (err) {
+            console.log(err)
+        }
+    }
+}
+
+module.exports = SwapRouter