@dhedge/v2-sdk 1.1.0 → 1.2.1

package/src/config.ts

@@ -7,16 +7,22 @@ import {
 import { ChainId } from "@sushiswap/sdk";
 import { NetworkChainIdMap } from ".";
 
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+require("dotenv").config();
+
 export const factoryAddress: AddressNetworkMap = {
-  [Network.POLYGON]: "0xfdc7b8bFe0DD3513Cc669bB8d601Cb83e2F69cB0"
+  [Network.POLYGON]: process.env.STAGING_CONTRACTS
+    ? "0xDd87eCdB10cFF7004276AAbAbd30e7a08F69bb53"
+    : "0xfdc7b8bFe0DD3513Cc669bB8d601Cb83e2F69cB0"
 };
 
 export const routerAddress: AddressDappNetworkMap = {
   [Network.POLYGON]: {
     [Dapp.SUSHISWAP]: "0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506",
     [Dapp.AAVE]: "0x8dFf5E27EA6b7AC08EbFdf9eB090F32ee9a30fcf",
-    [Dapp.ONEINCH]: "0x11111112542D85B3EF69AE05771c2dCCff4fAa26",
-    [Dapp.QUICKSWAP]: "0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff"
+    [Dapp.ONEINCH]: "0x1111111254fb6c44bac0bed2854e76f90643097d",
+    [Dapp.QUICKSWAP]: "0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff",
+    [Dapp.BALANCER]: "0xBA12222222228d8Ba445958a75a0704d566BF2C8"
   }
 };
 
@@ -29,10 +35,21 @@ export const dappFactoryAddress: AddressDappNetworkMap = {
 
 export const stakingAddress: AddressDappNetworkMap = {
   [Network.POLYGON]: {
-    [Dapp.SUSHISWAP]: "0x0769fd68dFb93167989C6f7254cd0D766Fb2841F"
+    [Dapp.SUSHISWAP]: "0x0769fd68dFb93167989C6f7254cd0D766Fb2841F",
+    [Dapp.BALANCER]: "0x0F3e0c4218b7b0108a3643cFe9D3ec0d4F57c54e",
+    [Dapp.AAVE]: "0x357D51124f59836DeD84c8a1730D72B749d8BC23"
   }
 };
 
 export const networkChainIdMap: NetworkChainIdMap = {
   [Network.POLYGON]: ChainId.MATIC
 };
+
+export const balancerSubgraph: AddressNetworkMap = {
+  [Network.POLYGON]:
+    "https://api.thegraph.com/subgraphs/name/balancer-labs/balancer-polygon-v2"
+};
+
+export const multiCallAddress: AddressNetworkMap = {
+  [Network.POLYGON]: "0x275617327c958bD06b5D6b871E7f491D76113dd8"
+};

package/src/entities/pool.ts

@@ -7,6 +7,8 @@ import IERC20 from "../abi/IERC20.json";
 import IMiniChefV2 from "../abi/IMiniChefV2.json";
 import ILendingPool from "../abi/ILendingPool.json";
 import IUniswapV2Router from "../abi/IUniswapV2Router.json";
+import IBalancerMerkleOrchard from "../abi/IBalancerMerkleOrchard.json";
+import IAaveIncentivesController from "../abi/IAaveIncentivesController.json";
 import { routerAddress, stakingAddress } from "../config";
 import {
   Dapp,
@@ -17,6 +19,7 @@ import {
 } from "../types";
 
 import { Utils } from "./utils";
+import { ClaimService } from "../services/claim-balancer/claim.service";
 
 export class Pool {
   public readonly poolLogic: Contract;
@@ -187,13 +190,21 @@ export class Pool {
   ): Promise<any> {
     let swapTxData: string;
     if (dapp === Dapp.ONEINCH) {
-      const apiUrl = `https://api.1inch.exchange/v3.0/137/swap?fromTokenAddress=${assetFrom}&toTokenAddress=${assetTo}&amount=${amountIn.toString()}&fromAddress=${
+      const apiUrl = `https://api.1inch.exchange/v4.0/137/swap?fromTokenAddress=${assetFrom}&toTokenAddress=${assetTo}&amount=${amountIn.toString()}&fromAddress=${
         this.address
       }&destReceiver=${
         this.address
       }&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 {
       const iUniswapV2Router = new ethers.utils.Interface(IUniswapV2Router.abi);
       const minAmountOut = await this.utils.getMinAmountOut(
@@ -342,7 +353,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 +370,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 +379,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 +387,7 @@ export class Pool {
       asset,
       amount,
       this.address,
-      0
+      referrralCode
     ]);
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][dapp],
@@ -416,6 +429,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 +437,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 +445,7 @@ export class Pool {
       asset,
       amount,
       2,
-      0,
+      referrralCode,
       this.address
     ]);
     const tx = await this.poolLogic.execTransaction(
@@ -531,4 +546,132 @@ 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;
+  }
 }

package/src/entities/utils.ts

@@ -8,17 +8,22 @@ import {
   Trade,
   Percent
 } from "@sushiswap/sdk";
+import { SOR, SwapTypes } from "@balancer-labs/sor";
+import { BaseProvider } from "@ethersproject/providers";
 
 import IERC20 from "../abi/IERC20.json";
 import IMiniChefV2 from "../abi/IMiniChefV2.json";
 import UniswapV2Factory from "../abi/IUniswapV2Factory.json";
 import UniswapV2Pair from "../abi/IUniswapV2Pair.json";
+import IBalancerV2Vault from "../abi/IBalancertV2Vault.json";
 import {
+  balancerSubgraph,
   dappFactoryAddress,
   networkChainIdMap,
   stakingAddress
 } from "../config";
 import { Dapp, Network, Reserves } from "../types";
+import { Pool } from ".";
 
 export class Utils {
   network: Network;
@@ -171,4 +176,134 @@ export class Utils {
         .raw.toString()
     );
   }
+
+  async getBalancerSwapTx(
+    pool: Pool,
+    assetFrom: string,
+    assetTo: string,
+    amountIn: ethers.BigNumber | string,
+    slippage: number
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ): Promise<any> {
+    const sor = new SOR(
+      this.signer.provider as BaseProvider,
+      networkChainIdMap[this.network],
+      balancerSubgraph[this.network]
+    );
+    // isFetched will be true on success
+    const isFetched = await sor.fetchPools();
+
+    if (!isFetched) throw new Error("Error fetching balancer pools");
+
+    const swapType = SwapTypes.SwapExactIn;
+    const { swaps, tokenAddresses, returnAmount } = await sor.getSwaps(
+      assetFrom,
+      assetTo,
+      swapType,
+      ethers.BigNumber.from(amountIn)
+    );
+
+    const minimumAmountOut = returnAmount
+      .mul(10000 - slippage * 100)
+      .div(10000);
+
+    const iBalancerV2Vault = new ethers.utils.Interface(IBalancerV2Vault.abi);
+
+    if (swaps.length === 1) {
+      const swap = swaps[0];
+      //do single swap
+      const swapTx = iBalancerV2Vault.encodeFunctionData("swap", [
+        [
+          swap.poolId,
+          SwapTypes.SwapExactIn,
+          tokenAddresses[swap.assetInIndex],
+          tokenAddresses[swap.assetOutIndex],
+          swap.amount,
+          swap.userData
+        ],
+        [pool.address, false, pool.address, false],
+        minimumAmountOut,
+        Math.floor(Date.now() / 1000) + 60 * 20 // 20 minutes from the current Unix time
+      ]);
+      return swapTx;
+    } else {
+      // Limits:
+      // +ve means max to send
+      // -ve mean min to receive
+      // For a multihop the intermediate tokens should be 0
+      const limits: string[] = [];
+      tokenAddresses.forEach((token, i) => {
+        if (token.toLowerCase() === assetFrom.toLowerCase()) {
+          limits[i] = amountIn.toString();
+        } else if (token.toLowerCase() === assetTo.toLowerCase()) {
+          limits[i] = minimumAmountOut.mul(-1).toString();
+        } else {
+          limits[i] = "0";
+        }
+      });
+      const swapTx = iBalancerV2Vault.encodeFunctionData("batchSwap", [
+        SwapTypes.SwapExactIn,
+        swaps,
+        tokenAddresses,
+        [pool.address, false, pool.address, false],
+        limits,
+        Math.floor(Date.now() / 1000) + 60 * 20 // 20 minutes from the current Unix time
+      ]);
+      return swapTx;
+    }
+  }
+
+  async getBalancerJoinPoolTx(
+    pool: Pool,
+    balancerPoolId: string,
+    assets: string[],
+    amountsIn: string[] | ethers.BigNumber[]
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ): Promise<any> {
+    const iBalancerV2Vault = new ethers.utils.Interface(IBalancerV2Vault.abi);
+    const txData = [
+      balancerPoolId,
+      pool.address,
+      pool.address,
+      [
+        assets,
+        amountsIn,
+        ethers.utils.defaultAbiCoder.encode(
+          ["uint256", "uint256[]", "uint256"],
+          [1, amountsIn, 0]
+        ),
+        false
+      ]
+    ];
+    const joinPoolTx = iBalancerV2Vault.encodeFunctionData("joinPool", txData);
+    return joinPoolTx;
+  }
+
+  async getBalancerExitPoolTx(
+    pool: Pool,
+    balancerPoolId: string,
+    assets: string[],
+    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 txData = [
+      balancerPoolId,
+      pool.address,
+      pool.address,
+      [
+        assets,
+        minimumAmountOut,
+        ethers.utils.defaultAbiCoder.encode(
+          ["uint256", "uint256"],
+          [1, amount]
+        ),
+        false
+      ]
+    ];
+    const exitPoolTx = iBalancerV2Vault.encodeFunctionData("exitPool", txData);
+    return exitPoolTx;
+  }
 }

package/src/services/claim-balancer/MultiTokenClaim.json

@@ -0,0 +1,115 @@
+{
+    "1": [
+        {
+            "label": "BAL",
+            "distributor": "0xd2EB7Bd802A7CA68d9AcD209bEc4E664A9abDD7b",
+            "token": "0xba100000625a3754423978a60c9317c58a424e3d",
+            "manifest": "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current.json",
+            "weekStart": 52
+        },
+        {
+            "label": "UNN",
+            "distributor": "0xBfbd6e720ffdF0497f69C95E5C03a4861C65A6E7",
+            "token": "0x226f7b842E0F0120b7E194D05432b3fd14773a9D",
+            "manifest": "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-union.json",
+            "weekStart": 1
+        },
+        {
+            "label": "BANK",
+            "distributor": "0x9d20FE66eC5Dd15a3D3213556534C77cA20318bE",
+            "token": "0x2d94AA3e47d9D5024503Ca8491fcE9A2fB4DA198",
+            "manifest": "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-bankless.json",
+            "weekStart": 1
+        },
+        {
+            "label": "NOTE",
+            "distributor": "0xF1C2dD9bD863f2444086B739383F1043E6b88F69",
+            "token": "0xcfeaead4947f0705a14ec42ac3d44129e1ef3ed5",
+            "manifest": "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-note.json",
+            "weekStart": 1
+        },
+        {
+            "label": "NEXO",
+            "distributor": "0x0000000000000000000000000000000000000000",
+            "token": "0xB62132e35a6c13ee1EE0f84dC5d40bad8d815206",
+            "manifest": "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-nexo.json",
+            "weekStart": 1
+        }
+    ],
+    "42": [
+      {
+          "label": "BAL",
+          "distributor": "0x95FaE1C936B4Cd6c5099d7A705D792ee6aC9FEc3",
+          "token": "0x41286Bb1D3E870f3F750eB7E1C25d7E48c8A1Ac7",
+          "manifest": "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/sample-tree/reports-kovan/_current.json",
+          "weekStart": 52
+      },
+      {
+        "label": "DAI",
+        "distributor": "0x95FaE1C936B4Cd6c5099d7A705D792ee6aC9FEc3",
+        "token": "0x04DF6e4121c27713ED22341E7c7Df330F56f289B",
+        "manifest": "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/sample-tree/reports-kovan/_current-dai.json",
+        "weekStart": 1
+    }
+    ],
+    "137": [
+        {
+            "label": "BAL",
+            "distributor": "0xd2EB7Bd802A7CA68d9AcD209bEc4E664A9abDD7b",
+            "token": "0x9a71012b13ca4d3d0cdc72a177df3ef03b0e76a3",
+            "manifest": "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-polygon.json",
+            "weekStart": 1
+        },
+        {
+            "label": "WMATIC",
+            "distributor": "0x087A7AFB6975A2837453BE685EB6272576c0bC06",
+            "token": "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
+            "manifest": "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-wmatic-polygon.json",
+            "weekStart": 1
+        },
+        {
+            "label": "WMATIC",
+            "distributor": "0xBd44C01EC7d623372B4572247afB6231eDD8486F",
+            "token": "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
+            "manifest": "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-wmatic-polygon.json",
+            "weekStart": 4
+        },
+        {
+            "label": "WMATIC",
+            "distributor": "0x632208491602Dd205da8Cb9C0BA98620fc19854A",
+            "token": "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
+            "manifest": "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-wmatic-polygon.json",
+            "weekStart": 5
+        },
+        {
+            "label": "TUSD",
+            "distributor": "0x09f3010ec0f6d72ef8ff2008f8e756d60482c9a8",
+            "token": "0x2e1ad108ff1d8c782fcbbb89aad783ac49586756",
+            "manifest": "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-tusd-polygon.json",
+            "weekStart": 1
+        }
+      ],
+    "42161": [
+        {
+            "label": "BAL",
+            "distributor": "0xd2EB7Bd802A7CA68d9AcD209bEc4E664A9abDD7b",
+            "token": "0x040d1EdC9569d4Bab2D15287Dc5A4F10F56a56B8",
+            "manifest": "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-arbitrum.json",
+            "weekStart": 6
+        },
+        {
+            "label": "MCB",
+            "distributor": "0x25c646adf184051b35a405b9aaeba321e8d5342a",
+            "token": "0x4e352cf164e64adcbad318c3a1e222e9eba4ce42",
+            "manifest": "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-mcdex-arbitrum.json",
+            "weekStart": 4
+        },
+        {
+            "label": "PICKLE",
+            "distributor": "0xf02CeB58d549E4b403e8F85FBBaEe4c5dfA47c01",
+            "token": "0x965772e0e9c84b6f359c8597c891108dcf1c5b1a",
+            "manifest": "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-pickle-arbitrum.json",
+            "weekStart": 4
+        }
+    ]
+  }