h-agent-swap 2.0.0 → 2.1.2

package/src/agent-swap.js

@@ -4,10 +4,10 @@ let { abi, bytecode } = require("./abi/TokenMarket.json")
 
 let { plus, reduce, multiplication, division, saveNum, charCompare,longHandle,toSmall } = require("h-token-staking/src/utils")
 const ERC20 = require("h-token-staking/src/ERC20")
-
+let SwapLP = require("./swap-pair")
 
 class AgentSwap extends HI {
-    constructor({ provider, account, rpcUrl, privateKey, contract }) {
+    constructor({ provider, account, rpcUrl, privateKey, contract,lp = "" }) {
         super({ provider, account, rpcUrl, privateKey, contract, abi })
         this.mainToken = "0x0000000000000000000000000000000000000000"
         this.maxVal = "999000000000000000000000000000000000000000000000000"
@@ -16,6 +16,159 @@ class AgentSwap extends HI {
         this.pointMax = "100000000"
 
         this.point = 0.01
+        this.lp = lp
+    }
+
+    async estimate({ side = 0,amount = 0, point = 0 , wallet = "" ,usdt = "" }) {
+        let usdt_precision = 6
+        let tau_precision = 18
+        let user = this.web3.eth.defaultAccount
+        let data = {
+            wallet:wallet ? wallet : user,
+            usdt_pool:0,
+            tau_pool:0,
+            usdt:usdt ? usdt : "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+            tau:"",
+            inAmount:0,
+            outAmount:0,
+            tau_balance:0,
+            feeAmount:0,
+            realOutAmount:0,
+            win:false,
+            change:0,
+            buyAmount:0,
+            taxAmount:0,
+            backAmount:0,
+            buyType:1
+        }
+        let lp = new SwapLP({ ...this.network, contract:this.lp })
+        let result = await lp.getReserves()
+        
+        if(result.token0.toLocaleLowerCase() == data.usdt.toLocaleLowerCase()) {
+            data.usdt_pool = saveNum(toSmall(result._reserve0,usdt_precision),usdt_precision)
+            data.tau_pool = saveNum(toSmall(result._reserve1,tau_precision),tau_precision)
+            data.tau = result.token1
+        }else {
+            data.usdt_pool = saveNum(toSmall(result._reserve1,usdt_precision),usdt_precision)
+            data.tau_pool = saveNum(toSmall(result._reserve0,tau_precision),tau_precision)
+            data.tau = result.token0
+        }
+        let tau = new ERC20({ ...this.network,contract:data.tau })
+        let balance = await tau.balanceOf(data.wallet)
+        data.tau_balance = toSmall(balance,18)
+    
+        console.log(`
+<=======swap before amount=======>
+${JSON.stringify(data,null,2)}
+        `)
+
+        // 第一次兑换
+        let path = [data.tau,data.usdt]
+        if(side == 0) {
+            data.inAmount = amount
+            let amountInWithFee = multiplication(data.inAmount,9975)
+            let numerator = multiplication(amountInWithFee,data.usdt_pool)
+            let denominator = plus(multiplication(data.tau_pool,10000),amountInWithFee)
+            data.outAmount = saveNum(division(numerator,denominator),6)
+            
+            data.tau_balance = reduce(data.tau_balance,data.inAmount)
+            data.tau_pool = plus(data.tau_pool,data.inAmount)
+            data.usdt_pool = reduce(data.usdt_pool,data.outAmount)
+            
+        }else {
+            data.outAmount = amount
+            let numerator = multiplication(multiplication(data.tau_pool,data.outAmount),10000)
+            let denominator = multiplication(reduce(data.usdt_pool,data.outAmount),9975)
+            let inAmount = saveNum(division(numerator,denominator),18)
+            data.inAmount = this.pointOffset({
+                amount:inAmount,
+                point
+            })
+            data.tau_balance = reduce(data.tau_balance,data.inAmount)
+            data.tau_pool = plus(data.tau_pool,inAmount)
+            data.usdt_pool = reduce(data.usdt_pool,data.outAmount)
+        }
+        console.log(`
+ <=======swap after amount =======>
+${JSON.stringify(data,null,2)}
+        `)
+        
+        // 历史累加输入输出
+        let amounts = await this.SC.methods.tokenAmounts(data.wallet,data.usdt).call()
+        amounts.outAmount = toSmall(amounts.outAmount,usdt_precision)
+        amounts.inAmount = toSmall(amounts.inAmount,usdt_precision)
+        // 获取手续费比率
+        let config = await this.SC.methods.rateAmount(data.tau,data.usdt).call()
+        config.feeRate = division(config.feeRate,this.pointMax)
+
+        data.feeAmount = multiplication(data.outAmount,config.feeRate)
+        // 获取扣除手续费后预计得到的usdt
+        let outAmount = reduce(data.outAmount,data.feeAmount)
+        // 计算当前兑换后的价格
+        let amountInWithFee = multiplication(1,9975)
+        let numerator = multiplication(amountInWithFee,data.usdt_pool)
+        let denominator = plus(multiplication(data.tau_pool,10000),amountInWithFee)
+        let price = saveNum(division(numerator,denominator),6)
+        
+        // 判断盈亏
+        let totalIn = amounts.inAmount
+        let totalOut = plus(plus(amounts.outAmount,outAmount),multiplication(data.tau_balance,price))
+        if(parseFloat(totalIn) >= parseFloat(totalOut)) {
+            data.win = false
+            data.change = reduce(totalIn,totalOut)
+        }else {
+            data.win = true
+            data.change = reduce(totalOut,totalIn)
+        }
+
+        let limit = await this.limitBuy(data.usdt)
+        let tax = await this.SC.methods.taxConfig(data.tau,data.usdt).call()
+        tax.tax = division(tax.tax,this.pointMax)
+        tax.backBuy = division(tax.backBuy,this.pointMax)
+        console.log(tax)
+        console.log(limit)
+        if(data.win) {
+            if(parseFloat(limit.inMin) <= parseFloat(data.change) && parseFloat(data.change) > 0) {
+                if(parseFloat(data.change) >= parseFloat(outAmount)){
+                    data.buyAmount = multiplication(outAmount,tax.backBuy)
+                    data.taxAmount = multiplication(outAmount,tax.tax)
+                }else {
+                    data.buyAmount = multiplication(data.change,tax.backBuy)
+                    data.taxAmount = multiplication(data.change,tax.tax)
+                }
+                data.buyType = 0
+                data.realOutAmount = reduce(reduce(outAmount,data.buyAmount),data.taxAmount)
+            }else {
+                // data.realOutAmount = outAmount
+                data.buyAmount = multiplication(outAmount,tax.backBuy)
+                data.realOutAmount = reduce(outAmount,data.buyAmount)
+            }
+        }else {
+            data.buyAmount = multiplication(outAmount,tax.backBuy)
+            data.realOutAmount = reduce(outAmount,data.buyAmount)
+            if(parseFloat(limit.outMin) <= parseFloat(data.change) && parseFloat(data.change) > 0) {
+                data.backAmount = data.change
+            }
+        }
+
+        console.log(`totalIn:${totalIn}`)
+        console.log(`totalOut:${totalOut}`)
+        console.log(`
+ <=======swap complete amount =======>
+${JSON.stringify(data,null,2)}`)
+        return data
+    }
+    
+
+    pointOffset({ point,amount,isplus = true }) {
+        let result
+        if(isplus) {
+            result = division(multiplication(amount,plus(this.pointMax,point)),this.pointMax)
+        }else {
+            result = division(multiplication(amount,reduce(this.pointMax,point)),this.pointMax)
+        }
+
+        return result
     }
 
     pointHandle(amount, isplus = true) {
@@ -351,7 +504,7 @@ class AgentSwap extends HI {
 
     
 
-    async tradeConfig({ amount,path,side = 0,point = 1000 }) {
+    async tradeConfig({ amount,path,side = 0,point = 1000, target = "" }) {
         let inToken = path[0]
         let outToken = path[path.length - 1]
         let IToken = new HERC20({ ...this.network, contract: inToken })
@@ -368,25 +521,45 @@ class AgentSwap extends HI {
             outAmount = await OToken.toAmount(amount)
             inputAmount = await IToken.toAmount(amount)
         }
-        let user = this.web3.eth.defaultAccount
+        let user = target ? target : this.web3.eth.defaultAccount
         console.log([inToken,outToken,path,inputAmount,outAmount,user])
-        let result = await this.SC.methods.fundRead(inToken,outToken,path,inputAmount,outAmount,user).call()
+
+        let result;
+        let decimals = await OToken.decimals()
+        try{
+            
+            result = await this.SC.methods.fundRead(inToken,outToken,path,inputAmount,outAmount,user).call()
+            console.log(result)
+            
+            result.feeAmount = toSmall(result.group.feeAmount,decimals)
+            result.outReal = toSmall(result.group.outAmount,decimals)
+            result.taxAmount = toSmall(result.group.taxAmount,decimals)
+            result.backAmount = toSmall(result.group.backAmount,decimals)
+            result.buyAmount = toSmall(result.group.buyAmount,decimals)
+            result.change = toSmall(result.group.change,decimals)
+            result.win = result.group.win
+
+            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
+        }catch(err){
+            console.log(err)
+            result = {}
+            result.outAmount = toSmall(outAmount,decimals)
+            result.inAmount = inAmount
+            result.feeAmount = 0
+            result.outReal = 0
+            result.taxAmount = 0
+            result.buyAmount = 0
+            result.change = 0
+            result.win = false
+        }
+        
         console.log(result)
         
-        let decimals = await OToken.decimals()
-        result.feeAmount = toSmall(result.group.feeAmount,decimals)
-        result.outReal = toSmall(result.group.outAmount,decimals)
-        result.taxAmount = toSmall(result.group.taxAmount,decimals)
-        result.backAmount = toSmall(result.group.backAmount,decimals)
-        result.buyAmount = toSmall(result.group.buyAmount,decimals)
-        result.change = toSmall(result.group.change,decimals)
-        result.win = result.group.win
-
-        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
     }
 

package/src/index.js

@@ -2,15 +2,17 @@
 let AgentSwap = require("./agent-swap")
 let SwapFactory = require("./swap-factory")
 let SwapRouter = require("./swap-router")
-
+let SwapLP = require("./swap-pair")
 if (window) {
     window.AgentSwap = AgentSwap
     window.SwapFactory = SwapFactory
     window.SwapRouter = SwapRouter
+    window.SwapLP = SwapLP
 }
 
 module.exports = {
     AgentSwap,
     SwapFactory,
-    SwapRouter
+    SwapRouter,
+    SwapLP
 }

package/src/swap-pair.js

@@ -0,0 +1,26 @@
+let { HI, HERC20, HERC721 } = require("h-token-staking")
+let { abi } = require("./abi/PancakePair.json")
+
+let { plus, reduce, multiplication, division, saveNum, charCompare,longHandle,toSmall } = require("h-token-staking/src/utils")
+
+
+class SwapLP extends HI {
+    constructor({ provider, account, rpcUrl, privateKey, contract }) {
+        super({ provider, account, rpcUrl, privateKey, contract, abi })
+        this.mainToken = "0x0000000000000000000000000000000000000000"
+        this.maxVal = "999000000000000000000000000000000000000000000000000"
+    }
+
+
+    async getReserves() {
+        let reserves = await this.SC.methods.getReserves().call()
+        let token0 = await this.SC.methods.token0().call()
+        let token1 = await this.SC.methods.token1().call()
+        return {
+            ...reserves,
+            token0,token1
+        }
+    }
+}
+
+module.exports = SwapLP