@dhedge/v2-sdk 1.4.1 → 1.5.0

package/src/entities/dhedge.ts

@@ -88,7 +88,6 @@ export class Dhedge {
    * @returns {Pool} Loaded Pool
    */
   public async loadPool(address: string): Promise<Pool> {
-    this.validatePool(address);
     const poolLogic = new Contract(address, PoolLogic.abi, this.signer);
     const managerLogicAddress = await poolLogic.poolManagerLogic();
     const managerLogic = new Contract(
@@ -112,8 +111,7 @@ export class Dhedge {
    * @param {string} address Pool address
    * @returns {boolean} Is valid pool address
    */
-  private async validatePool(address: string): Promise<void> {
-    const isPool = await this.factory.isPool(address);
-    if (!isPool) throw new Error("Given address not a pool");
+  validatePool(address: string): Promise<boolean> {
+    return this.factory.isPool(address);
   }
 }

package/src/entities/pool.ts

@@ -40,6 +40,8 @@ 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";
 
 export class Pool {
   public readonly poolLogic: Contract;
@@ -265,52 +267,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],
@@ -821,7 +839,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(
@@ -872,8 +893,8 @@ export class Pool {
       dappAddress = nonfungiblePositionManagerAddress[this.network];
       const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
       const liquidity = (await getUniswapV3Liquidity(tokenId, this))
-        .mul(amount)
-        .div(100);
+        .mul(Math.round(amount * 1e4))
+        .div(1e6);
       const decreaseLiquidityTxData = abi.encodeFunctionData(
         Transaction.DECREASE_LIQUIDITY,
         [[tokenId, liquidity, 0, 0, deadline]]
@@ -895,8 +916,8 @@ export class Pool {
       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);
+        .mul(Math.round(amount * 1e4))
+        .div(1e6);
       txData = abi.encodeFunctionData(Transaction.REMOVE_LIQUIDITY_UNSTAKE, [
         tokenId,
         liquidity,

package/src/services/chainLink/price.ts

@@ -0,0 +1,25 @@
+import { ethers, Pool } from "../..";
+
+import IAaveV3PoolAddressProvider from "../../abi/IAaveV3PoolAddressProvider.json";
+import IPriceOracle from "../../abi/IPriceOracle.json";
+
+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(
+    "0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb",
+    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,110 @@
+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
+): Promise<string | undefined> {
+  const torosPool = await loadPool(pool, poolAddress);
+  const composition = await torosPool.getComposition();
+  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);
+    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

@@ -0,0 +1,54 @@
+import { Dhedge } from "..";
+import { Dapp, Network } from "../types";
+import { TEST_POOL, USDC, WBTC } 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 WBTC on 1Inch", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.trade(
+        Dapp.ONEINCH,
+        USDC,
+        WBTC,
+        "1000000",
+        0.5,
+        options
+      );
+      console.log(result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+});

package/src/test/arrakis.test.ts

@@ -14,7 +14,7 @@ jest.setTimeout(100000);
 describe("pool", () => {
   beforeAll(async () => {
     dhedge = new Dhedge(wallet, Network.POLYGON);
-    options = await getTxOptions();
+    options = await getTxOptions(Network.POLYGON);
   });
 
   // it("approves unlimited WETH on  Arrakis", async () => {
@@ -69,7 +69,7 @@ describe("pool", () => {
     const result = await pool.decreaseLiquidity(
       Dapp.ARRAKIS,
       ARRAKIS_USDC_WETH_GAUGE,
-      100,
+      50.6576575755,
       options
     );
     console.log("result", result);

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";
@@ -14,10 +14,16 @@ export const ARRAKIS_USDC_WETH_GAUGE =
   "0x33d1ad9Cd88A509397CD924C2d7613C285602C20";
 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 TEST_POOL = "TEST_POOL_ADDRESS";
+export const TEST_POOL = "TEST_POOL";

package/src/test/toros.test.ts

@@ -0,0 +1,117 @@
+import { Dhedge, ethers } from "..";
+import {
+  getEasySwapperDepositQuote,
+  getEasySwapperWithdrawalQuote,
+  getPoolDepositAsset
+} from "../services/toros/easySwapper";
+import { Dapp, Network } from "../types";
+import { BTCBEAR2X, ETHBULL3X, TEST_POOL, USDC, WBTC } 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.POLYGON);
+    options = await getTxOptions(Network.POLYGON);
+  });
+
+  it("gets Deposit Quote for ETHBULL3X invest with USDC", async () => {
+    let result;
+    const pool = await dhedge.loadPool(ETHBULL3X);
+    try {
+      const depositAsset = await getPoolDepositAsset(pool, ETHBULL3X);
+      if (!depositAsset) throw new Error("no deposit assets");
+
+      result = await getEasySwapperDepositQuote(
+        pool,
+        pool.address,
+        USDC,
+        depositAsset,
+        ethers.BigNumber.from("100000000")
+      );
+      console.log("deposit quote", result.toString());
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+
+  it("gets withdrawal Quote for BTCBEAR2X sell for WBTC", async () => {
+    let result;
+    const pool = await dhedge.loadPool(BTCBEAR2X);
+    try {
+      result = await getEasySwapperWithdrawalQuote(
+        pool,
+        pool.address,
+        WBTC,
+        ethers.BigNumber.from("9751590099507644982205")
+      );
+      console.log("withdrawal quote", result.toString());
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+
+  it("approves unlimited ETHBULL3X on Easyswapper", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.approve(
+        Dapp.TOROS,
+        ETHBULL3X,
+        ethers.constants.MaxInt256,
+        options
+      );
+      console.log(result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+
+  // it("buys ETHBULL3X for 1 USDC", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.trade(
+  //       Dapp.TOROS,
+  //       USDC,
+  //       ETHBULL3X,
+  //       "1000000",
+  //       0.5,
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  it("sells ETHBULL3X balance for USDC", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const balance = await pool.utils.getBalance(ETHBULL3X, pool.address);
+    try {
+      result = await pool.trade(
+        Dapp.TOROS,
+        ETHBULL3X,
+        USDC,
+        balance,
+        3,
+        options
+      );
+      console.log(result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+});

package/src/test/txOptions.ts

@@ -1,15 +1,21 @@
 import axios from "axios";
 import BigNumber from "bignumber.js";
+import { Network } from "../types";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const getTxOptions = async (): Promise<any> => {
-  const result = await axios("https://gasstation-mainnet.matic.network/v2");
-
-  return {
-    gasLimit: "3000000",
-    maxPriorityFeePerGas: new BigNumber(result.data.fast.maxPriorityFee)
-      .shiftedBy(9)
-      .toFixed(0),
-    maxFeePerGas: new BigNumber(result.data.fast.maxFee).shiftedBy(9).toFixed(0)
-  };
+export const getTxOptions = async (network: Network): Promise<any> => {
+  if (network === Network.POLYGON) {
+    const result = await axios("https://gasstation-mainnet.matic.network/v2");
+    return {
+      gasLimit: "3000000",
+      maxPriorityFeePerGas: new BigNumber(result.data.fast.maxPriorityFee)
+        .shiftedBy(9)
+        .toFixed(0),
+      maxFeePerGas: new BigNumber(result.data.fast.maxFee)
+        .shiftedBy(9)
+        .toFixed(0),
+    };
+  } else {
+    return { gasLimit: "3000000" };
+  }
 };

package/src/types.ts

@@ -14,7 +14,8 @@ export enum Dapp {
   UNISWAPV3 = "uniswapV3",
   SYNTHETIX = "synthetix",
   AAVEV3 = "aavev3",
-  ARRAKIS = "arrakis"
+  ARRAKIS = "arrakis",
+  TOROS = "toros"
 }
 
 export enum Transaction {