@dhedge/v2-sdk 1.4.3 → 1.5.2

package/src/config.ts

@@ -25,13 +25,15 @@ export const routerAddress: AddressDappNetworkMap = {
     [Dapp.QUICKSWAP]: "0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff",
     [Dapp.BALANCER]: "0xBA12222222228d8Ba445958a75a0704d566BF2C8",
     [Dapp.UNISWAPV3]: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
-    [Dapp.ARRAKIS]: "0xbc91a120cCD8F80b819EAF32F0996daC3Fa76a6C"
+    [Dapp.ARRAKIS]: "0xbc91a120cCD8F80b819EAF32F0996daC3Fa76a6C",
+    [Dapp.TOROS]: "0x42B1DDcFa1c43E06F483BA0Dd1b9cC923043677f"
   },
   [Network.OPTIMISM]: {
     [Dapp.UNISWAPV3]: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
     [Dapp.SYNTHETIX]: "0x8700dAec35aF8Ff88c16BdF0418774CB3D7599B4",
     [Dapp.AAVEV3]: "0x794a61358D6845594F94dc1DB02A252b5b4814aD",
-    [Dapp.ONEINCH]: "0x1111111254760F7ab3F16433eea9304126DCd199"
+    [Dapp.ONEINCH]: "0x1111111254760F7ab3F16433eea9304126DCd199",
+    [Dapp.TOROS]: "0xf8C62BD5f2fEf9E1a329c197F32E77AD6866B022"
   }
 };
 
@@ -47,11 +49,23 @@ export const stakingAddress: AddressDappNetworkMap = {
   [Network.POLYGON]: {
     [Dapp.SUSHISWAP]: "0x0769fd68dFb93167989C6f7254cd0D766Fb2841F",
     [Dapp.BALANCER]: "0x0F3e0c4218b7b0108a3643cFe9D3ec0d4F57c54e",
-    [Dapp.AAVE]: "0x357D51124f59836DeD84c8a1730D72B749d8BC23"
+    [Dapp.AAVE]: "0x357D51124f59836DeD84c8a1730D72B749d8BC23",
+    [Dapp.AAVEV3]: "0x929EC64c34a17401F460460D4B9390518E5B473e"
   },
-  [Network.OPTIMISM]: {}
+  [Network.OPTIMISM]: {
+    [Dapp.AAVEV3]: "0x929EC64c34a17401F460460D4B9390518E5B473e"
+  }
 };
 
+export const aaveAddressProvider: AddressDappNetworkMap = {
+  [Network.POLYGON]: {
+    [Dapp.AAVE]: "0xd05e3E715d945B59290df0ae8eF85c1BdB684744",
+    [Dapp.AAVEV3]: "0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb"
+  },
+  [Network.OPTIMISM]: {
+    [Dapp.AAVEV3]: "0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb"
+  }
+};
 export const nonfungiblePositionManagerAddress: AddressNetworkMap = {
   [Network.POLYGON]: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
   [Network.OPTIMISM]: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"

package/src/entities/dhedge.ts

@@ -105,4 +105,13 @@ export class Dhedge {
       this.factory
     );
   }
+
+  /**
+   * Check if pool address is valid
+   * @param {string} address Pool address
+   * @returns {boolean} Is valid pool address
+   */
+  validatePool(address: string): Promise<boolean> {
+    return this.factory.isPool(address);
+  }
 }

package/src/entities/pool.ts

@@ -40,6 +40,9 @@ import {
 } from "../services/uniswap/V3Liquidity";
 import { FeeAmount } from "@uniswap/v3-sdk";
 import { getUniswapV3SwapTxData } from "../services/uniswap/V3Trade";
+import { getEasySwapperTxData } from "../services/toros/easySwapper";
+import { getOneInchProtocols } from "../services/oneInch/protocols";
+import { getAaveV3ClaimTxData } from "../services/aave/incentives";
 
 export class Pool {
   public readonly poolLogic: Contract;
@@ -265,52 +268,68 @@ export class Pool {
     options: any = null
   ): Promise<any> {
     let swapTxData: string;
-    if (dapp === Dapp.ONEINCH) {
-      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
-      }&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 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(
-        dapp,
-        assetFrom,
-        assetTo,
-        amountIn,
-        slippage
-      );
-      swapTxData = iUniswapV2Router.encodeFunctionData(Transaction.SWAP, [
-        amountIn,
-        minAmountOut,
-        [assetFrom, assetTo],
-        this.address,
-        deadline
-      ]);
+    switch (dapp) {
+      case Dapp.ONEINCH:
+        const chainId = networkChainIdMap[this.network];
+        const protocols = await getOneInchProtocols(chainId);
+        const apiUrl = `https://api.1inch.exchange/v4.0/${chainId}/swap?fromTokenAddress=${assetFrom}&toTokenAddress=${assetTo}&amount=${amountIn.toString()}&fromAddress=${
+          this.address
+        }&destReceiver=${
+          this.address
+        }&slippage=${slippage.toString()}&disableEstimate=true${protocols}`;
+        const response = await axios.get(apiUrl);
+        swapTxData = response.data.tx.data;
+        break;
+      case Dapp.BALANCER:
+        swapTxData = await this.utils.getBalancerSwapTx(
+          this,
+          assetFrom,
+          assetTo,
+          amountIn,
+          slippage
+        );
+        break;
+      case 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
+        ]);
+        break;
+      case Dapp.TOROS:
+        swapTxData = await getEasySwapperTxData(
+          this,
+          assetFrom,
+          assetTo,
+          ethers.BigNumber.from(amountIn),
+          slippage
+        );
+        break;
+      default:
+        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,
+          deadline
+        ]);
     }
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][dapp],
@@ -795,6 +814,27 @@ export class Pool {
     return tx;
   }
 
+  /**
+   * Claim rewards from Aave platform
+   * @param {string[]} assets Assets invested in Aave
+   * @param {string} rewardAssets Reward token address
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async harvestAaveV3Rewards(
+    assets: string[],
+    rewardAsset: string,
+    options: any = null
+  ): Promise<any> {
+    const claimTxData = await getAaveV3ClaimTxData(this, assets, rewardAsset);
+    const tx = await this.poolLogic.execTransaction(
+      stakingAddress[this.network][Dapp.AAVEV3] as string,
+      claimTxData,
+      options
+    );
+    return tx;
+  }
+
   /**
    * Create UniswapV3 liquidity pool
    * @param {string} assetA First asset
@@ -821,7 +861,10 @@ export class Pool {
     feeAmount: FeeAmount,
     options: any = null
   ): Promise<any> {
-    if ((!minPrice || !maxPrice) && (!minTick || !maxTick))
+    if (
+      (minPrice === null || maxPrice === null) &&
+      (minTick === null || maxTick === null)
+    )
       throw new Error("Need to provide price or tick range");
 
     const iNonfungiblePositionManager = new ethers.utils.Interface(

package/src/services/aave/assets.ts

@@ -0,0 +1,26 @@
+import { Dapp, ethers, Pool } from "../..";
+
+import ILendingPool from "../../abi/ILendingPool.json";
+import ILendingPoolV3 from "../../abi/IAaveV3LendingPool.json";
+import { routerAddress } from "../../config";
+
+export async function getAaveAssetsForUnderlying(
+  pool: Pool,
+  dapp: Dapp,
+  assets: string[]
+): Promise<string[]> {
+  const iLendingPool = dapp === Dapp.AAVEV3 ? ILendingPoolV3 : ILendingPool;
+  const lendingPool = new ethers.Contract(
+    routerAddress[pool.network][dapp] as string,
+    iLendingPool.abi,
+    pool.signer
+  );
+
+  const reserveData = await Promise.all(
+    assets.map(e => lendingPool.getReserveData(e))
+  );
+
+  const aTokens = reserveData.map(e => e.aTokenAddress);
+  const debtTokens = reserveData.map(e => e.variableDebtTokenAddress);
+  return aTokens.concat(debtTokens);
+}

package/src/services/aave/incentives.ts

@@ -0,0 +1,23 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ethers } from "ethers";
+import { Dapp } from "../../types";
+import IAaveV3Incentives from "../../abi/IAaveV3Incentives.json";
+import { Pool } from "../..";
+import { getAaveAssetsForUnderlying } from "./assets";
+
+export async function getAaveV3ClaimTxData(
+  pool: Pool,
+  assets: string[],
+  rewardAsset: string
+): Promise<any> {
+  const iAaveIncentives = new ethers.utils.Interface(IAaveV3Incentives.abi);
+  const aaveAsset = await getAaveAssetsForUnderlying(pool, Dapp.AAVEV3, assets);
+
+  const claimTxData = iAaveIncentives.encodeFunctionData("claimRewards", [
+    aaveAsset,
+    ethers.constants.MaxUint256,
+    pool.address,
+    rewardAsset
+  ]);
+  return claimTxData;
+}

package/src/services/chainLink/price.ts

@@ -0,0 +1,26 @@
+import { Dapp, ethers, Pool } from "../..";
+
+import IAaveV3PoolAddressProvider from "../../abi/IAaveV3PoolAddressProvider.json";
+import IPriceOracle from "../../abi/IPriceOracle.json";
+import { aaveAddressProvider } from "../../config";
+
+export async function getChainlinkPriceInUsd(
+  pool: Pool,
+  asset: string
+): Promise<ethers.BigNumber> {
+  //Workaround as Chainlink doesn't have feed registry on Polygon/Optimism
+  //Use oracle from Aave which uses Chainlink
+  const lendingPoolAddressProvider = new ethers.Contract(
+    aaveAddressProvider[pool.network][Dapp.AAVEV3] as string,
+    IAaveV3PoolAddressProvider.abi,
+    pool.signer
+  );
+
+  const priceOracleAddress = await lendingPoolAddressProvider.getPriceOracle();
+  const priceOracle = new ethers.Contract(
+    priceOracleAddress,
+    IPriceOracle.abi,
+    pool.signer
+  );
+  return await priceOracle.getAssetPrice(asset);
+}

package/src/services/oneInch/protocols.ts

@@ -0,0 +1,18 @@
+import axios from "axios";
+
+const excludedProtocols = ["OPTIMISM_PMM6"]; //Clipper
+
+export async function getOneInchProtocols(chainId: number): Promise<string> {
+  try {
+    const response = await axios.get(
+      `https://api.1inch.io/v4.0/${chainId}/liquidity-sources`
+    );
+    const protocols = response.data.protocols.map((e: { id: string }) => e.id);
+    const filteredProtocols = protocols.filter(
+      (e: string) => !excludedProtocols.includes(e)
+    );
+    return `&protocols=${filteredProtocols.join(",")}`;
+  } catch {
+    return "";
+  }
+}

package/src/services/toros/easySwapper.ts

@@ -0,0 +1,120 @@
+import { ethers } from "ethers";
+import { Dapp, Pool } from "../..";
+
+import IDhedgeEasySwapper from "../../abi/IDhedgeEasySwapper.json";
+import { routerAddress } from "../../config";
+import { getChainlinkPriceInUsd } from "../chainLink/price";
+import { isPool, loadPool } from "./pool";
+
+export async function getPoolDepositAsset(
+  pool: Pool,
+  poolAddress: string,
+  investAsset: string
+): Promise<string | undefined> {
+  const torosPool = await loadPool(pool, poolAddress);
+  const composition = await torosPool.getComposition();
+  if (
+    composition.find(e => e.asset.toLowerCase() === investAsset.toLowerCase())
+      ?.isDeposit
+  )
+    return investAsset;
+  return composition.find(e => e.isDeposit)?.asset;
+}
+
+export async function getTorosPoolTokenPrice(
+  pool: Pool,
+  poolAddress: string
+): Promise<ethers.BigNumber> {
+  const torosPool = await loadPool(pool, poolAddress);
+  return await torosPool.poolLogic.tokenPrice();
+}
+
+export async function getEasySwapperDepositQuote(
+  pool: Pool,
+  torosAsset: string,
+  investAsset: string,
+  depositAsset: string,
+  amountIn: ethers.BigNumber
+): Promise<ethers.BigNumber> {
+  const easySwapper = new ethers.Contract(
+    routerAddress[pool.network][Dapp.TOROS] as string,
+    IDhedgeEasySwapper.abi,
+    pool.signer
+  );
+
+  return await easySwapper.depositQuote(
+    torosAsset,
+    investAsset,
+    amountIn,
+    depositAsset
+  );
+}
+
+export async function getEasySwapperWithdrawalQuote(
+  pool: Pool,
+  torosAsset: string,
+  investAsset: string,
+  amountIn: ethers.BigNumber
+): Promise<ethers.BigNumber> {
+  const [torosTokenPrice, assetPrice, assetDecimals] = await Promise.all([
+    getTorosPoolTokenPrice(pool, torosAsset),
+    getChainlinkPriceInUsd(pool, investAsset),
+    pool.utils.getDecimals(investAsset)
+  ]);
+
+  return amountIn
+    .mul(torosTokenPrice)
+    .div(assetPrice)
+    .div(1e10)
+    .div(10 ** (18 - assetDecimals));
+}
+
+export async function getEasySwapperTxData(
+  pool: Pool,
+  assetFrom: string,
+  assetTo: string,
+  amountIn: ethers.BigNumber,
+  slippage: number
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+): Promise<any> {
+  const isWithdrawal = await isPool(pool, assetFrom);
+  const [torosAsset, investAsset] = isWithdrawal
+    ? [assetFrom, assetTo]
+    : [assetTo, assetFrom];
+  const iDhedgeEasySwapper = new ethers.utils.Interface(IDhedgeEasySwapper.abi);
+  if (isWithdrawal) {
+    const minAmountOut = await getEasySwapperWithdrawalQuote(
+      pool,
+      torosAsset,
+      investAsset,
+      amountIn
+    );
+    return iDhedgeEasySwapper.encodeFunctionData("withdraw", [
+      torosAsset,
+      amountIn,
+      investAsset,
+      minAmountOut.mul(10000 - slippage * 100).div(10000)
+    ]);
+  } else {
+    const depositAsset = await getPoolDepositAsset(
+      pool,
+      torosAsset,
+      investAsset
+    );
+    if (!depositAsset) throw new Error("no deposit assets");
+    const minAmountOut = await getEasySwapperDepositQuote(
+      pool,
+      torosAsset,
+      investAsset,
+      depositAsset,
+      amountIn
+    );
+    return iDhedgeEasySwapper.encodeFunctionData("deposit", [
+      torosAsset,
+      investAsset,
+      amountIn,
+      depositAsset,
+      minAmountOut.mul(10000 - slippage * 100).div(10000)
+    ]);
+  }
+}

package/src/services/toros/pool.ts

@@ -0,0 +1,14 @@
+import { Dhedge, Pool } from "../..";
+
+export async function loadPool(pool: Pool, poolAddress: string): Promise<Pool> {
+  const dhedge = new Dhedge(pool.signer, pool.network);
+  return await dhedge.loadPool(poolAddress);
+}
+
+export async function isPool(
+  pool: Pool,
+  poolAddress: string
+): Promise<boolean> {
+  const dhedge = new Dhedge(pool.signer, pool.network);
+  return await dhedge.validatePool(poolAddress);
+}

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

@@ -1,6 +1,6 @@
 import { Dhedge } from "..";
 import { Dapp, Network } from "../types";
-import { TEST_POOL, USDC, WETH } from "./constants";
+import { TEST_POOL, USDC, WBTC } from "./constants";
 import { getTxOptions } from "./txOptions";
 
 import { wallet } from "./wallet";
@@ -33,14 +33,14 @@ describe("pool", () => {
   //     expect(result).not.toBe(null);
   //   });
 
-  it("trades 1 USDC into WETH on 1Inch", async () => {
+  it("trades 1 USDC into WBTC on 1Inch", async () => {
     let result;
     const pool = await dhedge.loadPool(TEST_POOL);
     try {
       result = await pool.trade(
         Dapp.ONEINCH,
         USDC,
-        WETH,
+        WBTC,
         "1000000",
         0.5,
         options

package/src/test/aave.test.ts

@@ -1,6 +1,6 @@
 import { Dhedge } from "..";
-import { Dapp, Network } from "../types";
-import { TEST_POOL, WETH } from "./constants";
+import { Network } from "../types";
+import { OP, TEST_POOL, USDC, WBTC, WETH } from "./constants";
 
 import { wallet } from "./wallet";
 
@@ -51,17 +51,17 @@ describe("pool", () => {
   //   expect(result).not.toBe(null);
   // });
 
-  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("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;
@@ -98,4 +98,31 @@ describe("pool", () => {
   //   }
   //   expect(result).not.toBe(null);
   // });
+
+  // it("gets Aave assets for underlying", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await getAaveAssetsForUnderlying(pool, Dapp.AAVEV3, [
+  //       USDC,
+  //       WETH
+  //     ]);
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  it("claims rewards from AaveV3", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.harvestAaveV3Rewards([USDC, WETH, WBTC], OP);
+      console.log(result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
 });

package/src/test/constants.ts

@@ -1,10 +1,10 @@
 //Polygon
-export const USDC = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
-export const WETH = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
-export const USDT = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
-export const DAI = "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063";
-export const TUSD = "0x2e1ad108ff1d8c782fcbbb89aad783ac49586756";
-export const WBTC = "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6";
+// export const USDC = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+// export const WETH = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
+// export const USDT = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
+// export const DAI = "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063";
+// export const TUSD = "0x2e1ad108ff1d8c782fcbbb89aad783ac49586756";
+// export const WBTC = "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6";
 export const SUSHI = "0x0b3f868e0be5597d5db7feb59e1cadbb0fdda50a";
 export const WMATIC = "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270";
 export const BAL = "0x9a71012B13CA4d3D0Cdc72A177DF3ef03b0E76A3";
@@ -16,10 +16,15 @@ export const STMATIC = "0x3A58a54C066FdC0f2D55FC9C89F0415C92eBf3C4";
 export const WMATIC_STMATIC_LP = "0xaF5E0B5425dE1F5a630A8cB5AA9D97B8141C908D";
 export const AARAKIS_WNATIC_STMATIC_GAUGE =
   "0x9928340f9E1aaAd7dF1D95E27bd9A5c715202a56";
+export const ETHBULL3X = "0x460b60565cb73845d56564384ab84bf84c13e47d";
+export const BTCBEAR2X = "0x3dbce2c8303609c17aa23b69ebe83c2f5c510ada";
 
 //Optimism
-// export const WETH = "0x4200000000000000000000000000000000000006";
-// export const USDC = "0x7F5c764cBc14f9669B88837ca1490cCa17c31607";
-// export const DAI = "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1";
+export const WETH = "0x4200000000000000000000000000000000000006";
+export const USDC = "0x7F5c764cBc14f9669B88837ca1490cCa17c31607";
+export const DAI = "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1";
+export const USDy = "0x1ec50880101022c11530a069690f5446d1464592";
+export const WBTC = "0x68f180fcCe6836688e9084f035309E29Bf0A2095";
+export const OP = "4200000000000000000000000000000000000042";
 
 export const TEST_POOL = "TEST_POOL";