@dhedge/v2-sdk 1.3.0 → 1.4.2

package/src/entities/pool.ts

@@ -11,9 +11,14 @@ 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 IArrakisV1RouterStaking from "../abi/IArrakisV1RouterStaking.json";
+import ILiquidityGaugeV4 from "../abi/ILiquidityGaugeV4.json";
+import IBalancerRewardsGauge from "../abi/IBalancerRewardsGauge.json";
+
 import {
   deadline,
   MaxUint128,
+  networkChainIdMap,
   nonfungiblePositionManagerAddress,
   routerAddress,
   stakingAddress,
@@ -214,6 +219,33 @@ export class Pool {
     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
@@ -234,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
@@ -373,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;
   }
 
@@ -406,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
    */
@@ -419,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);
@@ -427,7 +507,7 @@ export class Pool {
       asset,
       amount,
       this.address,
-      referrralCode
+      referralCode
     ]);
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][dapp],
@@ -469,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
    */
@@ -477,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);
@@ -485,7 +565,7 @@ export class Pool {
       asset,
       amount,
       2,
-      referrralCode,
+      referralCode,
       this.address
     ]);
     const tx = await this.poolLogic.execTransaction(
@@ -620,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
    */
@@ -627,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(
@@ -770,99 +853,149 @@ export class Pool {
   }
 
   /**
-   * Remove liquidity from an UniswapV3 liquidity pool
+   * 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 removeLiquidityUniswapV3(
+  async decreaseLiquidity(
+    dapp: Dapp,
     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]]
-    );
+    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];
+      const multicallParams = [decreaseLiquidityTxData, collectTxData];
 
-    if (amount === 100) {
-      const burnTxData = iNonfungiblePositionManager.encodeFunctionData(
-        Transaction.BURN,
-        [tokenId]
-      );
-      multicallParams.push(burnTxData);
+      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 multicallTxData = iNonfungiblePositionManager.encodeFunctionData(
-      Transaction.MULTI_CALL,
-      [multicallParams]
-    );
+
     const tx = await this.poolLogic.execTransaction(
-      nonfungiblePositionManagerAddress[this.network],
-      multicallTxData,
+      dappAddress,
+      txData,
       options
     );
     return tx;
   }
 
   /**
-   * Increase liquidity of an UniswapV3 liquidity pool
+   * 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 increaseLiquidityUniswapV3(
+  async increaseLiquidity(
+    dapp: Dapp,
     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]]
-    );
+    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(
-      nonfungiblePositionManagerAddress[this.network],
-      increaseLiquidityTxData,
+      dappAddress,
+      txData,
       options
     );
     return tx;
   }
 
   /**
-   * Claim fees of an UniswapV3 liquidity pool
-   * @param {string} tokenId Token Id of UniswapV3 position
-   * @param {any} options Transaction options
+   * 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 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]]
-    );
+  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(
-      nonfungiblePositionManagerAddress[this.network],
-      collectTxData,
+      contractAddress,
+      txData,
       options
     );
     return tx;

package/src/entities/utils.ts

@@ -295,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;

package/src/test/1inch.test.ts

@@ -0,0 +1,54 @@
+import { Dhedge } from "..";
+import { Dapp, Network } from "../types";
+import { TEST_POOL, USDC, WETH } from "./constants";
+import { getTxOptions } from "./txOptions";
+
+import { wallet } from "./wallet";
+
+let dhedge: Dhedge;
+let options: any;
+
+jest.setTimeout(100000);
+
+describe("pool", () => {
+  beforeAll(async () => {
+    dhedge = new Dhedge(wallet, Network.OPTIMISM);
+    options = await getTxOptions(Network.OPTIMISM);
+  });
+
+  //   it("approves unlimited USDC on 1Inch", async () => {
+  //     let result;
+  //     const pool = await dhedge.loadPool(TEST_POOL);
+  //     try {
+  //       result = await pool.approve(
+  //         Dapp.ONEINCH,
+  //         USDC,
+  //         ethers.constants.MaxInt256,
+  //         options
+  //       );
+  //       console.log(result);
+  //     } catch (e) {
+  //       console.log(e);
+  //     }
+  //     expect(result).not.toBe(null);
+  //   });
+
+  it("trades 1 USDC into WETH on 1Inch", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.trade(
+        Dapp.ONEINCH,
+        USDC,
+        WETH,
+        "1000000",
+        0.5,
+        options
+      );
+      console.log(result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+});

package/src/test/aave.test.ts

@@ -1,6 +1,6 @@
-import { Dhedge, ethers } from "..";
-import { Network } from "../types";
-import { AMUSDC, TEST_POOL, VDEBTWETH } from "./constants";
+import { Dhedge } from "..";
+import { Dapp, Network } from "../types";
+import { TEST_POOL, WETH } from "./constants";
 
 import { wallet } from "./wallet";
 
@@ -8,16 +8,32 @@ let dhedge: Dhedge;
 
 jest.setTimeout(100000);
 
-const options = {
-  gasLimit: 5000000,
-  gasPrice: ethers.utils.parseUnits("100", "gwei")
-};
+// const options = {
+//   gasLimit: 5000000,
+//   gasPrice: ethers.utils.parseUnits("100", "gwei")
+// };
 
 describe("pool", () => {
   beforeAll(() => {
-    dhedge = new Dhedge(wallet, Network.POLYGON);
+    dhedge = new Dhedge(wallet, Network.OPTIMISM);
   });
 
+  // it("approves USDC to Aave", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.approve(
+  //       Dapp.AAVEV3,
+  //       USDC,
+  //       ethers.constants.MaxUint256
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
   // it("withdraws 1 USDC from Aave lending pool", async () => {
   //   let result;
   //   const pool = await dhedge.loadPool(myPool);
@@ -35,11 +51,23 @@ describe("pool", () => {
   //   expect(result).not.toBe(null);
   // });
 
-  // it("borrows 0.0001 WETH from Aave lending pool", async () => {
+  it("borrows 0.001 WETH from Aave lending pool", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.borrow(Dapp.AAVEV3, WETH, "1000000000000000");
+      console.log(result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+
+  // it("reapys 1USDC to Aave lending pool", async () => {
   //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
+  //   const pool = await dhedge.loadPool(TEST_POOL);
   //   try {
-  //     result = await pool.borrow(Dapp.AAVE, weth, "100000000000000");
+  //     result = await pool.repay(Dapp.AAVEV3, USDC, "1380000");
   //     console.log(result);
   //   } catch (e) {
   //     console.log(e);
@@ -47,11 +75,11 @@ describe("pool", () => {
   //   expect(result).not.toBe(null);
   // });
 
-  // it("reapys 0.0001 WETH to Aave lending pool", async () => {
+  // it("claims rewards from Aave", async () => {
   //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
+  //   const pool = await dhedge.loadPool(TEST_POOL);
   //   try {
-  //     result = await pool.repay(Dapp.AAVE, weth, "100000000000000", options);
+  //     result = await pool.harvestAaveRewards([AMUSDC, VDEBTWETH], options);
   //     console.log(result);
   //   } catch (e) {
   //     console.log(e);
@@ -59,15 +87,15 @@ describe("pool", () => {
   //   expect(result).not.toBe(null);
   // });
 
-  it("claims rewards from Aave", async () => {
-    let result;
-    const pool = await dhedge.loadPool(TEST_POOL);
-    try {
-      result = await pool.harvestAaveRewards([AMUSDC, VDEBTWETH], options);
-      console.log(result);
-    } catch (e) {
-      console.log(e);
-    }
-    expect(result).not.toBe(null);
-  });
+  // it("lends USDC to Aave", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     const balance = await dhedge.utils.getBalance(WETH, pool.address);
+  //     result = await pool.lend(Dapp.AAVEV3, WETH, balance, 196);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
 });