@dhedge/v2-sdk 1.4.0 → 1.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhedge/v2-sdk",
-  "version": "1.4.0",
+  "version": "1.4.3",
   "license": "MIT",
   "description": "🛠 An SDK for building applications on top of dHEDGE V2",
   "main": "dist/index.js",

package/src/abi/IBalancerRewardsGauge.json

@@ -0,0 +1,239 @@
+{
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "user",
+          "type": "address"
+        }
+      ],
+      "name": "balanceOf",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "user",
+          "type": "address"
+        }
+      ],
+      "name": "claim_rewards",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "user",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "receiver",
+          "type": "address"
+        }
+      ],
+      "name": "claim_rewards",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "claim_rewards",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "user",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "rewardToken",
+          "type": "address"
+        }
+      ],
+      "name": "claimable_reward",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "user",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "rewardToken",
+          "type": "address"
+        }
+      ],
+      "name": "claimable_reward_write",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "user",
+          "type": "address"
+        }
+      ],
+      "name": "deposit",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "onBehalf",
+          "type": "address"
+        },
+        {
+          "internalType": "bool",
+          "name": "isClaimRewards",
+          "type": "bool"
+        }
+      ],
+      "name": "deposit",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        }
+      ],
+      "name": "deposit",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "lp_token",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "reward_contract",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "index",
+          "type": "uint256"
+        }
+      ],
+      "name": "reward_tokens",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        }
+      ],
+      "name": "withdraw",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "isClaimRewards",
+          "type": "bool"
+        }
+      ],
+      "name": "withdraw",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ]
+}

package/src/entities/dhedge.ts

@@ -88,7 +88,6 @@ export class Dhedge {
    * @returns {Pool} Loaded Pool
    */
   public async loadPool(address: string): Promise<Pool> {
-    this.validatePool(address);
     const poolLogic = new Contract(address, PoolLogic.abi, this.signer);
     const managerLogicAddress = await poolLogic.poolManagerLogic();
     const managerLogic = new Contract(
@@ -106,14 +105,4 @@ export class Dhedge {
       this.factory
     );
   }
-
-  /**
-   * Check if pool address is valid
-   * @param {string} address Pool address
-   * @returns {boolean} Is valid pool address
-   */
-  private async validatePool(address: string): Promise<void> {
-    const isPool = await this.factory.isPool(address);
-    if (!isPool) throw new Error("Given address not a pool");
-  }
 }

package/src/entities/pool.ts

@@ -13,6 +13,8 @@ import IBalancerMerkleOrchard from "../abi/IBalancerMerkleOrchard.json";
 import IAaveIncentivesController from "../abi/IAaveIncentivesController.json";
 import IArrakisV1RouterStaking from "../abi/IArrakisV1RouterStaking.json";
 import ILiquidityGaugeV4 from "../abi/ILiquidityGaugeV4.json";
+import IBalancerRewardsGauge from "../abi/IBalancerRewardsGauge.json";
+
 import {
   deadline,
   MaxUint128,
@@ -217,6 +219,33 @@ export class Pool {
     return tx;
   }
 
+  /**
+   * Approve the asset for provided spender address
+   * @param {string} spender Spender address
+   * @param {string} asset Address of asset
+   * @param {BigNumber | string} amount to be approved
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async approveSpender(
+    spender: string,
+    asset: string,
+    amount: BigNumber | string,
+    options: any = null
+  ): Promise<any> {
+    const iERC20 = new ethers.utils.Interface(IERC20.abi);
+    const approveTxData = iERC20.encodeFunctionData("approve", [
+      spender,
+      amount
+    ]);
+    const tx = await this.poolLogic.execTransaction(
+      asset,
+      approveTxData,
+      options
+    );
+    return tx;
+  }
+
   /**
    * Trade an asset into another asset
    * @param {Dapp} dapp Platform like Sushiswap or Uniswap
@@ -377,7 +406,30 @@ export class Pool {
       stakeTxData,
       options
     );
+    return tx;
+  }
 
+  /**
+   * Stake liquidity pool tokens in gauge contract
+   * @param {string} gauge Gauge contract address
+   * @param {BigNumber | string} amount Amount of liquidity pool tokens
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async stakeInGauge(
+    gauge: string,
+    amount: BigNumber | string,
+    options: any = null
+  ): Promise<any> {
+    const rewardsGauge = new ethers.utils.Interface(IBalancerRewardsGauge.abi);
+    const stakeTxData = rewardsGauge.encodeFunctionData("deposit(uint256)", [
+      amount
+    ]);
+    const tx = await this.poolLogic.execTransaction(
+      gauge,
+      stakeTxData,
+      options
+    );
     return tx;
   }
 
@@ -410,12 +462,36 @@ export class Pool {
     return tx;
   }
 
+  /**
+   * Unstake liquidity pool tokens from gauge contract
+   * @param {string} gauge Gauge contract address
+   * @param {BigNumber | string} amount Amount of liquidity pool tokens
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async unstakeFromGauge(
+    gauge: string,
+    amount: BigNumber | string,
+    options: any = null
+  ): Promise<any> {
+    const rewardsGauge = new ethers.utils.Interface(IBalancerRewardsGauge.abi);
+    const unstakeTxData = rewardsGauge.encodeFunctionData("withdraw(uint256)", [
+      amount
+    ]);
+    const tx = await this.poolLogic.execTransaction(
+      gauge,
+      unstakeTxData,
+      options
+    );
+    return tx;
+  }
+
   /**
    * Lend asset to a lending pool
    * @param {Dapp} dapp Platform like Aave
    * @param {string} asset Asset
    * @param {BigNumber | string} amount Amount of asset to lend
-   * @param {number} referrralCode Code from Aave referral program
+   * @param {number} referralCode Code from Aave referral program
    * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
@@ -423,7 +499,7 @@ export class Pool {
     dapp: Dapp,
     asset: string,
     amount: BigNumber | string,
-    referrralCode = 0,
+    referralCode = 0,
     options: any = null
   ): Promise<any> {
     const iLendingPool = new ethers.utils.Interface(ILendingPool.abi);
@@ -431,7 +507,7 @@ export class Pool {
       asset,
       amount,
       this.address,
-      referrralCode
+      referralCode
     ]);
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][dapp],
@@ -473,7 +549,7 @@ export class Pool {
    * @param {Dapp} dapp Platform like Aave
    * @param {string} asset Asset
    * @param  {BigNumber | string} amount Amount of asset to lend
-   * @param {number} referrralCode Code from Aave referral program
+   * @param {number} referralCode Code from Aave referral program
    * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
@@ -481,7 +557,7 @@ export class Pool {
     dapp: Dapp,
     asset: string,
     amount: BigNumber | string,
-    referrralCode = 0,
+    referralCode = 0,
     options: any = null
   ): Promise<any> {
     const iLendingPool = new ethers.utils.Interface(ILendingPool.abi);
@@ -489,7 +565,7 @@ export class Pool {
       asset,
       amount,
       2,
-      referrralCode,
+      referralCode,
       this.address
     ]);
     const tx = await this.poolLogic.execTransaction(
@@ -624,6 +700,7 @@ export class Pool {
    * @param {string} poolId Balancer pool id
    * @param {string[] | } assets Array of balancer pool assets
    * @param {BigNumber | string } amount Amount of pool tokens to withdraw
+   * @param { null | number } singleExitAssetIndex Index of asset to withdraw to
    * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
@@ -631,12 +708,14 @@ export class Pool {
     poolId: string,
     assets: string[],
     amount: string | BigNumber,
+    singleExitAssetIndex: number | null = null,
     options: any = null
   ): Promise<any> {
     const exitPoolTxData = this.utils.getBalancerExitPoolTx(
       this,
       poolId,
       assets,
+      singleExitAssetIndex,
       amount
     );
     const tx = await this.poolLogic.execTransaction(
@@ -793,8 +872,8 @@ export class Pool {
       dappAddress = nonfungiblePositionManagerAddress[this.network];
       const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
       const liquidity = (await getUniswapV3Liquidity(tokenId, this))
-        .mul(amount)
-        .div(100);
+        .mul(Math.round(amount * 1e4))
+        .div(1e6);
       const decreaseLiquidityTxData = abi.encodeFunctionData(
         Transaction.DECREASE_LIQUIDITY,
         [[tokenId, liquidity, 0, 0, deadline]]
@@ -816,8 +895,8 @@ export class Pool {
       dappAddress = routerAddress[this.network][dapp];
       const abi = new ethers.utils.Interface(IArrakisV1RouterStaking.abi);
       const liquidity = (await this.utils.getBalance(tokenId, this.address))
-        .mul(amount)
-        .div(100);
+        .mul(Math.round(amount * 1e4))
+        .div(1e6);
       txData = abi.encodeFunctionData(Transaction.REMOVE_LIQUIDITY_UNSTAKE, [
         tokenId,
         liquidity,
@@ -887,8 +966,8 @@ export class Pool {
   /**
    * Claim fees of an UniswapV3 liquidity or Arrakis pool
    * @param {Dapp} dapp Platform either UniswapV3 or Arrakis
-   * @param {string} tokenId Token Id of UniswapV3 or Arrakis position
-   * @param {any} options Transaction options
+   * @param {string} tokenId Token Id of UniswapV3 or Gauge address
+   * @param {any} options Transaction option
    * @returns {Promise<any>} Transaction
    */
   async claimFees(
@@ -907,7 +986,7 @@ export class Pool {
         Transaction.COLLECT,
         [[tokenId, this.address, MaxUint128, MaxUint128]]
       );
-    } else if (dapp === Dapp.ARRAKIS) {
+    } else if (dapp === Dapp.ARRAKIS || dapp === Dapp.BALANCER) {
       contractAddress = tokenId;
       const abi = new ethers.utils.Interface(ILiquidityGaugeV4.abi);
       txData = abi.encodeFunctionData("claim_rewards()", []);

package/src/entities/utils.ts

@@ -295,25 +295,29 @@ export class Utils {
     pool: Pool,
     balancerPoolId: string,
     assets: string[],
+    singleExitAssetIndex: null | number,
     amount: string | ethers.BigNumber
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   ): Promise<any> {
     const minimumAmountOut = new Array(assets.length).fill(0);
     const iBalancerV2Vault = new ethers.utils.Interface(IBalancerV2Vault.abi);
+    const userTxData =
+      singleExitAssetIndex === null
+        ? ethers.utils.defaultAbiCoder.encode(
+            ["uint256", "uint256"],
+            [1, amount]
+          )
+        : ethers.utils.defaultAbiCoder.encode(
+            ["uint256", "uint256", "uint256"],
+            [0, amount, singleExitAssetIndex]
+          );
+
     const txData = [
       balancerPoolId,
       pool.address,
       pool.address,
-      [
-        assets,
-        minimumAmountOut,
-        ethers.utils.defaultAbiCoder.encode(
-          ["uint256", "uint256"],
-          [1, amount]
-        ),
-        false
-      ]
+      [assets, minimumAmountOut, userTxData, false]
     ];
     const exitPoolTx = iBalancerV2Vault.encodeFunctionData("exitPool", txData);
     return exitPoolTx;

package/src/test/1inch.test.ts

@@ -0,0 +1,54 @@
+import { Dhedge } from "..";
+import { Dapp, Network } from "../types";
+import { TEST_POOL, USDC, WETH } from "./constants";
+import { getTxOptions } from "./txOptions";
+
+import { wallet } from "./wallet";
+
+let dhedge: Dhedge;
+let options: any;
+
+jest.setTimeout(100000);
+
+describe("pool", () => {
+  beforeAll(async () => {
+    dhedge = new Dhedge(wallet, Network.OPTIMISM);
+    options = await getTxOptions(Network.OPTIMISM);
+  });
+
+  //   it("approves unlimited USDC on 1Inch", async () => {
+  //     let result;
+  //     const pool = await dhedge.loadPool(TEST_POOL);
+  //     try {
+  //       result = await pool.approve(
+  //         Dapp.ONEINCH,
+  //         USDC,
+  //         ethers.constants.MaxInt256,
+  //         options
+  //       );
+  //       console.log(result);
+  //     } catch (e) {
+  //       console.log(e);
+  //     }
+  //     expect(result).not.toBe(null);
+  //   });
+
+  it("trades 1 USDC into WETH on 1Inch", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.trade(
+        Dapp.ONEINCH,
+        USDC,
+        WETH,
+        "1000000",
+        0.5,
+        options
+      );
+      console.log(result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+});

package/src/test/arrakis.test.ts

@@ -14,7 +14,7 @@ jest.setTimeout(100000);
 describe("pool", () => {
   beforeAll(async () => {
     dhedge = new Dhedge(wallet, Network.POLYGON);
-    options = await getTxOptions();
+    options = await getTxOptions(Network.POLYGON);
   });
 
   // it("approves unlimited WETH on  Arrakis", async () => {
@@ -69,7 +69,7 @@ describe("pool", () => {
     const result = await pool.decreaseLiquidity(
       Dapp.ARRAKIS,
       ARRAKIS_USDC_WETH_GAUGE,
-      100,
+      50.6576575755,
       options
     );
     console.log("result", result);