@dhedge/v2-sdk 1.2.1 → 1.4.1

package/src/entities/pool.ts

@@ -6,10 +6,24 @@ 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 INonfungiblePositionManager from "../abi/INonfungiblePositionManager.json";
 import IBalancerMerkleOrchard from "../abi/IBalancerMerkleOrchard.json";
 import IAaveIncentivesController from "../abi/IAaveIncentivesController.json";
-import { routerAddress, stakingAddress } from "../config";
+import IArrakisV1RouterStaking from "../abi/IArrakisV1RouterStaking.json";
+import ILiquidityGaugeV4 from "../abi/ILiquidityGaugeV4.json";
+import IBalancerRewardsGauge from "../abi/IBalancerRewardsGauge.json";
+
+import {
+  deadline,
+  MaxUint128,
+  networkChainIdMap,
+  nonfungiblePositionManagerAddress,
+  routerAddress,
+  stakingAddress,
+  SYNTHETIX_TRACKING_CODE
+} from "../config";
 import {
   Dapp,
   Transaction,
@@ -20,10 +34,17 @@ import {
 
 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;
@@ -34,7 +55,8 @@ export class Pool {
     signer: Wallet,
     poolLogic: Contract,
     mangerLogic: Contract,
-    utils: Utils
+    utils: Utils,
+    factory: Contract
   ) {
     this.network = network;
     this.poolLogic = poolLogic;
@@ -42,6 +64,7 @@ export class Pool {
     this.managerLogic = mangerLogic;
     this.signer = signer;
     this.utils = utils;
+    this.factory = factory;
   }
 
   /**
@@ -170,13 +193,66 @@ 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;
+  }
+
+  /**
+   * 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
    * @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
    */
@@ -190,7 +266,8 @@ export class Pool {
   ): Promise<any> {
     let swapTxData: string;
     if (dapp === Dapp.ONEINCH) {
-      const apiUrl = `https://api.1inch.exchange/v4.0/137/swap?fromTokenAddress=${assetFrom}&toTokenAddress=${assetTo}&amount=${amountIn.toString()}&fromAddress=${
+      const chainId = networkChainIdMap[this.network];
+      const apiUrl = `https://api.1inch.exchange/v4.0/${chainId}/swap?fromTokenAddress=${assetFrom}&toTokenAddress=${assetTo}&amount=${amountIn.toString()}&fromAddress=${
         this.address
       }&destReceiver=${
         this.address
@@ -205,6 +282,19 @@ export class Pool {
         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(
@@ -219,7 +309,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(
@@ -251,16 +341,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],
@@ -289,15 +370,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],
@@ -333,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;
   }
 
@@ -366,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
    */
@@ -379,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);
@@ -387,7 +507,7 @@ export class Pool {
       asset,
       amount,
       this.address,
-      referrralCode
+      referralCode
     ]);
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][dapp],
@@ -429,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
    */
@@ -437,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);
@@ -445,7 +565,7 @@ export class Pool {
       asset,
       amount,
       2,
-      referrralCode,
+      referralCode,
       this.address
     ]);
     const tx = await this.poolLogic.execTransaction(
@@ -580,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
    */
@@ -587,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(
@@ -657,16 +780,13 @@ export class Pool {
       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,
@@ -674,4 +794,245 @@ export class Pool {
     );
     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 or Arrakis liquidity pool
+   * @param {Dapp} dapp Platform either UniswapV3 or Arrakis
+   * @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 decreaseLiquidity(
+    dapp: Dapp,
+    tokenId: string,
+    amount = 100,
+    options: any = null
+  ): Promise<any> {
+    let txData;
+    let dappAddress;
+    if (dapp === Dapp.UNISWAPV3) {
+      dappAddress = nonfungiblePositionManagerAddress[this.network];
+      const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
+      const liquidity = (await getUniswapV3Liquidity(tokenId, this))
+        .mul(amount)
+        .div(100);
+      const decreaseLiquidityTxData = abi.encodeFunctionData(
+        Transaction.DECREASE_LIQUIDITY,
+        [[tokenId, liquidity, 0, 0, deadline]]
+      );
+      const collectTxData = abi.encodeFunctionData(Transaction.COLLECT, [
+        [tokenId, this.address, MaxUint128, MaxUint128]
+      ]);
+
+      const multicallParams = [decreaseLiquidityTxData, collectTxData];
+
+      if (amount === 100) {
+        const burnTxData = abi.encodeFunctionData(Transaction.BURN, [tokenId]);
+        multicallParams.push(burnTxData);
+      }
+      txData = abi.encodeFunctionData(Transaction.MULTI_CALL, [
+        multicallParams
+      ]);
+    } else if (dapp === Dapp.ARRAKIS) {
+      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);
+      txData = abi.encodeFunctionData(Transaction.REMOVE_LIQUIDITY_UNSTAKE, [
+        tokenId,
+        liquidity,
+        0,
+        0,
+        this.address
+      ]);
+    } else {
+      throw new Error("dapp not supported");
+    }
+
+    const tx = await this.poolLogic.execTransaction(
+      dappAddress,
+      txData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Increase liquidity of an UniswapV3 or Arrakis liquidity pool
+   * @param {Dapp} dapp Platform either UniswapV3 or Arrakis
+   * @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 increaseLiquidity(
+    dapp: Dapp,
+    tokenId: string,
+    amountA: BigNumber | string,
+    amountB: BigNumber | string,
+    options: any = null
+  ): Promise<any> {
+    let txData;
+    let dappAddress;
+    if (dapp === Dapp.UNISWAPV3) {
+      dappAddress = nonfungiblePositionManagerAddress[this.network];
+      const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
+      txData = abi.encodeFunctionData(Transaction.INCREASE_LIQUIDITY, [
+        [tokenId, amountA, amountB, 0, 0, deadline]
+      ]);
+    } else if (dapp === Dapp.ARRAKIS) {
+      dappAddress = routerAddress[this.network][dapp];
+      const abi = new ethers.utils.Interface(IArrakisV1RouterStaking.abi);
+      txData = abi.encodeFunctionData(Transaction.ADD_LIQUIDITY_STAKE, [
+        tokenId,
+        amountA,
+        amountB,
+        0,
+        0,
+        this.address
+      ]);
+    } else {
+      throw new Error("dapp not supported");
+    }
+
+    const tx = await this.poolLogic.execTransaction(
+      dappAddress,
+      txData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * 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 Gauge address
+   * @param {any} options Transaction option
+   * @returns {Promise<any>} Transaction
+   */
+  async claimFees(
+    dapp: Dapp,
+    tokenId: string,
+    options: any = null
+  ): Promise<any> {
+    let txData;
+    let contractAddress;
+    if (dapp === Dapp.UNISWAPV3) {
+      contractAddress = nonfungiblePositionManagerAddress[this.network];
+      const iNonfungiblePositionManager = new ethers.utils.Interface(
+        INonfungiblePositionManager.abi
+      );
+      txData = iNonfungiblePositionManager.encodeFunctionData(
+        Transaction.COLLECT,
+        [[tokenId, this.address, MaxUint128, MaxUint128]]
+      );
+    } else if (dapp === Dapp.ARRAKIS || dapp === Dapp.BALANCER) {
+      contractAddress = tokenId;
+      const abi = new ethers.utils.Interface(ILiquidityGaugeV4.abi);
+      txData = abi.encodeFunctionData("claim_rewards()", []);
+    } else {
+      throw new Error("dapp not supported");
+    }
+    const tx = await this.poolLogic.execTransaction(
+      contractAddress,
+      txData,
+      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;
+  }
 }

package/src/entities/utils.ts

@@ -125,6 +125,18 @@ export class Utils {
     return balance;
   }
 
+  /**
+   * Returns the decimals of an asset (ERC20) token
+   * @param {string} asset string token address
+   * @returns { number } Balance of asset
+   */
+
+  async getDecimals(asset: string): Promise<number> {
+    const iERC20 = new ethers.Contract(asset, IERC20.abi, this.signer);
+    const decimals = await iERC20.decimals();
+    return decimals;
+  }
+
   /**
    * Return the minimum amount out for a trade between two assets
    * given the trade amount and slippage
@@ -283,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;