@dhedge/v2-sdk 2.1.8 → 2.2.0

package/src/test/toros.test.ts

@@ -1,23 +1,25 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
 import BigNumber from "bignumber.js";
-import { Dhedge, Pool } from "..";
-import { routerAddress } from "../config";
+import { Dhedge, ethers, Pool } from "..";
 
 import { Dapp, Network } from "../types";
-import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import { CONTRACT_ADDRESS, MAX_AMOUNT } from "./constants";
 import {
+  fixOracleAggregatorStaleness,
+  runWithImpersonateAccount,
   setChainlinkTimeout,
   setUSDCAmount,
   testingHelper,
   TestingRunParams
 } from "./utils/testingHelper";
-
-import { allowanceDelta, balanceDelta } from "./utils/token";
+import { balanceDelta } from "./utils/token";
+import { routerAddress } from "../config";
 
 const testToros = ({ wallet, network, provider }: TestingRunParams) => {
   const USDC = CONTRACT_ADDRESS[network].USDC;
   const TOROS = CONTRACT_ADDRESS[network].TOROS;
+  const TEST_POOL_ADDRESS = "0x2d4cddd2c4fa854536593bcf61d0da3b63ed80cb";
 
   let dhedge: Dhedge;
   let pool: Pool;
@@ -25,17 +27,37 @@ const testToros = ({ wallet, network, provider }: TestingRunParams) => {
 
   describe(`pool on ${network}`, () => {
     beforeAll(async () => {
-      dhedge = new Dhedge(wallet, network);
-      pool = await dhedge.loadPool(TEST_POOL[network]);
-      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
-      // top up gas
       await provider.send("hardhat_setBalance", [
         wallet.address,
         "0x10000000000000000"
       ]);
-      await provider.send("evm_mine", []);
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL_ADDRESS);
+
+      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
+      await fixOracleAggregatorStaleness({ pool, provider });
+
+      // Impersonate pool manager to set trader and add Toros token as asset
+      await runWithImpersonateAccount(
+        { provider, account: await pool.managerLogic.manager() },
+        async ({ signer }) => {
+          await pool.managerLogic.connect(signer).setTrader(wallet.address);
+          const newAssets = [
+            [USDC, true],
+            [TOROS, false]
+          ];
+          await pool.managerLogic.connect(signer).changeAssets(newAssets, []);
+        }
+      );
+
+      // Fix the Toros vault's oracle aggregators (has different assets with Pyth oracles)
+      if (TOROS) {
+        const torosPool = await dhedge.loadPool(TOROS);
+        await fixOracleAggregatorStaleness({ pool: torosPool, provider });
+      }
+
       // top up USDC
-      const amount = new BigNumber(100).times(1e6).toFixed(0);
+      const amount = new BigNumber(1000).times(1e6).toFixed(0);
       await setUSDCAmount({
         amount,
         userAddress: pool.address,
@@ -46,13 +68,12 @@ const testToros = ({ wallet, network, provider }: TestingRunParams) => {
 
     it("approves unlimited USDC on Toros", async () => {
       await pool.approve(Dapp.TOROS, USDC, MAX_AMOUNT);
-      const usdcAllowanceDelta = await allowanceDelta(
-        pool.address,
+      const usdcAllowance = await new ethers.Contract(
         USDC,
-        routerAddress[network].toros!,
+        ["function allowance(address,address) view returns (uint256)"],
         pool.signer
-      );
-      await expect(usdcAllowanceDelta.gt(0));
+      ).allowance(pool.address, routerAddress[network].toros!);
+      expect(usdcAllowance.gt(0)).toBe(true);
     });
 
     it("trades USDC balance into Toros Token", async () => {
@@ -63,7 +84,37 @@ const testToros = ({ wallet, network, provider }: TestingRunParams) => {
         TOROS,
         pool.signer
       );
-      expect(torosBalanceDelta.gt(0));
+      expect(torosBalanceDelta.gt(0)).toBe(true);
+    });
+
+    it("get Tx data for init and complete withdrawal", async () => {
+      // await provider.send("evm_increaseTime", [86400]);
+      // await provider.send("evm_mine", []);
+      const torosBalance = await pool.utils.getBalance(TOROS, pool.address);
+      await pool.approve(Dapp.TOROS, TOROS, MAX_AMOUNT);
+      const tradeResult = await pool.trade(
+        Dapp.TOROS,
+        TOROS,
+        USDC,
+        torosBalance,
+        1.5,
+        null,
+        {
+          estimateGas: false,
+          onlyGetTxData: true
+        }
+      );
+      expect(tradeResult.minAmountOut).toBeDefined();
+      const completeWithdrawResult = await pool.completeTorosWithdrawal(
+        USDC,
+        5,
+        null,
+        {
+          estimateGas: false,
+          onlyGetTxData: true
+        }
+      );
+      expect(completeWithdrawResult.txData).toBeDefined();
     });
 
     it("init Toros Token for withdrawal", async () => {
@@ -77,23 +128,26 @@ const testToros = ({ wallet, network, provider }: TestingRunParams) => {
         TOROS,
         pool.signer
       );
-      expect(torosBalanceDelta.lt(0));
+      expect(torosBalanceDelta.lt(0)).toBe(true);
     });
 
     it("complete withdrawal from Toros asset", async () => {
+      // Advance chain time past the Toros withdrawal cooldown
+      await provider.send("evm_increaseTime", [600]);
+      await provider.send("evm_mine", []);
       await pool.completeTorosWithdrawal(USDC, 1.5);
       const usdcBalanceDelta = await balanceDelta(
         pool.address,
         USDC,
         pool.signer
       );
-      expect(usdcBalanceDelta.gt(0));
+      expect(usdcBalanceDelta.gt(0)).toBe(true);
     });
   });
 };
 
 testingHelper({
-  network: Network.OPTIMISM,
+  network: Network.ARBITRUM,
   testingRun: testToros,
   onFork: true
 });

package/src/test/torosLimitOrder.test.ts

@@ -1,79 +1,125 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
-// import { ethers } from "ethers";
+import BigNumber from "bignumber.js";
+import { ethers } from "ethers";
 import { Dhedge, Pool } from "..";
-// import { limitOrderAddress } from "../config";
+import { limitOrderAddress, routerAddress } from "../config";
+
+import { Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  fixOracleAggregatorStaleness,
+  runWithImpersonateAccount,
+  setChainlinkTimeout,
+  setUSDCAmount,
+  testingHelper,
+  TestingRunParams
+} from "./utils/testingHelper";
+
+const TOROS_BTCBEAR2X = "0x3e63f81b3aa4e821392fccdabdd7d0c960c0235e";
+const BTC_PRICING_ASSET = "0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f"; // WBTC
+
+const testTorosLimitOrder = ({
+  wallet,
+  network,
+  provider
+}: TestingRunParams) => {
+  const ORDER_AMOUNT = ethers.utils.parseEther("0.001");
+  const STOP_LOSS = ethers.utils.parseEther("50000");
+  const TAKE_PROFIT = ethers.utils.parseEther("200000");
 
-import { Network } from "../types";
-// import { MAX_AMOUNT } from "./constants";
-import { testingHelper, TestingRunParams } from "./utils/testingHelper";
-
-// import { allowanceDelta } from "./utils/token";
-
-// cspell:ignore goldbull
-const TOROS_GOLDBULL2X = "0xc8e7e840ca82804c14061a27aaca1b97a5a592ab";
-// const GOLD_PRICING_ASSET = "0x7624cccCc59361D583F28BEC40D37e7771d2ef5D";
-
-const testTorosLimitOrder = ({ wallet, network }: TestingRunParams) => {
-  // const ORDER_AMOUNT = ethers.utils.parseEther("0.001");
-  // const STOP_LOSS = ethers.utils.parseEther("3000");
-  // const TAKE_PROFIT = ethers.utils.parseEther("6000");
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   let dhedge: Dhedge;
   let pool: Pool;
   jest.setTimeout(100000);
 
   describe(`toros limit order on ${network}`, () => {
     beforeAll(async () => {
+      // Top up gas
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
+      await provider.send("evm_mine", []);
+
       dhedge = new Dhedge(wallet, network);
-      pool = await dhedge.loadPool(
-        "0xdd3d575fae102a12aaa086d97c7a8814eff42ebc" // MCP test pool (with GOLDBULL2X)
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+
+      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
+      await fixOracleAggregatorStaleness({ pool, provider });
+
+      // Impersonate pool manager to set trader and enable BTCBEAR2X asset
+      await runWithImpersonateAccount(
+        { provider, account: await pool.managerLogic.manager() },
+        async ({ signer }) => {
+          await pool.managerLogic.connect(signer).setTrader(wallet.address);
+          const USDC = CONTRACT_ADDRESS[network].USDC;
+          const easySwapperV2 = routerAddress[network][Dapp.TOROS]!;
+          await pool.managerLogic.connect(signer).changeAssets(
+            [
+              [TOROS_BTCBEAR2X, false],
+              [USDC, true],
+              [easySwapperV2, false]
+            ],
+            []
+          );
+        }
       );
+
+      // Fund pool with USDC and trade into BTCBEAR2X
+      const USDC = CONTRACT_ADDRESS[network].USDC;
+      const usdcAmount = new BigNumber(100).times(1e6).toFixed(0);
+      await setUSDCAmount({
+        amount: usdcAmount,
+        userAddress: pool.address,
+        network,
+        provider
+      });
+      await pool.approve(Dapp.TOROS, USDC, MAX_AMOUNT);
+      await pool.trade(Dapp.TOROS, USDC, TOROS_BTCBEAR2X, usdcAmount, 1.5);
     });
 
     it("approves Toros vault token for LimitOrderManager", async () => {
-      const tx = await pool.approveTorosLimitOrder(
-        TOROS_GOLDBULL2X,
-        MAX_AMOUNT
-      );
+      const tx = await pool.approveTorosLimitOrder(TOROS_BTCBEAR2X, MAX_AMOUNT);
       await tx.wait(1);
-      const delta = await allowanceDelta(
-        pool.address,
-        TOROS_GOLDBULL2X,
-        limitOrderAddress[network],
+      const iERC20 = new ethers.Contract(
+        TOROS_BTCBEAR2X,
+        ["function allowance(address,address) view returns (uint256)"],
         pool.signer
       );
-      expect(delta.gt(0)).toBe(true);
+      const allowance = await iERC20.allowance(
+        pool.address,
+        limitOrderAddress[network]
+      );
+      expect(allowance.gt(0)).toBe(true);
     });
 
     it("creates a limit order", async () => {
       const tx = await pool.createTorosLimitOrder(
-        TOROS_GOLDBULL2X,
+        TOROS_BTCBEAR2X,
         ORDER_AMOUNT,
         STOP_LOSS,
         TAKE_PROFIT,
-        GOLD_PRICING_ASSET
+        BTC_PRICING_ASSET
       );
       await tx.wait(1);
       const order = await pool.getTorosLimitOrder(
         pool.address,
-        TOROS_GOLDBULL2X
+        TOROS_BTCBEAR2X
       );
       expect(order).not.toBeNull();
       expect(order!.amount.eq(ORDER_AMOUNT)).toBe(true);
       expect(order!.stopLossPriceD18.eq(STOP_LOSS)).toBe(true);
       expect(order!.takeProfitPriceD18.eq(TAKE_PROFIT)).toBe(true);
-      expect(order!.pool.toLowerCase()).toBe(TOROS_GOLDBULL2X.toLowerCase());
+      expect(order!.pool.toLowerCase()).toBe(TOROS_BTCBEAR2X.toLowerCase());
       expect(order!.pricingAsset.toLowerCase()).toBe(
-        GOLD_PRICING_ASSET.toLowerCase()
+        BTC_PRICING_ASSET.toLowerCase()
       );
     });
 
     it("modifies a toros limit order", async () => {
       const order = await pool.getTorosLimitOrder(
         pool.address,
-        TOROS_GOLDBULL2X
+        TOROS_BTCBEAR2X
       );
       if (!order) throw new Error("No existing order found");
 
@@ -87,7 +133,7 @@ const testTorosLimitOrder = ({ wallet, network }: TestingRunParams) => {
         .toString();
 
       const tx = await pool.modifyTorosLimitOrder(
-        TOROS_GOLDBULL2X,
+        TOROS_BTCBEAR2X,
         order.amount,
         newStopLoss,
         newTakeProfit,
@@ -97,7 +143,7 @@ const testTorosLimitOrder = ({ wallet, network }: TestingRunParams) => {
 
       const modifiedOrder = await pool.getTorosLimitOrder(
         pool.address,
-        TOROS_GOLDBULL2X
+        TOROS_BTCBEAR2X
       );
       expect(modifiedOrder).not.toBeNull();
       expect(modifiedOrder!.stopLossPriceD18.toString()).toBe(newStopLoss);
@@ -107,16 +153,16 @@ const testTorosLimitOrder = ({ wallet, network }: TestingRunParams) => {
     it("deletes a toros limit order", async () => {
       const order = await pool.getTorosLimitOrder(
         pool.address,
-        TOROS_GOLDBULL2X
+        TOROS_BTCBEAR2X
       );
       if (!order) throw new Error("No existing order found");
 
-      const tx = await pool.deleteTorosLimitOrder(TOROS_GOLDBULL2X);
+      const tx = await pool.deleteTorosLimitOrder(TOROS_BTCBEAR2X);
       await tx.wait(1);
 
       const deletedOrder = await pool.getTorosLimitOrder(
         pool.address,
-        TOROS_GOLDBULL2X
+        TOROS_BTCBEAR2X
       );
       expect(deletedOrder).toBeNull();
     });
@@ -125,6 +171,5 @@ const testTorosLimitOrder = ({ wallet, network }: TestingRunParams) => {
 
 testingHelper({
   network: Network.ARBITRUM,
-  testingRun: testTorosLimitOrder,
-  onFork: false
+  testingRun: testTorosLimitOrder
 });

package/src/test/uniswap.test.ts

@@ -1,11 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Dhedge, ethers, Pool } from "..";
-import { routerAddress } from "../config";
-import { AssetEnabled, Dapp, Network } from "../types";
+import { nonfungiblePositionManagerAddress } from "../config";
+import { Dapp, Network } from "../types";
 import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
-import { allowanceDelta, balanceDelta } from "./utils/token";
 import {
   setUSDCAmount,
+  setWETHAmount,
+  runWithImpersonateAccount,
   testingHelper,
   TestingRunParams
 } from "./utils/testingHelper";
@@ -30,22 +31,37 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
         "0x10000000000000000"
       ]);
       await provider.send("evm_mine", []);
+
+      // Fund pool with USDC and WETH
       await setUSDCAmount({
-        amount: new BigNumber(1000000).times(1e6).toFixed(0),
+        amount: new BigNumber(10000).times(1e6).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
+      await setWETHAmount({
+        amount: new BigNumber(5).times(1e18).toFixed(0),
         userAddress: pool.address,
         network,
         provider
       });
 
-      const newAssets: AssetEnabled[] = [
-        { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
-        { asset: CONTRACT_ADDRESS[network].WETH, isDeposit: true },
-        {
-          asset: CONTRACT_ADDRESS[network].uniswapV3.nonfungiblePositionManager,
-          isDeposit: false
+      // Impersonate the pool manager to set trader and configure assets
+      await runWithImpersonateAccount(
+        { provider, account: await pool.managerLogic.manager() },
+        async ({ signer }) => {
+          await pool.managerLogic.connect(signer).setTrader(wallet.address);
+          const newAssets = [
+            [CONTRACT_ADDRESS[network].USDC, true],
+            [CONTRACT_ADDRESS[network].WETH, true],
+            [
+              CONTRACT_ADDRESS[network].uniswapV3.nonfungiblePositionManager,
+              false
+            ]
+          ];
+          await pool.managerLogic.connect(signer).changeAssets(newAssets, []);
         }
-      ];
-      await pool.changeAssets(newAssets);
+      );
 
       nonfungiblePositionManager = new ethers.Contract(
         CONTRACT_ADDRESS[network].uniswapV3.nonfungiblePositionManager,
@@ -54,60 +70,42 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
       );
     });
 
-    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));
-    });
+    // Note: tradeUniswapV3 (UniswapV3RouterGuard) is deprecated on all chains.
+    // Swap tests removed. Use Dapp.ONEINCH or Dapp.KYBERSWAP for trading instead.
 
-    it("should swap 5000 USDC into WETH on UniswapV3", async () => {
-      await pool.tradeUniswapV3(
-        CONTRACT_ADDRESS[network].USDC,
-        CONTRACT_ADDRESS[network].WETH,
-        new BigNumber(5000).times(1e6).toFixed(0),
-        500,
-        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 () => {
-      await pool.approveUniswapV3Liquidity(
+    it("approves unlimited USDC and WETH for UniswapV3 LP", async () => {
+      const usdcTx = await pool.approveUniswapV3Liquidity(
         CONTRACT_ADDRESS[network].USDC,
         ethers.constants.MaxInt256
       );
-      await pool.approveUniswapV3Liquidity(
+      await usdcTx.wait(1);
+      const wethTx = await pool.approveUniswapV3Liquidity(
         CONTRACT_ADDRESS[network].WETH,
         ethers.constants.MaxInt256
       );
-      const UsdcAllowanceDelta = await allowanceDelta(
-        pool.address,
+      await wethTx.wait(1);
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const positionManager = nonfungiblePositionManagerAddress[network][
+        Dapp.UNISWAPV3
+      ]!;
+      const allowanceAbi = [
+        "function allowance(address,address) view returns (uint256)"
+      ];
+      const usdcAllowance = await new ethers.Contract(
         CONTRACT_ADDRESS[network].USDC,
-        pool.address,
+        allowanceAbi,
         pool.signer
-      );
-
-      expect(UsdcAllowanceDelta).not.toBe(null);
+      ).allowance(pool.address, positionManager);
+      const wethAllowance = await new ethers.Contract(
+        CONTRACT_ADDRESS[network].WETH,
+        allowanceAbi,
+        pool.signer
+      ).allowance(pool.address, positionManager);
+      expect(usdcAllowance.gt(0)).toBe(true);
+      expect(wethAllowance.gt(0)).toBe(true);
     });
 
     it("adds WETH and USDC to a new V3 pool", async () => {
-      let result = null;
       const pool = await dhedge.loadPool(TEST_POOL[network]);
       const usdcBalance = await dhedge.utils.getBalance(
         CONTRACT_ADDRESS[network].USDC,
@@ -118,39 +116,33 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
         pool.address
       );
 
-      try {
-        result = await pool.addLiquidityUniswapV3(
-          Dapp.UNISWAPV3,
-          CONTRACT_ADDRESS[network].WETH,
-          CONTRACT_ADDRESS[network].USDC,
-          wethBalance,
-          usdcBalance,
-          3500,
-          4000,
-          null,
-          null,
-          500
-          // options
-        );
-        await result.wait(1);
-
-        tokenId = await nonfungiblePositionManager.tokenOfOwnerByIndex(
-          pool.address,
-          0
-        );
-      } catch (e) {
-        console.log("e", e);
-      }
+      const result = await pool.addLiquidityUniswapV3(
+        Dapp.UNISWAPV3,
+        CONTRACT_ADDRESS[network].WETH,
+        CONTRACT_ADDRESS[network].USDC,
+        wethBalance,
+        usdcBalance,
+        3500,
+        4000,
+        null,
+        null,
+        500
+      );
+      await result.wait(1);
+
+      tokenId = await nonfungiblePositionManager.tokenOfOwnerByIndex(
+        pool.address,
+        0
+      );
       expect(result).not.toBe(null);
     });
 
-    it("should remove liquidity from an existing pool ", async () => {
+    it("should remove 50% liquidity from an existing pool", async () => {
       const result = await pool.decreaseLiquidity(
         Dapp.UNISWAPV3,
         tokenId.toString(),
-        50 // precent
+        50 // percent
       );
-      // console.log("result", result);
       expect(result).not.toBe(null);
     });
 
@@ -168,63 +160,20 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
         Dapp.UNISWAPV3,
         tokenId.toString(),
         wethBalance,
-        usdcBalance // eth
+        usdcBalance
       );
-      // console.log("result", result);
       expect(result).not.toBe(null);
     });
 
-    it("should claim fees an existing pool", async () => {
+    it("should claim fees from an existing pool", async () => {
       const result = await pool.claimFees(Dapp.UNISWAPV3, tokenId.toString());
-      // console.log("result", result);
       expect(result).not.toBe(null);
     });
-
-    // it("approves unlimited USDC to swap on UniswapV3", async () => {
-    //   let result;
-    //   const pool = await dhedge.loadPool(TEST_POOL);
-    //   try {
-    //     result = await pool.approve(
-    //       Dapp.UNISWAPV3,
-    //       USDC,
-    //       ethers.constants.MaxInt256,
-    //       options
-    //     );
-    //     console.log(result);
-    //   } catch (e) {
-    //     console.log(e);
-    //   }
-    //   expect(result).not.toBe(null);
-    // });
-
-    // it("should swap USDC into WETH on UniswapV3 pool", async () => {
-    //   const pool = await dhedge.loadPool(TEST_POOL);
-    //   const result = await pool.tradeUniswapV3(
-    //     USDC,
-    //     WETH,
-    //     "1000000",
-    //     FeeAmount.LOW,
-    //     1,
-    //     options
-    //   );
-
-    //   console.log(result);
-    //   expect(result).not.toBe(null);
-    // });
   });
 };
 
 testingHelper({
-  network: Network.OPTIMISM,
-  testingRun: testUniswapV3
+  network: Network.ARBITRUM,
+  testingRun: testUniswapV3,
+  onFork: true
 });
-
-// testingHelper({
-//   network: Network.POLYGON,
-//   testingRun: testUniswapV3
-// });
-
-// testingHelper({
-//   network: Network.ARBITRUM,
-//   testingRun: testUniswapV3
-// });