h-agent-swap 3.1.2 → 3.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "h-agent-swap",
-  "version": "3.1.2",
+  "version": "3.1.5",
   "description": "agent-swap",
   "main": "src/index.js",
   "files": [

package/src/BERC20.js

@@ -1,5 +1,6 @@
 let { HI } = require("h-token-staking")
 let { abi, bytecode } = require("./abi/ERC20Standard.json")
+let OCMJSON = require("./abi/OCM.json")
 let { plus, reduce, multiplication, division, saveNum, charCompare,longHandle } = require("h-token-staking/src/utils")
 
 class BERC20 extends HI {
@@ -24,6 +25,7 @@ class BERC20 extends HI {
         }
     }
 
+
 }
 
 

package/src/Interaction.js

@@ -0,0 +1,254 @@
+let { HI, HERC20, HERC721 } = require("h-token-staking")
+let Quoter = require("./Quoter")
+let PancakeFactory = require("./PancakeFactory")
+let { abi, bytecode } = require("./abi/Interaction.json")
+let { plus, reduce, multiplication, division, saveNum, charCompare, longHandle } = require("h-token-staking/src/utils")
+
+let Success = (data) => {
+    return {
+        code: 0,
+        data
+    }
+}
+
+let ERR = {
+    InsufficientBalance: {
+        code: 100,
+        msg: "Insufficient balance"
+    },
+    ApproveFailed: {
+        code: 101,
+        msg: "Approve failed"
+    },
+    InsufficientReserves: {
+        code: 102,
+        msg: "Insufficient reserves"
+    },
+    invalidNFT: {
+        code: 103,
+        msg: "invalid nft"
+    },
+    invalidTokenID: {
+        code: 104,
+        msg: "invalid tokenId"
+    },
+    InvalidLP: {
+        code: 105,
+        msg: "invalid liquidity"
+    },
+}
+
+class Interaction 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.usdt = ""
+        this.ocm = ""
+        this.usdtTreasury = ""
+        this.betPause = false
+
+        this.pointMax = "100000000"
+
+
+        this.point = 0.01
+
+        this.initContracts()
+
+
+    }
+
+    async initContracts() {
+        let route = ""
+        let chainId = await this.web3.eth.getChainId()
+        if (chainId == 56) {
+            route = "0x10ED43C718714eb63d5aA57B78B54704E256024E"
+        } else if (chainId == 97) {
+            route = "0xD99D1c33F9fC3444f8101754aBC46c52416550D1"
+        }
+        this.router = route
+        if(!!this.contract) {
+            await this.getRouter()
+            await this.getWETH()
+            await this.getUSDT()
+            await this.getOCM()
+            await this.getUsdtTreasury()
+            await this.getBetPause()
+        }
+    }
+
+    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({ usdt, ocm, usdtTreasury }) {
+        try {
+            let from = this.web3.eth.defaultAccount
+            // let chainId = await this.web3.eth.getChainId()
+            // let route = ""
+            // let quotev2 = ""
+
+            await this.initContracts()
+
+
+            let gasPrice = await this.GasPrice()
+            let result = await this.SC.deploy({
+                data: bytecode,
+                arguments: [this.router, usdt, ocm, usdtTreasury]
+            }).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 setting({ route, usdt, ocm, usdtTreasury, betPause }) {
+        let result = await this.manage("setting", [route, usdt, ocm, usdtTreasury, betPause])
+        return result
+    }
+
+    async updateWhite({ address, onoff }) {
+
+        let params = [
+            address,
+            onoff
+        ]
+        let result = await this.manage("updateWhite", params)
+        return result
+    }
+
+    async extract({ token, amount, recipient }) {
+        let inToken = new HERC20({ ...this.network, contract: token })
+        amount = await inToken.toAmount(amount)
+
+        let result = await this.manage("extract", [inToken.contract,recipient, amount])
+        return result
+    }
+
+    async balanceOf(token) {
+        let result = await this.SC.methods.balanceOf(token).call()
+        let targetToken = new HERC20({ ...this.network, contract: token })
+        let amount = await targetToken.fromAmount(result)
+        return amount
+    }
+
+    async getRouter() {
+        if (!this.router) {
+            let result = await this.SC.methods.route().call()
+            this.router = result
+        }
+        return this.router
+    }
+
+    async getWETH() {
+        if (!this.weth) {
+            let result = await this.SC.methods.weth().call()
+            this.weth = result
+        }
+        return this.weth
+    }
+
+    async getUSDT() {
+        if (!this.usdt) {
+            let result = await this.SC.methods.usdt().call()
+            this.usdt = result
+        }
+        return this.usdt
+    }
+
+    async getOCM() {
+        if (!this.ocm) {
+            let result = await this.SC.methods.ocm().call()
+            this.ocm = result
+        }
+        return this.ocm
+    }
+    async getUsdtTreasury() {
+        if (!this.usdtTreasury) {
+            let result = await this.SC.methods.usdtTreasury().call()
+            this.usdtTreasury = result
+        }
+        return this.usdtTreasury
+    }
+
+    async getBetPause() {
+        let result = await this.SC.methods.betPause().call()
+        this.betPause = result
+        return this.betPause
+    }
+
+    
+
+    async bet({ amount,expect }) {
+        let Token0 = new HERC20({ ...this.network, contract: this.usdt })
+        await Token0.tradeApprove(this.contract,amount)
+        amount = await Token0.toAmount(amount)
+        let ethAmount = 0
+        // if(token == "") {
+        //     token = this.mainToken
+        //     ethAmount = amount
+        // }
+
+        let parmas = await this.buildTx("bet", [
+            amount,
+            expect 
+        ],ethAmount)
+        let result = parmas && await this.broadTx(parmas)
+        return result
+    }
+
+
+    async allocationSet(allocations = []) {
+        allocations = allocations.map(item => {
+            return [
+                item.path,
+                item.point,
+                item.rate,
+                item.to
+            ]
+        })
+        console.log(allocations)
+
+        let result = await this.manage("allocationSet", [allocations])
+        return result
+    }
+
+}
+
+
+module.exports = Interaction

package/src/OCM.js

@@ -0,0 +1,48 @@
+let { HI } = require("h-token-staking")
+let { abi, bytecode } = require("./abi/OCM.json")
+let { plus, reduce, multiplication, division, saveNum, charCompare,longHandle } = require("h-token-staking/src/utils")
+
+class OCM extends HI {
+    constructor({ provider, account, rpcUrl, privateKey, contract }) {
+        super({ provider, account, rpcUrl, privateKey, contract, abi })
+    }
+
+    async deploy({ name,symbol,decimal,amount }) {
+        try {
+            let from = this.web3.eth.defaultAccount
+            let gasPrice = await this.GasPrice()
+            amount = longHandle(amount,decimal)
+            amount = saveNum(amount,0)
+            let result = await this.SC.deploy({
+                data: bytecode,
+                arguments: [ name,symbol,amount,decimal ]
+            }).send({ from, gasPrice });
+            this.SC = result
+            return result
+        } catch (err) {
+            console.log(err)
+        }
+    }
+
+    async addPoolAddress({ address, onoff }) {
+        let params = [
+            address,
+            onoff
+        ]
+        let result = await this.manage("addPoolAddress", params)
+        return result
+    }
+
+    async addToWhitelist({ address, onoff }) {
+        let params = [
+            address,
+            onoff
+        ]
+        let result = await this.manage("addToWhitelist", params)
+        return result
+    }
+
+}
+
+
+module.exports = OCM

package/src/PancakeFactory.js

@@ -0,0 +1,22 @@
+let { HI } = require("h-token-staking")
+let { abi } = require("./abi/PancakeFactory.json")
+let { plus,reduce,multiplication,division,saveNum } = require("h-token-staking/src/utils")
+
+class PancakeFactory extends HI {
+    constructor({ provider, account, rpcUrl, privateKey, contract }) {
+        super({ provider, account, rpcUrl, privateKey, contract, abi })
+    }
+    
+
+
+    async getPool({ token0,token1,fee }) {
+        fee = division(fee,100)
+        fee = multiplication(fee,1000000)
+        let result = await this.SC.methods.getPool(token0,token1,fee).call()
+        return result
+    }
+
+}
+
+
+module.exports = PancakeFactory

package/src/Quoter.js

@@ -0,0 +1,105 @@
+let { HI, HERC20 } = require("h-token-staking")
+let { abi } = require("./abi/QuoterV2.json")
+let { plus,reduce,multiplication,division,saveNum } = require("h-token-staking/src/utils")
+
+class Quoter extends HI {
+    constructor({ provider, account, rpcUrl, privateKey, contract }) {
+        // 0xb4a466911556e39210a6bb2faecbb59e4eb7e43d
+        super({ provider, account, rpcUrl, privateKey, contract, abi })
+    }
+    
+    async quoteExactInput({ path,amount }) {
+        try{
+            console.log(path,amount)
+            let { amountOut } = await this.SC.methods.quoteExactInput(path,amount).call()
+            return amountOut
+        }catch(err){
+            console.log(err)
+            console.error("流动性不足")
+            return 0
+        }
+    }
+
+    async quoteExactInputMulti(list = [],amountIn) {
+        let amountOut = amountIn
+        if(list.length) {
+            for(let i = 0; i < list.length; i++) {
+                let result = await this.quoteExactInputSingle(list[i],amountOut)
+                let outToken = new HERC20({ ...this.network, contract: list[i].tokenOut })
+                amountOut = await outToken.fromAmount(result.amountOut)
+            }
+        }else {
+            throw "list.length > 0"
+        }
+        return amountOut
+    }
+
+    async quoteExactInputSingle({ tokenIn,tokenOut,fee },amountIn) {
+        try{
+            let inToken = new HERC20({ ...this.network, contract: tokenIn })
+            amountIn = await inToken.toAmount(amountIn)
+            fee = division(fee, 100)
+            fee = multiplication(fee, 1000000)
+            fee = saveNum(fee,0)
+            console.log([
+                tokenIn,tokenOut,amountIn,fee,0
+            ])
+            let result = await this.SC.methods.quoteExactInputSingle([
+                tokenIn,tokenOut,amountIn,fee,0
+            ]).call()
+            return result
+        }catch(err){
+            console.log(err)
+            return false
+        }
+    }
+
+
+    async quoteExactOutputMulti(list = [],amountOut) {
+        let amountIn = amountOut
+        if(list.length) {
+            for(let i = 0; i < list.length; i++) {
+                let result = await this.quoteExactOutputSingle(list[i],amountIn)
+                console.log(result)
+                let inToken = new HERC20({ ...this.network, contract: list[i].tokenIn })
+                amountIn = await inToken.fromAmount(result.amountIn)
+            }
+        }else {
+            throw "list.length > 0"
+        }
+        return amountIn
+    }
+
+    async quoteExactOutputSingle({ tokenIn,tokenOut,fee },amountOut) {
+        try{
+            let outToken = new HERC20({ ...this.network, contract: tokenOut })
+            amountOut = await outToken.toAmount(amountOut)
+            fee = division(fee, 100)
+            fee = multiplication(fee, 1000000)
+            fee = saveNum(fee,0)
+            let result = await this.SC.methods.quoteExactOutputSingle([
+                tokenIn,tokenOut,amountOut,fee,0
+            ]).call()
+            return result
+        }catch(err){
+            console.log(err)
+            return false
+        }
+    }
+    
+    async quoteExactOutput({ path,amount }) {
+        try{
+            let { amountIn } = await this.SC.methods.quoteExactOutput(path,amount).call()
+            return amountIn
+        }catch(err){
+            console.log(err)
+            console.error("流动性不足")
+            return 0
+        }
+    }
+   
+
+}
+
+
+module.exports = Quoter