@dhedge/v2-sdk 1.7.2 → 1.8.1

package/src/test/pool.test.ts

@@ -1,103 +1,60 @@
-import { Dhedge } from "..";
-import { Network } from "../types";
-import { TEST_POOL } from "./constants";
-
+import { Dhedge, ethers, Pool } from "..";
+import { AssetEnabled, Network } from "../types";
+import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
+import { allowanceDelta, balanceDelta } from "./utils/token";
 import { wallet } from "./wallet";
 
 let dhedge: Dhedge;
+let pool: Pool;
 
 jest.setTimeout(100000);
 
-// const options = {
-//   gasLimit: 5000000,
-//   gasPrice: ethers.utils.parseUnits("35", "gwei")
-// };
+const network = Network.POLYGON;
 
 describe("pool", () => {
-  beforeAll(() => {
-    dhedge = new Dhedge(wallet, Network.OPTIMISM);
+  beforeAll(async () => {
+    dhedge = new Dhedge(wallet, network);
+    pool = await dhedge.loadPool(TEST_POOL[network]);
   });
 
   it("checks fund composition", async () => {
-    const pool = await dhedge.loadPool(TEST_POOL);
     const result = await pool.getComposition();
-    console.log(result);
     expect(result.length).toBeGreaterThan(0);
   });
 
-  // it("withdraws 1.00002975 fund tokens", async () => {
-  //   const pool = await dhedge.loadPool(myPool);
-  //   const result = await pool.withdraw("1000029750000000000");
-  //   expect(result).toBeGreaterThan(0);
-  // });
-
-  // it("approve USDC balance of User for Deposit", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.approveDeposit(usdt, ethers.constants.MaxUint256);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("deposit 0.1 USDC into Pool", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.deposit(usdc, depositAmountUsdc);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("adds LpUSDCWETH/SUSHI/WMATIC to enabled assets", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   const newAssets: AssetEnabled[] = [
-  //     { asset: usdc, isDeposit: true },
-  //     { asset: weth, isDeposit: true },
-  //     { asset: usdt, isDeposit: true },
-  //     { asset: amusdc, isDeposit: false },
-  //     { asset: lpUsdcUsdt, isDeposit: false }
-  //   ];
-  //   try {
-  //     result = await pool.changeAssets(newAssets);
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
+  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("removes all assets except USDC and USDT", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   const newAssets: AssetEnabled[] = [
-  //     { asset: usdc, isDeposit: false },
-  //     { asset: weth, isDeposit: true }
-  //   ];
-  //   try {
-  //     result = await pool.changeAssets(newAssets);
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
+  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("sets a trader account", async () => {
-  //   let result;
-  //   const newTrader = "0xC52D9a9D9b05a01887871216fF02bA4235e8503d";
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.setTrader(newTrader);
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
+  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);
+  });
 });

package/src/test/toros.test.ts

@@ -1,117 +1,69 @@
-import { Dhedge, ethers } from "..";
-import {
-  getEasySwapperDepositQuote,
-  getEasySwapperWithdrawalQuote,
-  getPoolDepositAsset
-} from "../services/toros/easySwapper";
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Dhedge, Pool } from "..";
+import { routerAddress } from "../config";
 import { Dapp, Network } from "../types";
-import { BTCBEAR2X, ETHBULL3X, TEST_POOL, USDC, WBTC } from "./constants";
-import { getTxOptions } from "./txOptions";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import { allowanceDelta, balanceDelta } from "./utils/token";
 
 import { wallet } from "./wallet";
 
-let dhedge: Dhedge;
-let options: any;
+const ETHy = "0xb2cfb909e8657c0ec44d3dd898c1053b87804755";
+const network = Network.OPTIMISM;
+const SUSD = CONTRACT_ADDRESS[network].SUSD;
 
+let dhedge: Dhedge;
+let pool: Pool;
 jest.setTimeout(100000);
 
 describe("pool", () => {
   beforeAll(async () => {
-    dhedge = new Dhedge(wallet, Network.POLYGON);
-    options = await getTxOptions(Network.POLYGON);
+    dhedge = new Dhedge(wallet, network);
+    pool = await dhedge.loadPool(TEST_POOL[network]);
   });
 
-  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, USDC);
-      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("approves unlimited ETHy on Toros (Easyswapper)", async () => {
+    await pool.approve(Dapp.TOROS, ETHy, MAX_AMOUNT);
+    const ETHyAllowanceDelta = await allowanceDelta(
+      pool.address,
+      ETHy,
+      routerAddress[network].toros!,
+      pool.signer
+    );
+    expect(ETHyAllowanceDelta.gt(0));
   });
 
-  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("sell ETHy to SUSD on Toros", async () => {
+    const ETHyBalance = await pool.utils.getBalance(ETHy, pool.address);
+    await pool.trade(Dapp.TOROS, ETHy, SUSD, ETHyBalance, 3);
+    const ETHyBalanceDelta = await balanceDelta(
+      pool.address,
+      SUSD,
+      pool.signer
+    );
+    expect(ETHyBalanceDelta.lt(0));
   });
 
-  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("approves unlimited sUSD on Toros (Easyswapper)", async () => {
+    await pool.approve(Dapp.TOROS, SUSD, MAX_AMOUNT, { gasLimit: "3000000" });
+    const sUSDAllowanceDelta = await allowanceDelta(
+      pool.address,
+      SUSD,
+      routerAddress[network].toros!,
+      pool.signer
+    );
+    expect(sUSDAllowanceDelta.gt(0));
   });
 
-  // 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);
+  it("buys ETHy for 3 sUSD", async () => {
+    await pool.trade(Dapp.TOROS, SUSD, ETHy, (3 * 10e18).toString(), 3, {
+      gasLimit: "3000000"
+    });
+    const ETHyBalanceDelta = await balanceDelta(
+      pool.address,
+      ETHy,
+      pool.signer
+    );
+    expect(ETHyBalanceDelta.gt(0));
   });
 });

package/src/test/uniswap.test.ts

@@ -1,35 +1,70 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Dhedge } from "..";
+import { FeeAmount } from "@uniswap/v3-sdk";
+import { Dhedge, ethers, Pool } from "..";
+import { routerAddress } from "../config";
 import { Dapp, Network } from "../types";
-import { TEST_POOL } from "./constants";
-import { getTxOptions } from "./txOptions";
+import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
+import { allowanceDelta, balanceDelta } from "./utils/token";
 
 import { wallet } from "./wallet";
 
 let dhedge: Dhedge;
-let options: any;
+let pool: Pool;
 jest.setTimeout(100000);
 
+const network = Network.POLYGON;
+
 describe("pool", () => {
   beforeAll(async () => {
-    dhedge = new Dhedge(wallet, Network.POLYGON);
-    options = await getTxOptions(Network.POLYGON);
-    //options = { gasLimit: "3000000" };
+    dhedge = new Dhedge(wallet, network);
+    pool = await dhedge.loadPool(TEST_POOL[network]);
+  });
+
+  it("approves unlimited USDC on for trading on UniswapV3", async () => {
+    await pool.approve(
+      Dapp.UNISWAPV3,
+      CONTRACT_ADDRESS[network].USDC,
+      ethers.constants.MaxUint256
+    );
+    const UsdcAllowanceDelta = await allowanceDelta(
+      pool.address,
+      CONTRACT_ADDRESS[network].USDC,
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      routerAddress[network].uniswapV3!,
+      pool.signer
+    );
+    expect(UsdcAllowanceDelta.gte(0));
+  });
+
+  it("should swap 5 USDC into WETH on UniswapV3", async () => {
+    await pool.tradeUniswapV3(
+      CONTRACT_ADDRESS[network].USDC,
+      CONTRACT_ADDRESS[network].WETH,
+      "5000000",
+      FeeAmount.LOW,
+      0.5
+    );
+
+    const wethAllowanceDelta = await balanceDelta(
+      pool.address,
+      CONTRACT_ADDRESS[network].WETH,
+      pool.signer
+    );
+    expect(wethAllowanceDelta.gt(0));
   });
 
   // it("approves unlimited WETH on for UniswapV3 LP", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(TEST_POOL);
-  //   try {
-  //     result = await pool.approveUniswapV3Liquidity(
-  //       USDC,
-  //       ethers.constants.MaxInt256,
-  //       options
-  //     );
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
+  //   await pool.approveUniswapV3Liquidity(
+  //     CONTRACT_ADDRESS[network].USDC,
+  //     ethers.constants.MaxInt256
+  //   );
+  //   const UsdcAllowanceDelta = await allowanceDelta(
+  //     pool.address,
+  //     CONTRACT_ADDRESS[network].USDC,
+  //     pool.address,
+  //     pool.signer
+  //   );
+
   //   expect(result).not.toBe(null);
   // });
 
@@ -59,17 +94,17 @@ describe("pool", () => {
   //   expect(result).not.toBe(null);
   // });
 
-  it("should remove liquidity from an existing pool ", async () => {
-    const pool = await dhedge.loadPool(TEST_POOL);
-    const result = await pool.decreaseLiquidity(
-      Dapp.UNISWAPV3,
-      "110507",
-      100,
-      options
-    );
-    console.log("result", result);
-    expect(result).not.toBe(null);
-  });
+  // it("should remove liquidity from an existing pool ", async () => {
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   const result = await pool.decreaseLiquidity(
+  //     Dapp.UNISWAPV3,
+  //     "110507",
+  //     100,
+  //     options
+  //   );
+  //   console.log("result", result);
+  //   expect(result).not.toBe(null);
+  // });
 
   // it("should increase liquidity in an existing pool WETH/WBTC pool", async () => {
   //   const pool = await dhedge.loadPool(TEST_POOL);

package/src/test/utils/token.ts

@@ -0,0 +1,31 @@
+import { BigNumber, Wallet, Contract } from "ethers";
+import IERC20 from "../../abi/IERC20.json";
+
+export const balanceDelta = async (
+  owner: string,
+  asset: string,
+  signer: Wallet
+): Promise<BigNumber> => {
+  const block = await signer.provider.getBlockNumber();
+  const iERC20 = new Contract(asset, IERC20.abi, signer);
+  const [balanceBefore, balanceAfter] = await Promise.all(
+    [block - 1, block].map(e => iERC20.balanceOf(owner, { blockTag: e }))
+  );
+  return balanceAfter.sub(balanceBefore);
+};
+
+export const allowanceDelta = async (
+  owner: string,
+  asset: string,
+  spender: string,
+  signer: Wallet
+): Promise<BigNumber> => {
+  const block = await signer.provider.getBlockNumber();
+  const iERC20 = new Contract(asset, IERC20.abi, signer);
+  const [allowanceBefore, allowanceAfter] = await Promise.all(
+    [block - 1, block].map(e =>
+      iERC20.allowance(owner, spender, { blockTag: e })
+    )
+  );
+  return allowanceAfter.sub(allowanceBefore);
+};