@dhedge/v2-sdk 1.9.1 → 1.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhedge/v2-sdk",
-  "version": "1.9.1",
+  "version": "1.9.3",
   "license": "MIT",
   "description": "🛠 An SDK for building applications on top of dHEDGE V2",
   "main": "dist/index.js",
@@ -20,9 +20,9 @@
     "prepare": "tsdx build",
     "size": "size-limit",
     "analyze": "size-limit --why",
-    "fork:polygon": "hardhat node --fork $(grep POLYGON_URL .env | cut -d '=' -f2)",
-    "fork:optimism": "hardhat node --fork $(grep OPTIMISM_URL .env | cut -d '=' -f2)",
-    "fork:arbitrum": "hardhat node --fork $(grep ARBITRUM_URL .env | cut -d '=' -f2)"
+    "fork:polygon": "hardhat node --port 8542 --fork $(grep POLYGON_URL .env | cut -d '=' -f2)",
+    "fork:optimism": "hardhat node --port 8544 --fork $(grep OPTIMISM_URL .env | cut -d '=' -f2)",
+    "fork:arbitrum": "hardhat node --port 8540 --fork $(grep ARBITRUM_URL .env | cut -d '=' -f2)"
   },
   "husky": {
     "hooks": {

package/src/entities/pool.ts

@@ -1,6 +1,5 @@
 /* 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";
@@ -16,7 +15,6 @@ import IBalancerRewardsGauge from "../abi/IBalancerRewardsGauge.json";
 
 import {
   MaxUint128,
-  networkChainIdMap,
   nonfungiblePositionManagerAddress,
   routerAddress,
   stakingAddress,
@@ -42,7 +40,6 @@ import {
 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";
 import {
   getVelodromeAddLiquidityTxData,
@@ -61,7 +58,7 @@ import {
 } from "../services/futures";
 import { getFuturesCancelOrderTxData } from "../services/futures/trade";
 import { getZeroExTradeTxData } from "../services/zeroEx/zeroExTrade";
-import { ApiError } from "../errors";
+import { getOneInchSwapTxData } from "../services/oneInch";
 
 export class Pool {
   public readonly poolLogic: Contract;
@@ -299,24 +296,13 @@ export class Pool {
         );
         break;
       case Dapp.ONEINCH:
-        const chainId = networkChainIdMap[this.network];
-        const protocols = await getOneInchProtocols(chainId);
-        if (!process.env.ONEINCH_API_URL)
-          throw new Error("ONEINCH_API_URL not configured in .env file");
-        const apiUrl = `${
-          process.env.ONEINCH_API_URL
-        }/${chainId}/swap?fromTokenAddress=${assetFrom}&toTokenAddress=${assetTo}&amount=${amountIn.toString()}&fromAddress=${
-          this.address
-        }&destReceiver=${
-          this.address
-        }&slippage=${slippage.toString()}&disableEstimate=true${protocols}`;
-        try {
-          const response = await axios.get(apiUrl);
-          swapTxData = response.data.tx.data;
-        } catch (e) {
-          throw new ApiError("Swap api request of 1inch failed");
-        }
-
+        swapTxData = await getOneInchSwapTxData(
+          this,
+          assetFrom,
+          assetTo,
+          amountIn,
+          slippage
+        );
         break;
       case Dapp.BALANCER:
         swapTxData = await this.utils.getBalancerSwapTx(
@@ -1355,4 +1341,23 @@ export class Pool {
     const tx = await this.poolLogic.execTransaction(market, txData, options);
     return tx;
   }
+
+  /**
+   * mintManagerFee
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async mintManagerFee(options: any = null): Promise<any> {
+    const tx = await this.poolLogic.mintManagerFee(options);
+    return tx;
+  }
+
+  /**
+   * getAvailableManagerFee
+   * @returns {Promise<BigNumber>} fee
+   */
+  async getAvailableManagerFee(): Promise<BigNumber> {
+    const fee = await this.poolLogic.availableManagerFee();
+    return BigNumber.from(fee);
+  }
 }

package/src/services/oneInch/index.ts

@@ -0,0 +1,33 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import axios from "axios";
+import { ApiError, ethers } from "../..";
+import { networkChainIdMap } from "../../config";
+import { Pool } from "../../entities";
+
+const oneInchBaseUrl = "https://api.1inch.dev/swap/v5.2/";
+
+export async function getOneInchSwapTxData(
+  pool: Pool,
+  assetFrom: string,
+  assetTo: string,
+  amountIn: ethers.BigNumber | string,
+  slippage: number
+): Promise<string> {
+  if (!process.env.ONEINCH_API_KEY)
+    throw new Error("ONEINCH_API_KEY not configured in .env file");
+
+  const chainId = networkChainIdMap[pool.network];
+  const apiUrl = `${oneInchBaseUrl}${chainId}/swap?src=${assetFrom}&dst=${assetTo}&amount=${amountIn.toString()}&from=${
+    pool.address
+  }&slippage=${slippage.toString()}&disableEstimate=true`;
+  try {
+    const response = await axios.get(apiUrl, {
+      headers: {
+        Authorization: `Bearer ${process.env.ONEINCH_API_KEY}`
+      }
+    });
+    return response.data.tx.data;
+  } catch (e) {
+    throw new ApiError("Swap api request of 1inch failed");
+  }
+}

package/src/test/constants.ts

@@ -56,6 +56,7 @@ export const CONTRACT_ADDRESS = {
     USDC: "0x7F5c764cBc14f9669B88837ca1490cCa17c31607",
     SUSD: "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9",
     WETH: "0x4200000000000000000000000000000000000006",
+    WBTC: "0x68f180fcCe6836688e9084f035309E29Bf0A2095",
     KWENTA_ETH_PERP_V2: "0x2b3bb4c683bfc5239b029131eef3b1d214478d93"
   },
   [Network.ARBITRUM]: {

package/src/test/oneInch.test.ts

@@ -3,44 +3,52 @@ import { Dhedge, Pool } from "..";
 import { routerAddress } from "../config";
 import { Dapp, Network } from "../types";
 import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import { TestingRunParams, testingHelper } from "./utils/testingHelper";
 import { allowanceDelta, balanceDelta } from "./utils/token";
 
-import { wallet } from "./wallet";
+const testOneInch = ({ wallet, network }: TestingRunParams) => {
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const WETH = CONTRACT_ADDRESS[network].WETH;
 
-// const network = Network.OPTIMISM;
-// const network = Network.POLYGON;
-const network = Network.ARBITRUM;
-const USDC = CONTRACT_ADDRESS[network].USDC;
-const WETH = CONTRACT_ADDRESS[network].WETH;
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
 
-let dhedge: Dhedge;
-let pool: Pool;
-jest.setTimeout(100000);
+  describe(`pool on ${network}`, () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+    });
 
-describe("pool", () => {
-  beforeAll(async () => {
-    dhedge = new Dhedge(wallet, network);
-    pool = await dhedge.loadPool(TEST_POOL[network]);
-  });
+    it("approves unlimited USDC on 1Inch", async () => {
+      await pool.approve(Dapp.ONEINCH, USDC, MAX_AMOUNT);
+      const usdcAllowanceDelta = await allowanceDelta(
+        pool.address,
+        USDC,
+        routerAddress[network]["1inch"]!,
+        pool.signer
+      );
+      await expect(usdcAllowanceDelta.gt(0));
+    });
 
-  it("approves unlimited USDC on 1Inch", async () => {
-    await pool.approve(Dapp.ONEINCH, USDC, MAX_AMOUNT);
-    const usdcAllowanceDelta = await allowanceDelta(
-      pool.address,
-      USDC,
-      routerAddress[network]["1inch"]!,
-      pool.signer
-    );
-    await expect(usdcAllowanceDelta.gt(0));
+    it("trades 2 USDC into WETH on 1Inch", async () => {
+      await pool.trade(Dapp.ONEINCH, USDC, WETH, "2000000", 0.5);
+      const wethBalanceDelta = await balanceDelta(
+        pool.address,
+        WETH,
+        pool.signer
+      );
+      expect(wethBalanceDelta.gt(0));
+    });
   });
+};
 
-  it("trades 2 USDC into WETH on 1Inch", async () => {
-    await pool.trade(Dapp.ONEINCH, USDC, WETH, "2000000", 0.5);
-    const wethBalanceDelta = await balanceDelta(
-      pool.address,
-      WETH,
-      pool.signer
-    );
-    expect(wethBalanceDelta.gt(0));
-  });
+testingHelper({
+  network: Network.OPTIMISM,
+  testingRun: testOneInch
+});
+
+testingHelper({
+  network: Network.POLYGON,
+  testingRun: testOneInch
 });

package/src/test/pool.test.ts

@@ -1,60 +1,104 @@
+import { BigNumber } from "ethers";
 import { Dhedge, ethers, Pool } from "..";
 import { AssetEnabled, Network } from "../types";
 import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
+
+import {
+  beforeAfterReset,
+  testingHelper,
+  TestingRunParams
+} from "./utils/testingHelper";
 import { allowanceDelta, balanceDelta } from "./utils/token";
-import { wallet } from "./wallet";
 
-let dhedge: Dhedge;
-let pool: Pool;
+const testPool = ({ wallet, network, provider }: TestingRunParams) => {
+  let dhedge: Dhedge;
+  let pool: Pool;
 
-jest.setTimeout(100000);
+  jest.setTimeout(200000);
 
-const network = Network.POLYGON;
+  describe(`pool on ${network}`, () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+    });
+    beforeAfterReset({ beforeAll, afterAll, provider });
 
-describe("pool", () => {
-  beforeAll(async () => {
-    dhedge = new Dhedge(wallet, network);
-    pool = await dhedge.loadPool(TEST_POOL[network]);
-  });
+    it("checks fund composition", async () => {
+      const result = await pool.getComposition();
+      expect(result.length).toBeGreaterThan(0);
+    });
 
-  it("checks fund composition", async () => {
-    const result = await pool.getComposition();
-    expect(result.length).toBeGreaterThan(0);
-  });
+    it("approves USDC balance of User for Deposit", async () => {
+      await pool.approveDeposit(
+        CONTRACT_ADDRESS[network].USDC,
+        ethers.constants.MaxUint256
+      );
+      const UsdcAllowanceDelta = await allowanceDelta(
+        pool.signer.address,
+        CONTRACT_ADDRESS[network].USDC,
+        pool.address,
+        pool.signer
+      );
+      expect(UsdcAllowanceDelta.gt(0));
+    });
 
-  it("approves USDC balance of User for Deposit", async () => {
-    await pool.approveDeposit(
-      CONTRACT_ADDRESS[network].USDC,
-      ethers.constants.MaxUint256
-    );
-    const UsdcAllowanceDelta = await allowanceDelta(
-      pool.signer.address,
-      CONTRACT_ADDRESS[network].USDC,
-      pool.address,
-      pool.signer
-    );
-    expect(UsdcAllowanceDelta.gt(0));
-  });
+    it("deposits 1 USDC into Pool", async () => {
+      await pool.deposit(CONTRACT_ADDRESS[network].USDC, (1e6).toString());
+      const poolTokenDelta = await balanceDelta(
+        pool.signer.address,
+        pool.address,
+        pool.signer
+      );
+      expect(poolTokenDelta.gt(0));
+    });
 
-  it("deposits 1 USDC into Pool", async () => {
-    await pool.deposit(CONTRACT_ADDRESS[network].USDC, (1e6).toString());
-    const poolTokenDelta = await balanceDelta(
-      pool.signer.address,
-      pool.address,
-      pool.signer
-    );
-    expect(poolTokenDelta.gt(0));
-  });
+    it("adds WBTC to enabled assets", async () => {
+      const assetsBefore = await pool.getComposition();
 
-  it("adds WBTC to enabled assets", async () => {
-    const assetsBefore = await pool.getComposition();
-    const newAssets: AssetEnabled[] = [
-      { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
-      { asset: CONTRACT_ADDRESS[network].WETH, isDeposit: false },
-      { asset: CONTRACT_ADDRESS[network].WBTC, isDeposit: false }
-    ];
-    await pool.changeAssets(newAssets);
-    const assetsAfter = await pool.getComposition();
-    expect(assetsAfter.length).toBeGreaterThan(assetsBefore.length);
+      const newAssets: AssetEnabled[] = [
+        { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
+        { asset: CONTRACT_ADDRESS[network].WETH, isDeposit: false },
+        { asset: CONTRACT_ADDRESS[network].WBTC, isDeposit: false }
+      ];
+      await pool.changeAssets(newAssets);
+      const assetsAfter = await pool.getComposition();
+      if (assetsBefore.length < newAssets.length) {
+        expect(assetsAfter.length).toBeGreaterThan(assetsBefore.length);
+      } else {
+        expect(assetsAfter.length).toBeLessThanOrEqual(assetsBefore.length);
+      }
+    });
+
+    it("get available Manager Fee", async () => {
+      const result = await pool.getAvailableManagerFee();
+      expect(result).toBeInstanceOf(BigNumber);
+    });
+
+    it("mintManagerFee; should not revert", async () => {
+      const tx = await pool.mintManagerFee();
+      expect(tx).toHaveProperty("wait");
+    });
+
+    it("withdraw 0.1 pool token into Pool", async () => {
+      await provider.send("evm_increaseTime", [24 * 60 * 60]);
+      await provider.send("evm_mine", []);
+      await pool.withdraw((0.1 * 1e18).toString());
+      const poolTokenDelta = await balanceDelta(
+        pool.signer.address,
+        pool.address,
+        pool.signer
+      );
+      expect(poolTokenDelta.lt(0));
+    });
   });
+};
+
+testingHelper({
+  network: Network.POLYGON,
+  testingRun: testPool
 });
+
+// testingHelper({
+//   network: Network.OPTIMISM,
+//   testingRun: testPool
+// });

package/src/test/utils/testingHelper.ts

@@ -0,0 +1,42 @@
+import { ethers } from "ethers";
+import { Network } from "../../types";
+import { getWalletData } from "../wallet";
+
+export type TestingRunParams = {
+  network: Network;
+  wallet: ethers.Wallet;
+  provider: ethers.providers.JsonRpcProvider;
+};
+
+type TestHelperParams = {
+  testingRun: (testingRunParams: TestingRunParams) => void;
+} & { network: Network };
+
+export const testingHelper = ({
+  network,
+  testingRun
+}: TestHelperParams): void => {
+  const { wallet, provider } = getWalletData(network);
+  testingRun({ network, wallet, provider });
+};
+
+export const beforeAfterReset = ({
+  beforeAll,
+  afterAll,
+  provider
+}: {
+  beforeAll: jest.Lifecycle;
+  afterAll: jest.Lifecycle;
+  provider: ethers.providers.JsonRpcProvider;
+}): void => {
+  let snapshot = "";
+  beforeAll(async () => {
+    snapshot = (await provider.send("evm_snapshot", [])) as string;
+    await provider.send("evm_mine", []);
+  });
+
+  afterAll(async () => {
+    await provider.send("evm_revert", [snapshot]);
+    await provider.send("evm_mine", []);
+  });
+};

package/src/test/utils.test.ts

@@ -1,61 +1,82 @@
 //import { ethers } from "ethers";
-import { Dhedge } from "..";
+import { Dhedge, Pool } from "..";
 import { Network } from "../types";
+import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
+import {
+  TestingRunParams,
+  beforeAfterReset,
+  testingHelper
+} from "./utils/testingHelper";
 
-import { wallet } from "./wallet";
-
-const myPool = "0xe3528a438b94e64669def9b875c381c46ef713bf";
+// const myPool = "0xe3528a438b94e64669def9b875c381c46ef713bf";
 
 // const usdt = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
-const usdc = "0x2791bca1f2de4661ed88a30c99a7a9449aa84174";
-const weth = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
-const wbtc = "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6";
+
 // const lpUsdcWeth = "0x34965ba0ac2451A34a0471F04CCa3F990b8dea27";
 
-let dhedge: Dhedge;
+const testUtils = ({ wallet, network, provider }: TestingRunParams) => {
+  let dhedge: Dhedge;
+  let pool: Pool;
+  const usdc = CONTRACT_ADDRESS[network].USDC;
+  const weth = CONTRACT_ADDRESS[network].WETH;
+  const wbtc = CONTRACT_ADDRESS[network].WBTC;
+  // const usdt = CONTRACT_ADDRESS[network].USDT;
 
-jest.setTimeout(100000);
+  jest.setTimeout(100000);
 
-describe("utils", () => {
-  beforeAll(() => {
-    dhedge = new Dhedge(wallet, Network.POLYGON);
-  });
+  describe(`utils on ${network}`, () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+    });
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    // it("gets lp ratio of the USDT/USDC pool", async () => {
+    //   const result = await dhedge.utils.getLpReserves(Dapp.SUSHISWAP, usdc, usdt);
+    //   expect(Number(result.assetA) / Number(result.assetB)).toBeGreaterThan(0.9);
+    // });
+
+    // it("gets pool id of sushi LP pool for USDC/WETH", async () => {
+    //   const result = await dhedge.utils.getLpPoolId(Dapp.SUSHISWAP, lpUsdcWeth);
+    //   expect(result).toBe(1);
+    // });
 
-  // it("gets lp ratio of the USDT/USDC pool", async () => {
-  //   const result = await dhedge.utils.getLpReserves(Dapp.SUSHISWAP, usdc, usdt);
-  //   expect(Number(result.assetA) / Number(result.assetB)).toBeGreaterThan(0.9);
-  // });
-
-  // it("gets pool id of sushi LP pool for USDC/WETH", async () => {
-  //   const result = await dhedge.utils.getLpPoolId(Dapp.SUSHISWAP, lpUsdcWeth);
-  //   expect(result).toBe(1);
-  // });
-
-  // it("gets USDC balance of a pool", async () => {
-  //   const result = await dhedge.utils.getBalance(usdc, myPool);
-  //   expect(result.gt(0));
-  // });
-  // it("gets minumum amount out of WETH for 1 USDC", async () => {
-  //   const result = await dhedge.utils.getMinAmountOut(
-  //     Dapp.SUSHISWAP,
-  //     usdc,
-  //     weth,
-  //     "1000000",
-  //     0.5
-  //   );
-  //   expect(result.gt(0));
-  // });
-
-  it("gets Balancer pool tx data", async () => {
-    const pool = await dhedge.loadPool(myPool);
-    const assets = [wbtc, usdc, weth];
-    const amounts = ["0", "1000000", "0"];
-    const result = await dhedge.utils.getBalancerJoinPoolTx(
-      pool,
-      "0x03cd191f589d12b0582a99808cf19851e468e6b500010000000000000000000a",
-      assets,
-      amounts
-    );
-    expect(result);
+    // it("gets USDC balance of a pool", async () => {
+    //   const result = await dhedge.utils.getBalance(usdc, myPool);
+    //   expect(result.gt(0));
+    // });
+    // it("gets minumum amount out of WETH for 1 USDC", async () => {
+    //   const result = await dhedge.utils.getMinAmountOut(
+    //     Dapp.SUSHISWAP,
+    //     usdc,
+    //     weth,
+    //     "1000000",
+    //     0.5
+    //   );
+    //   expect(result.gt(0));
+    // });
+
+    it("gets Balancer pool tx data", async () => {
+      // pool = await dhedge.loadPool(pool);
+      const assets = [wbtc, usdc, weth];
+      const amounts = ["0", "1000000", "0"];
+      const result = await dhedge.utils.getBalancerJoinPoolTx(
+        pool,
+        "0x03cd191f589d12b0582a99808cf19851e468e6b500010000000000000000000a",
+        assets,
+        amounts
+      );
+      expect(result);
+    });
   });
+};
+
+testingHelper({
+  network: Network.POLYGON,
+  testingRun: testUtils
+});
+
+testingHelper({
+  network: Network.OPTIMISM,
+  testingRun: testUtils
 });

package/src/test/wallet.ts

@@ -1,5 +1,5 @@
 import { ethers } from "ethers";
-
+import { Network } from "../types";
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 require("dotenv").config();
 
@@ -25,3 +25,24 @@ export const wallet = new ethers.Wallet(
   process.env.PRIVATE_KEY as string,
   provider
 );
+
+export const networkPortMap = {
+  [Network.POLYGON]: 8542,
+  [Network.OPTIMISM]: 8544,
+  [Network.ARBITRUM]: 8540
+};
+
+export const getWalletData = (
+  network: Network
+): {
+  wallet: ethers.Wallet;
+  provider: ethers.providers.JsonRpcProvider;
+} => {
+  const provider = new ethers.providers.JsonRpcProvider(
+    `http://127.0.0.1:${networkPortMap[network]}/`
+  );
+  return {
+    wallet: new ethers.Wallet(process.env.PRIVATE_KEY as string, provider),
+    provider
+  };
+};