@dhedge/v2-sdk 1.0.0 → 1.2.0

package/src/config.ts

@@ -4,25 +4,48 @@ import {
   Network,
   AddressDappNetworkMap
 } from "./types";
+import { ChainId } from "@sushiswap/sdk";
+import { NetworkChainIdMap } from ".";
 
 export const factoryAddress: AddressNetworkMap = {
   [Network.POLYGON]: "0xfdc7b8bFe0DD3513Cc669bB8d601Cb83e2F69cB0"
+  //[Network.POLYGON]: "0xDd87eCdB10cFF7004276AAbAbd30e7a08F69bb53"
 };
 
 export const routerAddress: AddressDappNetworkMap = {
   [Network.POLYGON]: {
-    [Dapp.SUSHISWAP]: "0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506"
+    [Dapp.SUSHISWAP]: "0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506",
+    [Dapp.AAVE]: "0x8dFf5E27EA6b7AC08EbFdf9eB090F32ee9a30fcf",
+    [Dapp.ONEINCH]: "0x1111111254fb6c44bac0bed2854e76f90643097d",
+    [Dapp.QUICKSWAP]: "0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff",
+    [Dapp.BALANCER]: "0xBA12222222228d8Ba445958a75a0704d566BF2C8"
   }
 };
 
 export const dappFactoryAddress: AddressDappNetworkMap = {
   [Network.POLYGON]: {
-    [Dapp.SUSHISWAP]: "0xc35DADB65012eC5796536bD9864eD8773aBc74C4"
+    [Dapp.SUSHISWAP]: "0xc35DADB65012eC5796536bD9864eD8773aBc74C4",
+    [Dapp.QUICKSWAP]: "0x5757371414417b8C6CAad45bAeF941aBc7d3Ab32"
   }
 };
 
 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/dhedge.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { Contract, Wallet } from "ethers";
 
 import PoolFactory from "../abi/PoolFactory.json";
@@ -34,6 +35,7 @@ export class Dhedge {
    * @param {string} symbol Token symbol
    * @param {tuple[]} supportedAssets Enabled assets to trade
    * @param {number|BigNumber} managerFeeNumerator Manger fee in percent
+   * @param {any} options Transaction options
    * @returns {Pool} Created Pool
    */
   public async createPool(
@@ -41,7 +43,8 @@ export class Dhedge {
     poolName: string,
     symbol: string,
     supportedAssets: SupportedAsset[],
-    managerFeeNumerator = 100
+    managerFeeNumerator = 20,
+    options: any = null
   ): Promise<Pool> {
     const pool = await this.factory.createFund(
       false,
@@ -49,8 +52,9 @@ export class Dhedge {
       managerName,
       poolName,
       symbol,
-      managerFeeNumerator,
-      supportedAssets
+      managerFeeNumerator * 100,
+      supportedAssets,
+      options
     );
     const receipt = await pool.wait(1);
 

package/src/entities/pool.ts

@@ -1,9 +1,14 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import axios from "axios";
 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 IUniswapV2Router from "../abi/IUniswapV2Router.json";
+import IBalancerMerkleOrchard from "../abi/IBalancerMerkleOrchard.json";
+import IAaveIncentivesController from "../abi/IAaveIncentivesController.json";
 import { routerAddress, stakingAddress } from "../config";
 import {
   Dapp,
@@ -14,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;
@@ -65,14 +71,16 @@ export class Pool {
    * Approve the asset that can be deposited into a pool
    * @param {string} nasset Address of deposit asset
    * @param {BigNumber | string} amount Amount to be approved
+   * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
   async approveDeposit(
     asset: string,
-    amount: BigNumber | string
+    amount: BigNumber | string,
+    options: any = null
   ): Promise<any> {
     const iERC20 = new ethers.Contract(asset, IERC20.abi, this.signer);
-    const tx = await iERC20.approve(this.address, amount);
+    const tx = await iERC20.approve(this.address, amount, options);
     return tx;
   }
 
@@ -80,20 +88,29 @@ export class Pool {
    * Deposit  asset into a pool
    * @param {string} asset Address of asset
    * @param {BigNumber | string} amount Amount to be deposited
+   * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
-  async deposit(asset: string, amount: string | BigNumber): Promise<any> {
-    const tx = await this.poolLogic.deposit(asset, amount);
+  async deposit(
+    asset: string,
+    amount: string | BigNumber,
+    options: any = null
+  ): Promise<any> {
+    const tx = await this.poolLogic.deposit(asset, amount, options);
     return tx;
   }
 
   /**
    * Withdraw  assets from a pool
    * @param fundTokenAmount Amount of pool tokens to be withdrawn
+   * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
-  async withdraw(fundTokenAmount: string | BigNumber): Promise<any> {
-    const tx = await this.poolLogic.withdraw(fundTokenAmount);
+  async withdraw(
+    fundTokenAmount: string | BigNumber,
+    options: any = null
+  ): Promise<any> {
+    const tx = await this.poolLogic.withdraw(fundTokenAmount, options);
     return tx;
   }
 
@@ -104,19 +121,25 @@ export class Pool {
    * @param {Dapp} dapp Platform like Sushiswap or Uniswap
    * @param {string} asset Address of asset
    * @param @param {BigNumber | string} Amount to be approved
+   * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
   async approve(
     dapp: Dapp,
     asset: string,
-    amount: BigNumber | string
+    amount: BigNumber | string,
+    options: any = null
   ): Promise<any> {
     const iERC20 = new ethers.utils.Interface(IERC20.abi);
     const approveTxData = iERC20.encodeFunctionData("approve", [
       routerAddress[this.network][dapp],
       amount
     ]);
-    const tx = await this.poolLogic.execTransaction(asset, approveTxData);
+    const tx = await this.poolLogic.execTransaction(
+      asset,
+      approveTxData,
+      options
+    );
     return tx;
   }
 
@@ -125,19 +148,25 @@ export class Pool {
    * @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 approveStaking(
     dapp: Dapp,
     asset: string,
-    amount: BigNumber | string
+    amount: BigNumber | string,
+    options: any = null
   ): Promise<any> {
     const iERC20 = new ethers.utils.Interface(IERC20.abi);
     const approveTxData = iERC20.encodeFunctionData("approve", [
       stakingAddress[this.network][dapp],
       amount
     ]);
-    const tx = await this.poolLogic.execTransaction(asset, approveTxData);
+    const tx = await this.poolLogic.execTransaction(
+      asset,
+      approveTxData,
+      options
+    );
     return tx;
   }
 
@@ -148,6 +177,7 @@ export class Pool {
    * @param {string} assetTo Asset to trade into
    * @param {BigNumber | string} amountIn Amount
    * @param {BigNumber | string} minAmountOut Minumum amount to receive
+   * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
   async trade(
@@ -155,19 +185,47 @@ export class Pool {
     assetFrom: string,
     assetTo: string,
     amountIn: BigNumber | string,
-    minAmountOut: BigNumber | string
+    slippage = 0.5,
+    options: any = null
   ): Promise<any> {
-    const iUniswapV2Router = new ethers.utils.Interface(IUniswapV2Router.abi);
-    const swapTxData = iUniswapV2Router.encodeFunctionData(Transaction.SWAP, [
-      amountIn,
-      minAmountOut,
-      [assetFrom, assetTo],
-      this.address,
-      Math.floor(Date.now() / 1000) + 60 * 20 // 20 minutes from the current Unix time
-    ]);
+    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=${
+        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(
+        dapp,
+        assetFrom,
+        assetTo,
+        amountIn,
+        slippage
+      );
+      swapTxData = iUniswapV2Router.encodeFunctionData(Transaction.SWAP, [
+        amountIn,
+        minAmountOut,
+        [assetFrom, assetTo],
+        this.address,
+        Math.floor(Date.now() / 1000) + 60 * 20 // 20 minutes from the current Unix time
+      ]);
+    }
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][dapp],
-      swapTxData
+      swapTxData,
+      options
     );
     return tx;
   }
@@ -179,6 +237,7 @@ export class Pool {
    * @param {string} assetB Second asset
    * @param {BigNumber | string} amountA Amount first asset
    * @param {BigNumber | string} amountB Amount second asset
+   * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
   async addLiquidity(
@@ -186,7 +245,8 @@ export class Pool {
     assetA: string,
     assetB: string,
     amountA: BigNumber | string,
-    amountB: BigNumber | string
+    amountB: BigNumber | string,
+    options: any = null
   ): Promise<any> {
     const iUniswapV2Router = new ethers.utils.Interface(IUniswapV2Router.abi);
     const addLiquidityTxData = iUniswapV2Router.encodeFunctionData(
@@ -204,7 +264,8 @@ export class Pool {
     );
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][dapp],
-      addLiquidityTxData
+      addLiquidityTxData,
+      options
     );
     return tx;
   }
@@ -215,13 +276,15 @@ export class Pool {
    * @param {string} assetA First asset
    * @param {string} assetB Second asset
    * @param {BigNumber | string} amount Amount of liquidity pool tokens
+   * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
   async removeLiquidity(
     dapp: Dapp,
     assetA: string,
     assetB: string,
-    amount: string | BigNumber
+    amount: string | BigNumber,
+    options: any = null
   ): Promise<any> {
     const iUniswapV2Router = new ethers.utils.Interface(IUniswapV2Router.abi);
     const removeLiquidityTxData = iUniswapV2Router.encodeFunctionData(
@@ -238,7 +301,8 @@ export class Pool {
     );
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][dapp],
-      removeLiquidityTxData
+      removeLiquidityTxData,
+      options
     );
     return tx;
   }
@@ -248,12 +312,14 @@ export class Pool {
    * @param {Dapp} dapp Platform like Sushiswap or Uniswap
    * @param {string} asset Liquidity pool token
    * @param {BigNumber | string} amount Amount of liquidity pool tokens
+   * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
   async stake(
     dapp: Dapp,
     asset: string,
-    amount: BigNumber | string
+    amount: BigNumber | string,
+    options: any = null
   ): Promise<any> {
     const iMiniChefV2 = new ethers.utils.Interface(IMiniChefV2.abi);
     const poolId = await this.utils.getLpPoolId(dapp, asset);
@@ -264,7 +330,8 @@ export class Pool {
     ]);
     const tx = await this.poolLogic.execTransaction(
       stakingAddress[this.network][dapp],
-      stakeTxData
+      stakeTxData,
+      options
     );
 
     return tx;
@@ -275,23 +342,141 @@ export class Pool {
    * @param {Dapp} dapp Platform like Sushiswap or Uniswap
    * @param {string} asset Liquidity pool token
    * @param  {BigNumber | string} amount Amount of liquidity pool tokens
+   * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
   async unStake(
     dapp: Dapp,
     asset: string,
-    amount: BigNumber | string
+    amount: BigNumber | string,
+    options: any = null
   ): 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
     ]);
     const tx = await this.poolLogic.execTransaction(
       stakingAddress[this.network][dapp],
-      unStakeTxData
+      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 {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async lend(
+    dapp: Dapp,
+    asset: string,
+    amount: BigNumber | string,
+    options: any = null
+  ): Promise<any> {
+    const iLendingPool = new ethers.utils.Interface(ILendingPool.abi);
+    const depositTxData = iLendingPool.encodeFunctionData(Transaction.DEPOSIT, [
+      asset,
+      amount,
+      this.address,
+      0
+    ]);
+    const tx = await this.poolLogic.execTransaction(
+      routerAddress[this.network][dapp],
+      depositTxData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Witdraw asset from a lending pool
+   * @param {Dapp} dapp Platform like Aave
+   * @param {string} asset Asset
+   * @param  {BigNumber | string} amount Amount of asset to lend
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async withdrawDeposit(
+    dapp: Dapp,
+    asset: string,
+    amount: BigNumber | string,
+    options: any = null
+  ): Promise<any> {
+    const iLendingPool = new ethers.utils.Interface(ILendingPool.abi);
+    const withdrawTxData = iLendingPool.encodeFunctionData(
+      Transaction.WITHDRAW,
+      [asset, amount, this.address]
+    );
+    const tx = await this.poolLogic.execTransaction(
+      routerAddress[this.network][dapp],
+      withdrawTxData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Borrow asset from a lending pool
+   * @param {Dapp} dapp Platform like Aave
+   * @param {string} asset Asset
+   * @param  {BigNumber | string} amount Amount of asset to lend
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async borrow(
+    dapp: Dapp,
+    asset: string,
+    amount: BigNumber | string,
+    options: any = null
+  ): Promise<any> {
+    const iLendingPool = new ethers.utils.Interface(ILendingPool.abi);
+    const borrowTxData = iLendingPool.encodeFunctionData(Transaction.BORROW, [
+      asset,
+      amount,
+      2,
+      0,
+      this.address
+    ]);
+    const tx = await this.poolLogic.execTransaction(
+      routerAddress[this.network][dapp],
+      borrowTxData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Repays borrowed 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 {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async repay(
+    dapp: Dapp,
+    asset: string,
+    amount: BigNumber | string,
+    options: any = null
+  ): Promise<any> {
+    const iLendingPool = new ethers.utils.Interface(ILendingPool.abi);
+    const repayTxData = iLendingPool.encodeFunctionData(Transaction.REPAY, [
+      asset,
+      amount,
+      2,
+      this.address
+    ]);
+    const tx = await this.poolLogic.execTransaction(
+      routerAddress[this.network][dapp],
+      repayTxData,
+      options
     );
     return tx;
   }
@@ -300,9 +485,14 @@ export class Pool {
    * Claim rewards of staked liquidity pool tokens
    * @param {Dapp} dapp Platform like Sushiswap or Uniswap
    * @param {string} asset Liquidity pool token
+   * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
-  async harvestRewards(dapp: Dapp, asset: string): Promise<any> {
+  async harvestRewards(
+    dapp: Dapp,
+    asset: string,
+    options: any = null
+  ): Promise<any> {
     const iMiniChefV2 = new ethers.utils.Interface(IMiniChefV2.abi);
     const poolId = await this.utils.getLpPoolId(dapp, asset);
     const harvestTxData = iMiniChefV2.encodeFunctionData(Transaction.HARVEST, [
@@ -311,7 +501,8 @@ export class Pool {
     ]);
     const tx = await this.poolLogic.execTransaction(
       stakingAddress[this.network][dapp],
-      harvestTxData
+      harvestTxData,
+      options
     );
     return tx;
   }
@@ -319,9 +510,13 @@ export class Pool {
   /**
    * Change enabled pool assets
    * @param {AssetEnabled[]} assets New pool assets
+   * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
-  public async changeAssets(assets: AssetEnabled[]): Promise<any> {
+  public async changeAssets(
+    assets: AssetEnabled[],
+    options: any = null
+  ): Promise<any> {
     const currentAssetsEnabled = await this.getComposition();
     const currentAssets = currentAssetsEnabled.map(e =>
       e.asset.toLocaleLowerCase()
@@ -331,7 +526,8 @@ export class Pool {
     const changedAssets = assets.map(e => [e.asset, e.isDeposit]);
     const tx = await this.managerLogic.changeAssets(
       changedAssets,
-      removedAssets
+      removedAssets,
+      options
     );
     return tx;
   }
@@ -339,10 +535,139 @@ export class Pool {
   /**
    * Set a new trader with trading permissions
    * @param {string} trader Address trader account
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async setTrader(trader: string, options: any = null): Promise<any> {
+    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 setTrader(trader: string): Promise<any> {
-    const tx = await this.managerLogic.setTrader(trader);
+  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;
   }
 }