h-agent-swap 3.0.7 → 3.1.0

package/src/agent-swap.js

@@ -5,14 +5,16 @@ 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")
+let SwapFactory = require("./swap-factory")
 
 class AgentSwap extends HI {
-    constructor({ provider, account, rpcUrl, privateKey, contract,lp = "" }) {
+    constructor({ provider, account, rpcUrl, privateKey, contract,lp = "",factory = "" }) {
         super({ provider, account, rpcUrl, privateKey, contract, abi })
         this.mainToken = "0x0000000000000000000000000000000000000000"
         this.maxVal = "999000000000000000000000000000000000000000000000000"
         this.WETH = ""
         this.ROUTER = ""
+        this.FACTORY = factory
         this.pointMax = "100000000"
 
         this.point = 0.01
@@ -391,6 +393,14 @@ ${JSON.stringify(data,null,2)}`)
 
 
 
+    async whitelist(address) {
+        let result = await this.SC.methods.whitelist(address).call()
+        return result
+    }
+
+
+
+
     async setTwapPeriod(period) {
  
         let params = [
@@ -474,7 +484,7 @@ ${JSON.stringify(data,null,2)}`)
         }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) {
@@ -544,7 +554,7 @@ ${JSON.stringify(data,null,2)}`)
 
     
 
-    async tradeConfig({ amount,path,side = 0,point = 1000, target = "" }) {
+    async tradeConfig({ amount,path,side = 0,point = 1000}) {
         if(path.length != 2) {
             throw "仅支持单一交易对计算"
         }
@@ -570,20 +580,16 @@ ${JSON.stringify(data,null,2)}`)
         })
         console.log("扣除费用后金额:",amount)
 
-
-        let IToken = new HERC20({ ...this.network, contract: inToken })
         let OToken = new HERC20({ ...this.network, contract: outToken })
         let outAmount;
-        let inAmount;
-        let inputAmount;
+
+        let outputAmount = 0;
         if(side == 0) {
-            inAmount = amount
             outAmount = await this.computeAmount({ amount,path,side,point })
-            inputAmount = await IToken.toAmount(amount)
-            console.log("预计输出金额:",outAmount)
+            outputAmount = await OToken.fromAmount(outAmount)
+            console.log("预计输出金额:",outputAmount)
         }
-        
-        let outputAmount = await OToken.fromAmount(outAmount)
+
         
         return outputAmount
     }
@@ -657,8 +663,28 @@ ${JSON.stringify(data,null,2)}`)
     }
 
 
-    async swapToken({ amount,path,side = 0,point = 1000, deadline = 0 }) {
+    async swapRate({ path,point = 1000 }) {
         await this.weth()
+        let outToken = path[path.length - 1]
+        let OToken = new HERC20({ ...this.network, contract: outToken })
+        let outAmount = await this.computeAmount({ amount:1,path,side:0,point })
+        
+        let amountOut = await OToken.fromAmount(outAmount)
+        console.log("汇率:",amountOut)
+        return amountOut
+    }
+
+
+    async swapToken({ amount,outAmountMin = 0,path,side = 0,point = 1000, deadline = 0 }) {
+        await this.weth()
+
+        if (path.length < 2) {
+            throw "path长度错误"
+        }
+        
+        
+
+
         let inToken = path[0]
         let outToken = path[path.length - 1]
         let inAmount = 0
@@ -677,17 +703,48 @@ ${JSON.stringify(data,null,2)}`)
             ethAmount = inAmount
         }
 
-  
+        if(outAmountMin == 0) {
+            outAmountMin = await this.tradeConfig({ amount,path,side,point})
+            console.log("最小接受数量:",outAmountMin)
+            outAmountMin = await OToken.toAmount(outAmountMin)
+        }else {
+            console.log("最小接受数量:",outAmountMin)
+            outAmountMin = await OToken.toAmount(outAmountMin)
+        }
+        
+
+        // 检查最大交换比例
+        // let factory = new SwapFactory({ ...this.network, contract: this.FACTORY })
+        // let lpAddress = await factory.getPair({ token0: path[0], token1: path[1] })
+        // let lp = new SwapLP({ ...this.network, contract:lpAddress })
+        // let resultReserves = await lp.getReserves()
+        // let maxSwapRatioBps = await this.getMaxSwapRatioBps()
+        // if(resultReserves.token0.toLocaleLowerCase() == path[0].toLocaleLowerCase()) {
+        //     let maxSwap = multiplication(resultReserves._reserve0,maxSwapRatioBps)
+        //     console.log("池子储量:",await IToken.fromAmount(resultReserves._reserve0),"最大交换量:",await IToken.fromAmount(maxSwap))
+        //     if(Number(inAmount) > Number(maxSwap)) {
+        //         throw `单次交换数量不能超过池子${multiplication(maxSwapRatioBps,100)}%`
+        //     }
+        // }else if(resultReserves.token1.toLocaleLowerCase() == path[0].toLocaleLowerCase()) {
+        //     let maxSwap = multiplication(resultReserves._reserve1,maxSwapRatioBps)
+        //     console.log("池子储量:",await IToken.fromAmount(resultReserves._reserve1),"最大交换量:",await IToken.fromAmount(maxSwap))
+        //     if(Number(inAmount) > Number(maxSwap)) {
+        //         throw `单次交换数量不能超过池子${multiplication(maxSwapRatioBps,100)}%`
+        //     }
+        // }
+    
+        // 批准
         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 parma_list = [
-            path,inAmount, deadline,point
+            path,inAmount,outAmountMin, deadline,point
         ]
         console.log(parma_list)
         let parmas = await this.buildTx("swapToken", parma_list, ethAmount)

package/src/index.js

@@ -5,6 +5,8 @@ let SwapRouter = require("./swap-router")
 let SwapLP = require("./swap-pair")
 let Poker = require("./poker")
 let BERC20 = require("./BERC20")
+let Treasury = require("./treasury")
+
 if (window) {
     window.AgentSwap = AgentSwap
     window.SwapFactory = SwapFactory
@@ -12,6 +14,7 @@ if (window) {
     window.SwapLP = SwapLP
     window.Poker = Poker
     window.BERC20 = BERC20
+    window.Treasury = Treasury
 }
 
 module.exports = {
@@ -20,5 +23,6 @@ module.exports = {
     SwapRouter,
     SwapLP,
     Poker,
-    BERC20
+    BERC20,
+    Treasury
 }

package/src/treasury.js

@@ -0,0 +1,362 @@
+let { HI, HERC20 } = require("h-token-staking")
+
+let { abi, bytecode } = require("./abi/Treasury.json")
+
+let { plus, reduce, multiplication, division, saveNum, charCompare, longHandle, toSmall } = require("h-token-staking/src/utils")
+const ERC20 = require("h-token-staking/src/ERC20")
+
+
+class Treasury extends HI {
+    constructor({ provider, account, rpcUrl, privateKey, contract, factory = "" }) {
+        super({ provider, account, rpcUrl, privateKey, contract, abi })
+        this.mainToken = "0x0000000000000000000000000000000000000000"
+        this.maxVal = "999000000000000000000000000000000000000000000000000"
+        this.WETH = ""
+        this.ROUTER = ""
+        this.FACTORY = factory
+        this.pointMax = "100000000"
+
+        this.point = 0.01
+    }
+
+    async transfer({ to, amount, contract }) {
+        let tokenItem = new ERC20({ ...this.network, contract })
+        let user = this.web3.eth.defaultAccount
+        let balance = await this.balanceOf({
+            token: contract,
+            address: user
+        })
+        if (parseFloat(balance) < parseFloat(amount)) {
+            return false
+        }
+        let result = await tokenItem.transfer(to, amount)
+        return result
+    }
+
+    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) {
+        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 }) {
+        try {
+            let from = this.web3.eth.defaultAccount
+
+            let gasPrice = await this.GasPrice()
+            let result = await this.SC.deploy({
+                data: bytecode,
+                arguments: [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 sync({ tokenIn, tokenOut }) {
+
+        let params = [
+            tokenIn,
+            tokenOut,
+        ]
+        let result = await this.manage("sync", params)
+        return result
+    }
+
+    async updateWhite({ address, onoff }) {
+
+        let params = [
+            address,
+            onoff
+        ]
+        let result = await this.manage("updateWhite", params)
+        return result
+    }
+
+    async setMaxAllowedOffset(percent) {
+        percent = multiplication(division(percent, 100), this.pointMax)
+        let params = [
+            percent
+        ]
+        let result = await this.manage("setMaxAllowedOffset", params)
+        return result
+    }
+
+    async getMaxAllowedOffset() {
+        let result = await this.SC.methods.maxAllowedOffset().call()
+
+        return division(result, this.pointMax)
+    }
+
+    async setMaxSwapRatioBps(percent) {
+        percent = multiplication(division(percent, 100), this.pointMax)
+        let params = [
+            percent
+        ]
+        let result = await this.manage("setMaxSwapRatioBps", params)
+        return result
+    }
+
+    async getMaxSwapRatioBps() {
+        let result = await this.SC.methods.maxSwapRatioBps().call()
+
+        return division(result, this.pointMax)
+    }
+
+    async setTwapPeriod(period) {
+
+        let params = [
+            period
+        ]
+        let result = await this.manage("setTwapPeriod", params)
+        return result
+    }
+
+    async getTwapPeriod() {
+        let result = await this.SC.methods.twapPeriod().call()
+
+        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 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)
+        }
+
+        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 swapRate({ path, point = 1000 }) {
+        await this.weth()
+        let outToken = path[path.length - 1]
+        let OToken = new HERC20({ ...this.network, contract: outToken })
+        let outAmount = await this.computeAmount({ amount: 1, path, side: 0, point })
+        let amountOut = await OToken.fromAmount(outAmount)
+        console.log("汇率:", amountOut)
+        return amountOut
+    }
+
+    async swap({ amount, outAmountMin = 0, path, side = 0, point = 1000, deadline = 0 }) {
+        await this.weth()
+        if (path.length < 2) {
+            throw "path长度错误"
+        }
+
+        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
+        }
+
+        outAmountMin = await this.computeAmount({ amount: amount, path, side: 0, point })
+        console.log("最小接受数量:", await OToken.fromAmount(outAmountMin))
+
+        // 批准
+        let amountIn = await IToken.fromAmount(inAmount)
+        let balance = await this.balanceOf({
+            token: inToken,
+            address: this.contract
+        })
+        if (parseFloat(balance) < parseFloat(amountIn)) {
+            throw "合约内余额不足，请先充值"
+        }
+
+        // 到期时间
+        let now = new Date().getTime()
+        now = parseInt(division(now, 1000))
+        deadline = deadline ? deadline : plus(multiplication(60, 30), now)
+
+
+        let parma_list = [
+            path, inAmount, outAmountMin, deadline, point
+        ]
+        console.log(parma_list)
+        let parmas = await this.buildTx("swap", parma_list, ethAmount)
+        let result = parmas && await this.broadTx(parmas)
+        return result
+
+    }
+
+
+    async whitelist(address) {
+        let result = await this.SC.methods.whitelist(address).call()
+        return result
+    }
+
+    /**
+     * 计算使池子价格变动所需投入的代币数量
+     * 
+     * @param {number} R0 - 代币A的当前储备量
+     * @param {number} R1 - 代币B的当前储备量
+     * @param {number} changePct - 价格变动百分比（正数表示上涨，负数表示下跌，如 2.5 表示 +2.5%，-1.2 表示 -1.2%）
+     * @returns {Object} { inputAmount, token } 
+     *         - inputAmount: 需要投入的数量（用户实际支付，含手续费）
+     *         - token: 'R0' 或 'R1'，表示应投入哪种代币
+     */
+    calculateInputForPriceChange(R0, R1, changePct) {
+        const feeRate = 0.0025; // 0.25%
+        const effectiveRate = 1 - feeRate; // 0.9975
+
+        const currentPrice = R1 / R0;
+        const targetPrice = currentPrice * (1 + changePct / 100);
+
+        if (targetPrice <= 0) {
+            throw new Error("目标价格必须大于 0");
+        }
+
+        const k = R0 * R1; // 恒定乘积
+
+        if (changePct > 0) {
+            // 价格上涨：需用 B 换 A → 投入 R1（代币B）
+            // 新状态满足: R1' / R0' = targetPrice, 且 R0' * R1' = k
+            const R1_prime = Math.sqrt(k * targetPrice);
+            const deltaR1_effective = R1_prime - R1; // 进入池子的 B（已扣手续费）
+            if (deltaR1_effective <= 0) {
+                throw new Error("价格上涨需增加 R1，但计算结果非正");
+            }
+            const inputR1 = deltaR1_effective / effectiveRate; // 用户实际需支付的 B
+            return {
+                inputAmount: inputR1,
+                token: 'R1', // 投入代币B
+                newPrice: targetPrice
+            };
+        } else if (changePct < 0) {
+            // 价格下跌：需用 A 换 B → 投入 R0（代币A）
+            const R0_prime = Math.sqrt(k / targetPrice);
+            const deltaR0_effective = R0_prime - R0; // 进入池子的 A（已扣手续费）
+            if (deltaR0_effective <= 0) {
+                throw new Error("价格下跌需增加 R0，但计算结果非正");
+            }
+            const inputR0 = deltaR0_effective / effectiveRate; // 用户实际需支付的 A
+            return {
+                inputAmount: inputR0,
+                token: 'R0', // 投入代币A
+                newPrice: targetPrice
+            };
+        } else {
+            return {
+                inputAmount: 0,
+                token: null,
+                newPrice: currentPrice
+            };
+        }
+    }
+
+
+
+
+}
+
+
+module.exports = Treasury