@dhedge/v2-sdk 2.1.8 → 2.2.0

package/src/test/lyra.test.ts

@@ -1,164 +1,173 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { utils } from "ethers";
 import { Dhedge } from "..";
 import { Network } from "../types";
-import { utils } from "ethers";
-import { SUSD, TEST_POOL } from "./constants";
+import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
 import { getTxOptions } from "./txOptions";
-import { wallet } from "./wallet";
+import { TestingRunParams, testingHelper } from "./utils/testingHelper";
 
-jest.setTimeout(100000);
-const TEST_POOL_OP = TEST_POOL.optimism;
+const testLyra = ({ wallet, network }: TestingRunParams) => {
+  const SUSD = CONTRACT_ADDRESS[network].SUSD;
 
-describe("pool", () => {
   let dhedge: Dhedge;
-  const options = getTxOptions(Network.OPTIMISM);
-  beforeAll(async () => {
-    dhedge = new Dhedge(wallet, Network.OPTIMISM);
-  });
+  jest.setTimeout(100000);
 
-  it("buys 0.1 1400 calls with expiry October 28th", async () => {
-    let result;
-    const pool = await dhedge.loadPool(TEST_POOL_OP);
-    try {
-      result = await pool.tradeLyraOption(
-        "eth",
-        1666944000,
-        1400,
-        "call",
-        "buy",
-        utils.parseEther("0.1"),
-        SUSD
-      );
-    } catch (e) {
-      console.log(e);
-    }
-    result.wait(1);
-    const positions = await pool.getLyraPositions("eth");
-    expect(positions.length > 0);
-  });
+  describe(`pool on ${network}`, () => {
+    let options: any;
+    beforeAll(async () => {
+      options = await getTxOptions(network);
+      dhedge = new Dhedge(wallet, network);
+    });
 
-  it("adds 0.05 1400 calls with expiry October 28th", async () => {
-    let result;
-    const pool = await dhedge.loadPool(TEST_POOL_OP);
-    try {
-      result = await pool.tradeLyraOption(
-        "eth",
-        1666944000,
-        1400,
-        "call",
-        "buy",
-        utils.parseEther("0.05"),
-        SUSD,
-        "0",
-        false,
-        options
-      );
-    } catch (e) {
-      console.log(e);
-    }
-    result.wait(1);
-    const positions = await pool.getLyraPositions("eth");
-    expect(utils.formatEther(positions[0].amount)).toBe("0.15");
-  });
+    it("buys 0.1 1400 calls with expiry October 28th", async () => {
+      let result;
+      const pool = await dhedge.loadPool(TEST_POOL[network]);
+      try {
+        result = await pool.tradeLyraOption(
+          "eth",
+          1666944000,
+          1400,
+          "call",
+          "buy",
+          utils.parseEther("0.1"),
+          SUSD
+        );
+      } catch (e) {
+        console.log(e);
+      }
+      result.wait(1);
+      const positions = await pool.getLyraPositions("eth");
+      expect(positions.length > 0);
+    });
 
-  it("sells 0.1 1300 Covered Call with expiry October 28th", async () => {
-    let result;
-    const pool = await dhedge.loadPool(TEST_POOL_OP);
-    try {
-      result = await pool.tradeLyraOption(
-        "eth",
-        1666944000,
-        1300,
-        "call",
-        "sell",
-        utils.parseEther("0.1"),
-        SUSD,
-        utils.parseEther("0.1"),
-        true,
-        options
-      );
-    } catch (e) {
-      console.log(e);
-    }
-    result.wait(1);
-    const positions = await pool.getLyraPositions("eth");
-    const cCall = positions.find(e => e.optionType === 2);
-    expect(cCall).not.toBe(undefined);
-  });
+    it("adds 0.05 1400 calls with expiry October 28th", async () => {
+      let result;
+      const pool = await dhedge.loadPool(TEST_POOL[network]);
+      try {
+        result = await pool.tradeLyraOption(
+          "eth",
+          1666944000,
+          1400,
+          "call",
+          "buy",
+          utils.parseEther("0.05"),
+          SUSD,
+          "0",
+          false,
+          options
+        );
+      } catch (e) {
+        console.log(e);
+      }
+      result.wait(1);
+      const positions = await pool.getLyraPositions("eth");
+      expect(utils.formatEther(positions[0].amount)).toBe("0.15");
+    });
 
-  it("adds 0.05 1300 Covered Call with expiry October 28th", async () => {
-    let result;
-    const pool = await dhedge.loadPool(TEST_POOL_OP);
-    try {
-      result = await pool.tradeLyraOption(
-        "eth",
-        1666944000,
-        1300,
-        "call",
-        "sell",
-        utils.parseEther("0.05"),
-        SUSD,
-        utils.parseEther("0.05"),
-        true,
-        options
-      );
-    } catch (e) {
-      console.log(e);
-    }
-    result.wait(1);
-    const positions = await pool.getLyraPositions("eth");
-    const cCall = positions.find(e => e.optionType === 2);
-    expect(cCall);
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    expect(utils.formatEther(cCall!.amount)).toBe("0.15");
-  });
+    it("sells 0.1 1300 Covered Call with expiry October 28th", async () => {
+      let result;
+      const pool = await dhedge.loadPool(TEST_POOL[network]);
+      try {
+        result = await pool.tradeLyraOption(
+          "eth",
+          1666944000,
+          1300,
+          "call",
+          "sell",
+          utils.parseEther("0.1"),
+          SUSD,
+          utils.parseEther("0.1"),
+          true,
+          options
+        );
+      } catch (e) {
+        console.log(e);
+      }
+      result.wait(1);
+      const positions = await pool.getLyraPositions("eth");
+      const cCall = positions.find(e => e.optionType === 2);
+      expect(cCall).not.toBe(undefined);
+    });
 
-  it("closes all 0.15 1300 Covered Call with expiry October 28th", async () => {
-    let result;
-    const pool = await dhedge.loadPool(TEST_POOL_OP);
-    try {
-      result = await pool.tradeLyraOption(
-        "eth",
-        1666944000,
-        1300,
-        "call",
-        "buy",
-        utils.parseEther("0.15"),
-        SUSD,
-        utils.parseEther("0.15"),
-        true,
-        options
-      );
-    } catch (e) {
-      console.log(e);
-    }
-    result.wait(1);
-    const positions = await pool.getLyraPositions("eth");
-    const cCall = positions.find(e => e.optionType === 2 && e.state === 1);
-    expect(cCall).toBe(undefined);
-  });
+    it("adds 0.05 1300 Covered Call with expiry October 28th", async () => {
+      let result;
+      const pool = await dhedge.loadPool(TEST_POOL[network]);
+      try {
+        result = await pool.tradeLyraOption(
+          "eth",
+          1666944000,
+          1300,
+          "call",
+          "sell",
+          utils.parseEther("0.05"),
+          SUSD,
+          utils.parseEther("0.05"),
+          true,
+          options
+        );
+      } catch (e) {
+        console.log(e);
+      }
+      result.wait(1);
+      const positions = await pool.getLyraPositions("eth");
+      const cCall = positions.find(e => e.optionType === 2);
+      expect(cCall);
+      expect(utils.formatEther(cCall!.amount)).toBe("0.15");
+    });
 
-  it("closes all 0.15 1400 Calls with expiry October 28th", async () => {
-    let result;
-    const pool = await dhedge.loadPool(TEST_POOL_OP);
-    try {
-      result = await pool.tradeLyraOption(
-        "eth",
-        1666944000,
-        1400,
-        "call",
-        "sell",
-        utils.parseEther("0.15"),
-        SUSD,
-        "0",
-        false,
-        options
-      );
-    } catch (e) {
-      console.log(e);
-    }
-    result.wait(1);
-    const positions = await pool.getLyraPositions("eth");
-    const call = positions.find(e => e.optionType === 0 && e.state === 1);
-    expect(call).toBe(undefined);
+    it("closes all 0.15 1300 Covered Call with expiry October 28th", async () => {
+      let result;
+      const pool = await dhedge.loadPool(TEST_POOL[network]);
+      try {
+        result = await pool.tradeLyraOption(
+          "eth",
+          1666944000,
+          1300,
+          "call",
+          "buy",
+          utils.parseEther("0.15"),
+          SUSD,
+          utils.parseEther("0.15"),
+          true,
+          options
+        );
+      } catch (e) {
+        console.log(e);
+      }
+      result.wait(1);
+      const positions = await pool.getLyraPositions("eth");
+      const cCall = positions.find(e => e.optionType === 2 && e.state === 1);
+      expect(cCall).toBe(undefined);
+    });
+
+    it("closes all 0.15 1400 Calls with expiry October 28th", async () => {
+      let result;
+      const pool = await dhedge.loadPool(TEST_POOL[network]);
+      try {
+        result = await pool.tradeLyraOption(
+          "eth",
+          1666944000,
+          1400,
+          "call",
+          "sell",
+          utils.parseEther("0.15"),
+          SUSD,
+          "0",
+          false,
+          options
+        );
+      } catch (e) {
+        console.log(e);
+      }
+      result.wait(1);
+      const positions = await pool.getLyraPositions("eth");
+      const call = positions.find(e => e.optionType === 0 && e.state === 1);
+      expect(call).toBe(undefined);
+    });
   });
+};
+
+testingHelper({
+  network: Network.OPTIMISM,
+  testingRun: testLyra
 });

package/src/test/odos.test.ts

@@ -50,7 +50,7 @@ const testOdos = ({ wallet, network, provider }: TestingRunParams) => {
         routerAddress[network]["odos"]!,
         pool.signer
       );
-      await expect(usdcAllowanceDelta.gt(0));
+      expect(usdcAllowanceDelta.gt(0)).toBe(true);
     });
 
     it("gets gas estimation for 10 USDC into WETH on Odos", async () => {
@@ -82,7 +82,7 @@ const testOdos = ({ wallet, network, provider }: TestingRunParams) => {
         WETH,
         pool.signer
       );
-      expect(wethBalanceDelta.gt(0));
+      expect(wethBalanceDelta.gt(0)).toBe(true);
       const wethBalanceDeltaForFeeRecipient = await balanceDelta(
         OdosSwapFeeRecipient[network],
         WETH,

package/src/test/oneInch.test.ts

@@ -1,20 +1,23 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
+import BigNumber from "bignumber.js";
+import { ethers } from "ethers";
 import { Dhedge, Pool } from "..";
 
+import { routerAddress } from "../config";
 import { Dapp, Network } from "../types";
 import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import { getTxOptions } from "./txOptions";
 import {
   TestingRunParams,
+  fixOracleAggregatorStaleness,
+  runWithImpersonateAccount,
+  setChainlinkTimeout,
   setUSDCAmount,
   testingHelper,
   wait
 } from "./utils/testingHelper";
-import { allowanceDelta, balanceDelta } from "./utils/token";
-import { getTxOptions } from "./txOptions";
-import BigNumber from "bignumber.js";
-import { routerAddress } from "../config";
-// import { routerAddress } from "../config";
+import { balanceDelta } from "./utils/token";
 
 const testOneInch = ({ wallet, network, provider }: TestingRunParams) => {
   const USDC = CONTRACT_ADDRESS[network].USDC;
@@ -26,22 +29,30 @@ const testOneInch = ({ wallet, network, provider }: TestingRunParams) => {
 
   describe(`pool on ${network}`, () => {
     beforeAll(async () => {
-      dhedge = new Dhedge(wallet, network);
-      pool = await dhedge.loadPool(TEST_POOL[network]);
-      // 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[network]);
 
-      const newAssets = [
-        { asset: USDC, isDeposit: true },
-        { asset: WETH, isDeposit: true }
-      ];
+      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
+      await fixOracleAggregatorStaleness({ pool, provider });
+
+      await runWithImpersonateAccount(
+        { provider, account: await pool.managerLogic.manager() },
+        async ({ signer }) => {
+          await pool.managerLogic.connect(signer).setTrader(wallet.address);
+          await pool.managerLogic.connect(signer).changeAssets(
+            [
+              [USDC, true],
+              [WETH, true]
+            ],
+            []
+          );
+        }
+      );
 
-      await pool.managerLogic.changeAssets(newAssets, []);
-      // top up USDC
       await setUSDCAmount({
         amount: new BigNumber(2).times(1e6).toFixed(0),
         userAddress: pool.address,
@@ -52,13 +63,16 @@ const testOneInch = ({ wallet, network, provider }: TestingRunParams) => {
 
     it("approves unlimited USDC on 1Inch", async () => {
       await pool.approve(Dapp.ONEINCH, USDC, MAX_AMOUNT);
-      const usdcAllowanceDelta = await allowanceDelta(
-        pool.address,
+      const iERC20 = new ethers.Contract(
         USDC,
-        routerAddress[network]["1inch"]!,
+        ["function allowance(address,address) view returns (uint256)"],
         pool.signer
       );
-      await expect(usdcAllowanceDelta.gt(0));
+      const usdcAllowance = await iERC20.allowance(
+        pool.address,
+        routerAddress[network][Dapp.ONEINCH]!
+      );
+      expect(usdcAllowance.gt(0)).toBe(true);
     });
 
     it("gets gas estimation for 2 USDC into WETH on 1Inch", async () => {
@@ -71,7 +85,7 @@ const testOneInch = ({ wallet, network, provider }: TestingRunParams) => {
         await getTxOptions(network),
         true
       );
-      expect(gasEstimate.gas.gt(0));
+      expect(gasEstimate.gas.gt(0)).toBe(true);
       expect(gasEstimate.minAmountOut).not.toBeNull();
     });
 
@@ -104,13 +118,13 @@ const testOneInch = ({ wallet, network, provider }: TestingRunParams) => {
         WETH,
         pool.signer
       );
-      expect(wethBalanceDelta.gt(0));
+      expect(wethBalanceDelta.gt(0)).toBe(true);
     });
   });
 };
 
 testingHelper({
-  network: Network.OPTIMISM,
+  network: Network.ARBITRUM,
   testingRun: testOneInch
 });
 

package/src/test/pancakeCL.test.ts

@@ -1,23 +1,31 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import BigNumber from "bignumber.js";
 import { Dhedge, Pool, ethers } from "..";
 
 import { nonfungiblePositionManagerAddress, stakingAddress } from "../config";
-import { AssetEnabled, Dapp, Network } from "../types";
-import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import { Dapp, Network } from "../types";
+import {
+  CONTRACT_ADDRESS,
+  MAX_AMOUNT,
+  TEST_POOL,
+  USDC_BALANCEOF_SLOT
+} from "./constants";
 import {
   TestingRunParams,
   beforeAfterReset,
+  fixOracleAggregatorStaleness,
+  runWithImpersonateAccount,
   setChainlinkTimeout,
+  setTokenAmount,
   testingHelper
 } from "./utils/testingHelper";
-import { allowanceDelta, balanceDelta } from "./utils/token";
+import { balanceDelta } from "./utils/token";
 import INonfungiblePositionManager from "../abi/INonfungiblePositionManager.json";
 
 const testPancakeCL = ({ wallet, network, provider }: TestingRunParams) => {
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
   const PANCAKE_POSITION_MANGER = nonfungiblePositionManagerAddress[network][
     Dapp.PANCAKECL
   ]!;
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
   const GAUGE = stakingAddress[network][Dapp.PANCAKECL]!;
 
   const USDC = CONTRACT_ADDRESS[network].USDC;
@@ -31,27 +39,45 @@ const testPancakeCL = ({ wallet, network, provider }: TestingRunParams) => {
 
   describe(`[${network}] Pancake CL tests`, () => {
     beforeAll(async () => {
-      await provider.send("evm_mine", []);
-      // top up ETH (gas)
       await provider.send("hardhat_setBalance", [
         wallet.address,
-        "0x100000000000000"
+        "0x10000000000000000"
       ]);
       dhedge = new Dhedge(wallet, network);
       pool = await dhedge.loadPool(TEST_POOL[network]);
 
-      // setChainlinkTimeout
       await setChainlinkTimeout({ pool, provider }, 86400 * 365);
-
-      const newAssets: AssetEnabled[] = [
-        { asset: USDC, isDeposit: true },
-        { asset: USDT, isDeposit: true },
-        {
-          asset: PANCAKE_POSITION_MANGER,
-          isDeposit: false
+      await fixOracleAggregatorStaleness({ pool, provider });
+
+      await runWithImpersonateAccount(
+        { provider, account: await pool.managerLogic.manager() },
+        async ({ signer }) => {
+          await pool.managerLogic.connect(signer).setTrader(wallet.address);
+          await pool.managerLogic.connect(signer).changeAssets(
+            [
+              [USDC, true],
+              [USDT, true],
+              [PANCAKE_POSITION_MANGER, false]
+            ],
+            []
+          );
         }
-      ];
-      await pool.managerLogic.changeAssets(newAssets, []);
+      );
+
+      await setTokenAmount({
+        amount: new BigNumber(1000).times(1e6).toFixed(0),
+        userAddress: pool.address,
+        tokenAddress: USDC,
+        slot: USDC_BALANCEOF_SLOT[network],
+        provider
+      });
+      await setTokenAmount({
+        amount: new BigNumber(1000).times(1e6).toFixed(0),
+        userAddress: pool.address,
+        tokenAddress: USDT,
+        slot: 0,
+        provider
+      });
 
       positionManager = new ethers.Contract(
         PANCAKE_POSITION_MANGER,
@@ -63,16 +89,19 @@ const testPancakeCL = ({ wallet, network, provider }: TestingRunParams) => {
     beforeAfterReset({ beforeAll, afterAll, provider });
 
     describe("Liquidity", () => {
-      it("approves unlimited USDC and USDT on for Aerodrome CL", async () => {
+      it("approves unlimited USDC and USDT on for Pancake CL", async () => {
         await pool.approveSpender(PANCAKE_POSITION_MANGER, USDC, MAX_AMOUNT);
         await pool.approveSpender(PANCAKE_POSITION_MANGER, USDT, MAX_AMOUNT);
-        const UsdcAllowanceDelta = await allowanceDelta(
-          pool.address,
+        const iERC20 = new ethers.Contract(
           USDC,
-          PANCAKE_POSITION_MANGER,
+          ["function allowance(address,address) view returns (uint256)"],
           pool.signer
         );
-        await expect(UsdcAllowanceDelta.gt(0));
+        const usdcAllowance = await iERC20.allowance(
+          pool.address,
+          PANCAKE_POSITION_MANGER
+        );
+        expect(usdcAllowance.gt(0)).toBe(true);
       });
 
       it("adds USDC and USDT to a CL (mint position)", async () => {
@@ -108,21 +137,24 @@ const testPancakeCL = ({ wallet, network, provider }: TestingRunParams) => {
           usdtBalance.div(2)
         );
         const positionAfter = await positionManager.positions(tokenId);
-        expect(positionAfter.liquidity.gt(positionBefore.liquidity));
+        expect(positionAfter.liquidity.gt(positionBefore.liquidity)).toBe(true);
       });
 
       it("decreases liquidity from a CL position", async () => {
         const positionBefore = await positionManager.positions(tokenId);
         await pool.decreaseLiquidity(Dapp.PANCAKECL, tokenId, 50);
         const positionAfter = await positionManager.positions(tokenId);
-        expect(positionAfter.liquidity.lt(positionBefore.liquidity));
+        expect(positionAfter.liquidity.lt(positionBefore.liquidity)).toBe(true);
       });
 
       it("collects fess of a CL position", async () => {
-        await provider.send("evm_increaseTime", [24 * 3600 * 3]); // 1 day
+        await provider.send("evm_increaseTime", [24 * 3600 * 3]); // 3 days
         await provider.send("evm_mine", []);
         await pool.claimFees(Dapp.PANCAKECL, tokenId);
-        expect((await balanceDelta(pool.address, USDC, pool.signer)).gt(0));
+        // Fork has no trading activity during evm_increaseTime so no fees accrue — assert gte(0) to verify the call succeeds
+        expect(
+          (await balanceDelta(pool.address, USDC, pool.signer)).gte(0)
+        ).toBe(true);
       });
     });
     describe("Liquidity staking", () => {
@@ -164,18 +196,19 @@ const testPancakeCL = ({ wallet, network, provider }: TestingRunParams) => {
           usdtBalance.div(2)
         );
         const positionAfter = await positionManager.positions(tokenId);
-        expect(positionAfter.liquidity.gt(positionBefore.liquidity));
+        expect(positionAfter.liquidity.gt(positionBefore.liquidity)).toBe(true);
       });
 
       it("collects fess from a staked CL position", async () => {
-        await pool.claimFees(Dapp.PANCAKECL, tokenId);
+        const tx = await pool.claimFees(Dapp.PANCAKECL, tokenId);
+        expect(tx).toBeDefined();
       });
 
       it("decreases liquidity from a CL position", async () => {
         const positionBefore = await positionManager.positions(tokenId);
         await pool.decreaseLiquidity(Dapp.PANCAKECL, tokenId, 50);
         const positionAfter = await positionManager.positions(tokenId);
-        expect(positionAfter.liquidity.lt(positionBefore.liquidity));
+        expect(positionAfter.liquidity.lt(positionBefore.liquidity)).toBe(true);
       });
 
       it("unstakes a CL position from a gauge", async () => {
@@ -188,7 +221,15 @@ const testPancakeCL = ({ wallet, network, provider }: TestingRunParams) => {
       it("remove all liquidity from a staked CL position", async () => {
         await pool.stakeInGauge(Dapp.PANCAKECL, GAUGE, tokenId);
         await pool.decreaseLiquidity(Dapp.PANCAKECL, tokenId, 100);
-        expect((await positionManager.balanceOf(pool.address)).eq(0));
+        // (a) NFT burned — ownerOf reverts for non-existent tokenId
+        await expect(positionManager.ownerOf(tokenId)).rejects.toThrow();
+        // (b) position data cleared — liquidity is 0 (or positions() reverts post-burn)
+        try {
+          const positionAfter = await positionManager.positions(tokenId);
+          expect(positionAfter.liquidity.eq(0)).toBe(true);
+        } catch {
+          // positions() reverted — acceptable for burned tokens on some NPM implementations
+        }
       });
     });
   });