@dhedge/v2-sdk 1.1.1 → 1.3.0

package/src/entities/pool.ts

@@ -6,8 +6,19 @@ import { Contract, ethers, Wallet, BigNumber } from "ethers";
 import IERC20 from "../abi/IERC20.json";
 import IMiniChefV2 from "../abi/IMiniChefV2.json";
 import ILendingPool from "../abi/ILendingPool.json";
+import ISynthetix from "../abi/ISynthetix.json";
 import IUniswapV2Router from "../abi/IUniswapV2Router.json";
-import { routerAddress, stakingAddress } from "../config";
+import INonfungiblePositionManager from "../abi/INonfungiblePositionManager.json";
+import IBalancerMerkleOrchard from "../abi/IBalancerMerkleOrchard.json";
+import IAaveIncentivesController from "../abi/IAaveIncentivesController.json";
+import {
+  deadline,
+  MaxUint128,
+  nonfungiblePositionManagerAddress,
+  routerAddress,
+  stakingAddress,
+  SYNTHETIX_TRACKING_CODE
+} from "../config";
 import {
   Dapp,
   Transaction,
@@ -17,10 +28,18 @@ import {
 } from "../types";
 
 import { Utils } from "./utils";
+import { ClaimService } from "../services/claim-balancer/claim.service";
+import {
+  getUniswapV3Liquidity,
+  getUniswapV3MintParams
+} from "../services/uniswap/V3Liquidity";
+import { FeeAmount } from "@uniswap/v3-sdk";
+import { getUniswapV3SwapTxData } from "../services/uniswap/V3Trade";
 
 export class Pool {
   public readonly poolLogic: Contract;
   public readonly managerLogic: Contract;
+  public readonly factory: Contract;
   public readonly signer: Wallet;
   public readonly address: string;
   public readonly utils: Utils;
@@ -31,7 +50,8 @@ export class Pool {
     signer: Wallet,
     poolLogic: Contract,
     mangerLogic: Contract,
-    utils: Utils
+    utils: Utils,
+    factory: Contract
   ) {
     this.network = network;
     this.poolLogic = poolLogic;
@@ -39,6 +59,7 @@ export class Pool {
     this.managerLogic = mangerLogic;
     this.signer = signer;
     this.utils = utils;
+    this.factory = factory;
   }
 
   /**
@@ -167,13 +188,39 @@ export class Pool {
     return tx;
   }
 
+  /**
+   * Approve the liquidity pool token for staking
+   * @param {Dapp} dapp Platform like Sushiswap or Uniswap
+   * @param {string} asset Address of liquidity pool token
+   * @param {BigNumber | string} amount Aamount to be approved
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async approveUniswapV3Liquidity(
+    asset: string,
+    amount: BigNumber | string,
+    options: any = null
+  ): Promise<any> {
+    const iERC20 = new ethers.utils.Interface(IERC20.abi);
+    const approveTxData = iERC20.encodeFunctionData("approve", [
+      nonfungiblePositionManagerAddress[this.network],
+      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
    * @param {string} assetFrom Asset to trade from
    * @param {string} assetTo Asset to trade into
    * @param {BigNumber | string} amountIn Amount
-   * @param {BigNumber | string} minAmountOut Minumum amount to receive
+   * @param {number} slippage Slippage tolerance in %
    * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
@@ -194,6 +241,27 @@ export class Pool {
       }&slippage=${slippage.toString()}&disableEstimate=true`;
       const response = await axios.get(apiUrl);
       swapTxData = response.data.tx.data;
+    } else if (dapp === Dapp.BALANCER) {
+      swapTxData = await this.utils.getBalancerSwapTx(
+        this,
+        assetFrom,
+        assetTo,
+        amountIn,
+        slippage
+      );
+    } else if (dapp === Dapp.SYNTHETIX) {
+      const iSynthetix = new ethers.utils.Interface(ISynthetix.abi);
+      const assets = [assetFrom, assetTo].map(asset =>
+        ethers.utils.formatBytes32String(asset)
+      );
+      const daoAddress = await this.factory.owner();
+      swapTxData = iSynthetix.encodeFunctionData(Transaction.SWAP_SYNTHS, [
+        assets[0],
+        amountIn,
+        assets[1],
+        daoAddress,
+        SYNTHETIX_TRACKING_CODE
+      ]);
     } else {
       const iUniswapV2Router = new ethers.utils.Interface(IUniswapV2Router.abi);
       const minAmountOut = await this.utils.getMinAmountOut(
@@ -208,7 +276,7 @@ export class Pool {
         minAmountOut,
         [assetFrom, assetTo],
         this.address,
-        Math.floor(Date.now() / 1000) + 60 * 20 // 20 minutes from the current Unix time
+        deadline
       ]);
     }
     const tx = await this.poolLogic.execTransaction(
@@ -240,16 +308,7 @@ export class Pool {
     const iUniswapV2Router = new ethers.utils.Interface(IUniswapV2Router.abi);
     const addLiquidityTxData = iUniswapV2Router.encodeFunctionData(
       Transaction.ADD_LIQUIDITY,
-      [
-        assetA,
-        assetB,
-        amountA,
-        amountB,
-        0,
-        0,
-        this.address,
-        Math.floor(Date.now() / 1000) + 60 * 20 // 20 minutes from the current Unix time
-      ]
+      [assetA, assetB, amountA, amountB, 0, 0, this.address, deadline]
     );
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][dapp],
@@ -278,15 +337,7 @@ export class Pool {
     const iUniswapV2Router = new ethers.utils.Interface(IUniswapV2Router.abi);
     const removeLiquidityTxData = iUniswapV2Router.encodeFunctionData(
       Transaction.REMOVE_LIQUIDITY,
-      [
-        assetA,
-        assetB,
-        amount,
-        0,
-        0,
-        this.address,
-        Math.floor(Date.now() / 1000) + 60 * 20 // 20 minutes from the current Unix time
-      ]
+      [assetA, assetB, amount, 0, 0, this.address, deadline]
     );
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][dapp],
@@ -342,7 +393,7 @@ export class Pool {
   ): Promise<any> {
     const iMiniChefV2 = new ethers.utils.Interface(IMiniChefV2.abi);
     const poolId = await this.utils.getLpPoolId(dapp, asset);
-    const unStakeTxData = iMiniChefV2.encodeFunctionData(Transaction.UNSTAKE, [
+    const unStakeTxData = iMiniChefV2.encodeFunctionData(Transaction.WITHDRAW, [
       poolId,
       amount,
       this.address
@@ -359,7 +410,8 @@ export class Pool {
    * 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 {BigNumber | string} amount Amount of asset to lend
+   * @param {number} referrralCode Code from Aave referral program
    * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
@@ -367,6 +419,7 @@ export class Pool {
     dapp: Dapp,
     asset: string,
     amount: BigNumber | string,
+    referrralCode = 0,
     options: any = null
   ): Promise<any> {
     const iLendingPool = new ethers.utils.Interface(ILendingPool.abi);
@@ -374,7 +427,7 @@ export class Pool {
       asset,
       amount,
       this.address,
-      0
+      referrralCode
     ]);
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][dapp],
@@ -416,6 +469,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 {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
@@ -423,6 +477,7 @@ export class Pool {
     dapp: Dapp,
     asset: string,
     amount: BigNumber | string,
+    referrralCode = 0,
     options: any = null
   ): Promise<any> {
     const iLendingPool = new ethers.utils.Interface(ILendingPool.abi);
@@ -430,7 +485,7 @@ export class Pool {
       asset,
       amount,
       2,
-      0,
+      referrralCode,
       this.address
     ]);
     const tx = await this.poolLogic.execTransaction(
@@ -531,4 +586,320 @@ export class Pool {
     const tx = await this.managerLogic.setTrader(trader, options);
     return tx;
   }
+
+  /**
+   * Invest into a Balancer pool
+   * @param {string} poolId Balancer pool id
+   * @param {string[] | } assetsIn Array of balancer pool assets
+   * @param {BigNumber[] | string[]} amountsIn Array of maximum amounts to provide to pool
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async joinBalancerPool(
+    poolId: string,
+    assets: string[],
+    amountsIn: string[] | BigNumber[],
+    options: any = null
+  ): Promise<any> {
+    const joinPoolTxData = this.utils.getBalancerJoinPoolTx(
+      this,
+      poolId,
+      assets,
+      amountsIn
+    );
+    const tx = await this.poolLogic.execTransaction(
+      routerAddress[this.network][Dapp.BALANCER],
+      joinPoolTxData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Invest into a Balancer 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 {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async exitBalancerPool(
+    poolId: string,
+    assets: string[],
+    amount: string | BigNumber,
+    options: any = null
+  ): Promise<any> {
+    const exitPoolTxData = this.utils.getBalancerExitPoolTx(
+      this,
+      poolId,
+      assets,
+      amount
+    );
+    const tx = await this.poolLogic.execTransaction(
+      routerAddress[this.network][Dapp.BALANCER],
+      exitPoolTxData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Claim rewards from Balancer pools
+   * @param {string[]} assets Array of tokens being claimed
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async harvestBalancerRewards(options: any = null): Promise<any> {
+    const claimService = new ClaimService(this.network, this.signer);
+    const multiTokenPendingClaims = await claimService.getMultiTokensPendingClaims(
+      this.address
+    );
+    const tokens = multiTokenPendingClaims.map(
+      tokenPendingClaims => tokenPendingClaims.tokenClaimInfo.token
+    );
+    const claims = await claimService.multiTokenClaimRewards(
+      this.address,
+      multiTokenPendingClaims
+    );
+    const iBalancerMerkleOrchard = new ethers.utils.Interface(
+      IBalancerMerkleOrchard.abi
+    );
+    const harvestTxData = iBalancerMerkleOrchard.encodeFunctionData(
+      Transaction.CLAIM_DISTRIBIUTIONS,
+      [this.address, claims, tokens]
+    );
+    const tx = await this.poolLogic.execTransaction(
+      stakingAddress[this.network][Dapp.BALANCER],
+      harvestTxData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Claim rewards from Aave platform
+   * @param {string[]} assets Aave tokens (deposit/debt) hold by pool
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async harvestAaveRewards(
+    assets: string[],
+    options: any = null
+  ): Promise<any> {
+    const aaveIncentivesAddress = stakingAddress[this.network][
+      Dapp.AAVE
+    ] as string;
+    const iAaveIncentivesController = new ethers.utils.Interface(
+      IAaveIncentivesController.abi
+    );
+    const aaveIncentivesController = new ethers.Contract(
+      aaveIncentivesAddress,
+      iAaveIncentivesController,
+      this.signer
+    );
+    const amount = await aaveIncentivesController.getUserUnclaimedRewards(
+      this.address
+    );
+    const claimTxData = iAaveIncentivesController.encodeFunctionData(
+      Transaction.CLAIM_REWARDS,
+      [assets, amount, this.address]
+    );
+    const tx = await this.poolLogic.execTransaction(
+      aaveIncentivesAddress,
+      claimTxData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Create UniswapV3 liquidity pool
+   * @param {string} assetA First asset
+   * @param {string} assetB Second asset
+   * @param {BigNumber | string} amountA Amount first asset
+   * @param {BigNumber | string} amountB Amount second asset
+   * @param { number } minPrice Lower price range (assetB per assetA)
+   * @param { number } maxPrice Upper price range (assetB per assetA)
+   * @param { number } minTick Lower tick range
+   * @param { number } maxTick Upper tick range
+   * @param { FeeAmount } feeAmount Fee tier (Low 0.05%, Medium 0.3%, High 1%)
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async addLiquidityUniswapV3(
+    assetA: string,
+    assetB: string,
+    amountA: BigNumber | string,
+    amountB: BigNumber | string,
+    minPrice: number | null,
+    maxPrice: number | null,
+    minTick: number | null,
+    maxTick: number | null,
+    feeAmount: FeeAmount,
+    options: any = null
+  ): Promise<any> {
+    if ((!minPrice || !maxPrice) && (!minTick || !maxTick))
+      throw new Error("Need to provide price or tick range");
+
+    const iNonfungiblePositionManager = new ethers.utils.Interface(
+      INonfungiblePositionManager.abi
+    );
+
+    const mintTxParams = await getUniswapV3MintParams(
+      this,
+      assetA,
+      assetB,
+      amountA,
+      amountB,
+      minPrice,
+      maxPrice,
+      minTick,
+      maxTick,
+      feeAmount
+    );
+    const mintTxData = iNonfungiblePositionManager.encodeFunctionData(
+      Transaction.MINT,
+      [mintTxParams]
+    );
+    const tx = await this.poolLogic.execTransaction(
+      nonfungiblePositionManagerAddress[this.network],
+      mintTxData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Remove liquidity from an UniswapV3 liquidity pool
+   * @param {string} tokenId Token Id of UniswapV3 position
+   * @param {number} amount Amount in percent of assets to be removed
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async removeLiquidityUniswapV3(
+    tokenId: string,
+    amount = 100,
+    options: any = null
+  ): Promise<any> {
+    const iNonfungiblePositionManager = new ethers.utils.Interface(
+      INonfungiblePositionManager.abi
+    );
+    const liquidity = (await getUniswapV3Liquidity(tokenId, this))
+      .mul(amount)
+      .div(100);
+    const decreaseLiquidityTxData = iNonfungiblePositionManager.encodeFunctionData(
+      Transaction.DECREASE_LIQUIDITY,
+      [[tokenId, liquidity, 0, 0, deadline]]
+    );
+    const collectTxData = iNonfungiblePositionManager.encodeFunctionData(
+      Transaction.COLLECT,
+      [[tokenId, this.address, MaxUint128, MaxUint128]]
+    );
+
+    const multicallParams = [decreaseLiquidityTxData, collectTxData];
+
+    if (amount === 100) {
+      const burnTxData = iNonfungiblePositionManager.encodeFunctionData(
+        Transaction.BURN,
+        [tokenId]
+      );
+      multicallParams.push(burnTxData);
+    }
+    const multicallTxData = iNonfungiblePositionManager.encodeFunctionData(
+      Transaction.MULTI_CALL,
+      [multicallParams]
+    );
+    const tx = await this.poolLogic.execTransaction(
+      nonfungiblePositionManagerAddress[this.network],
+      multicallTxData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Increase liquidity of an UniswapV3 liquidity pool
+   * @param {string} tokenId Token Id of UniswapV3 position
+   * @param {BigNumber | string} amountA Amount first asset
+   * @param {BigNumber | string} amountB Amount second asset
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async increaseLiquidityUniswapV3(
+    tokenId: string,
+    amountA: BigNumber | string,
+    amountB: BigNumber | string,
+    options: any = null
+  ): Promise<any> {
+    const iNonfungiblePositionManager = new ethers.utils.Interface(
+      INonfungiblePositionManager.abi
+    );
+    const increaseLiquidityTxData = iNonfungiblePositionManager.encodeFunctionData(
+      Transaction.INCREASE_LIQUIDITY,
+      [[tokenId, amountA, amountB, 0, 0, deadline]]
+    );
+    const tx = await this.poolLogic.execTransaction(
+      nonfungiblePositionManagerAddress[this.network],
+      increaseLiquidityTxData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Claim fees of an UniswapV3 liquidity pool
+   * @param {string} tokenId Token Id of UniswapV3 position
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async claimFeesUniswapV3(tokenId: string, options: any = null): Promise<any> {
+    const iNonfungiblePositionManager = new ethers.utils.Interface(
+      INonfungiblePositionManager.abi
+    );
+    const collectTxData = iNonfungiblePositionManager.encodeFunctionData(
+      Transaction.COLLECT,
+      [[tokenId, this.address, MaxUint128, MaxUint128]]
+    );
+    const tx = await this.poolLogic.execTransaction(
+      nonfungiblePositionManagerAddress[this.network],
+      collectTxData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Trade an asset into another asset
+   * @param {Dapp} dapp Platform like Sushiswap or Uniswap
+   * @param {string} assetFrom Asset to trade from
+   * @param {string} assetTo Asset to trade into
+   * @param {BigNumber | string} amountIn Amount
+   * @param { FeeAmount } feeAmount Fee tier (Low 0.05%, Medium 0.3%, High 1%)
+   * @param {number} slippage Slippage tolerance in %
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async tradeUniswapV3(
+    assetFrom: string,
+    assetTo: string,
+    amountIn: BigNumber | string,
+    feeAmount: FeeAmount,
+    slippage = 0.5,
+    options: any = null
+  ): Promise<any> {
+    const swapxData = await getUniswapV3SwapTxData(
+      this,
+      assetFrom,
+      assetTo,
+      amountIn,
+      slippage,
+      feeAmount
+    );
+    const tx = await this.poolLogic.execTransaction(
+      routerAddress[this.network][Dapp.UNISWAPV3],
+      swapxData,
+      options
+    );
+    return tx;
+  }
 }