@dhedge/v2-sdk 1.2.0 → 1.4.0

package/src/entities/pool.ts

@@ -6,10 +6,22 @@ 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 {
+  deadline,
+  MaxUint128,
+  networkChainIdMap,
+  nonfungiblePositionManagerAddress,
+  routerAddress,
+  stakingAddress,
+  SYNTHETIX_TRACKING_CODE
+} from "../config";
 import {
   Dapp,
   Transaction,
@@ -20,10 +32,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 +53,8 @@ export class Pool {
     signer: Wallet,
     poolLogic: Contract,
     mangerLogic: Contract,
-    utils: Utils
+    utils: Utils,
+    factory: Contract
   ) {
     this.network = network;
     this.poolLogic = poolLogic;
@@ -42,6 +62,7 @@ export class Pool {
     this.managerLogic = mangerLogic;
     this.signer = signer;
     this.utils = utils;
+    this.factory = factory;
   }
 
   /**
@@ -170,13 +191,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
    */
@@ -190,7 +237,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 +253,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 +280,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 +312,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 +341,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],
@@ -370,7 +414,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
    */
@@ -378,6 +423,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);
@@ -385,7 +431,7 @@ export class Pool {
       asset,
       amount,
       this.address,
-      0
+      referrralCode
     ]);
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][dapp],
@@ -427,6 +473,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
    */
@@ -434,6 +481,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);
@@ -441,7 +489,7 @@ export class Pool {
       asset,
       amount,
       2,
-      0,
+      referrralCode,
       this.address
     ]);
     const tx = await this.poolLogic.execTransaction(
@@ -653,16 +701,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,
@@ -670,4 +715,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 Arrakis position
+   * @param {any} options Transaction options
+   * @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) {
+      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

package/src/services/claim-balancer/claim.service.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import axios from "axios";
-import { chunk, flatten, groupBy } from "lodash";
+import { chunk, flatten } from "lodash";
 import merkleOrchardAbi from "../../abi/IBalancerMerkleOrchard.json";
 import { ethers, Wallet } from "ethers";
 
@@ -11,14 +11,10 @@ import { bnum, loadTree, scale } from "../../utils";
 
 import { ipfsService } from "./ipfs.service";
 
-import MultiTokenClaim from "./MultiTokenClaim.json";
-
 import {
   ClaimProofTuple,
   ClaimStatus,
   ComputeClaimProofPayload,
-  MultiTokenCurrentRewardsEstimate,
-  MultiTokenCurrentRewardsEstimateResponse,
   MultiTokenPendingClaims,
   Report,
   Snapshot,
@@ -26,7 +22,7 @@ import {
 } from "./types";
 
 import { Network } from "../../types";
-import { stakingAddress } from "../../config";
+import { networkChainIdMap, stakingAddress } from "../../config";
 import { soliditySha3 } from "web3-utils";
 import { Dapp } from "../..";
 
@@ -40,7 +36,7 @@ export class ClaimService {
   public async getMultiTokensPendingClaims(
     account: string
   ): Promise<MultiTokenPendingClaims[]> {
-    const tokenClaimsInfo = this.getTokenClaimsInfo();
+    const tokenClaimsInfo = await this.getTokenClaimsInfo();
     if (tokenClaimsInfo != null) {
       const multiTokenPendingClaims = await Promise.all(
         tokenClaimsInfo.map(tokenClaimInfo =>
@@ -100,73 +96,6 @@ export class ClaimService {
     };
   }
 
-  public async getMultiTokensCurrentRewardsEstimate(
-    account: string
-  ): Promise<{
-    data: MultiTokenCurrentRewardsEstimate[];
-    timestamp: string | null;
-  }> {
-    try {
-      const response = await axios.get<
-        MultiTokenCurrentRewardsEstimateResponse
-      >(
-        `https://api.balancer.finance/liquidity-mining/v1/liquidity-provider-multitoken/${account}`
-      );
-      if (response.data.success) {
-        const multiTokenLiquidityProviders = response.data.result[
-          "liquidity-providers"
-        ]
-          .filter(incentive => incentive.chain_id === 137)
-          .map(incentive => ({
-            ...incentive,
-            token_address: getAddress(incentive.token_address)
-          }));
-
-        const multiTokenCurrentRewardsEstimate: MultiTokenCurrentRewardsEstimate[] = [];
-
-        const multiTokenLiquidityProvidersByToken = Object.entries(
-          groupBy(multiTokenLiquidityProviders, "token_address")
-        );
-
-        for (const [
-          token,
-          liquidityProvider
-        ] of multiTokenLiquidityProvidersByToken) {
-          const rewards = liquidityProvider
-            .reduce(
-              (total, { current_estimate }) => total.plus(current_estimate),
-              bnum(0)
-            )
-            .toString();
-
-          const velocity =
-            liquidityProvider
-              .find(liquidityProvider => Number(liquidityProvider.velocity) > 0)
-              ?.velocity.toString() ?? "0";
-
-          if (Number(rewards) > 0) {
-            multiTokenCurrentRewardsEstimate.push({
-              rewards,
-              velocity,
-              token: getAddress(token)
-            });
-          }
-        }
-
-        return {
-          data: multiTokenCurrentRewardsEstimate,
-          timestamp: response.data.result.current_timestamp
-        };
-      }
-    } catch (e) {
-      console.log("[Claim] Current Rewards Estimate Error", e);
-    }
-    return {
-      data: [],
-      timestamp: null
-    };
-  }
-
   public async multiTokenClaimRewards(
     account: string,
     multiTokenPendingClaims: MultiTokenPendingClaims[]
@@ -243,8 +172,17 @@ export class ClaimService {
     ] as ClaimProofTuple;
   }
 
-  private getTokenClaimsInfo() {
-    const tokenClaims = MultiTokenClaim["137"];
+  private async getTokenClaimsInfo() {
+    let tokenClaims;
+    try {
+      const multiTokenClaim = await axios.get(
+        "https://raw.githubusercontent.com/balancer-labs/frontend-v2/develop/src/services/claim/MultiTokenClaim.json"
+      );
+      const chainId = networkChainIdMap[this.network];
+      tokenClaims = multiTokenClaim.data[chainId];
+    } catch (e) {
+      console.log("balancer multi token info error", e);
+    }
 
     if (tokenClaims != null) {
       return (tokenClaims as TokenClaimInfo[]).map(tokenClaim => ({