@dhedge/v2-sdk 2.1.7 → 2.2.0

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
+        }
       });
     });
   });

package/src/test/pendle.test.ts

@@ -1,13 +1,13 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
+import { ethers } from "ethers";
 import { Dhedge, Pool } from "..";
 
 import { Dapp, Network } from "../types";
-import { CONTRACT_ADDRESS, MAX_AMOUNT } from "./constants";
+import { MAX_AMOUNT } from "./constants";
 import {
   TestingRunParams,
   setTokenAmount,
-  setUSDCAmount,
   testingHelper
 } from "./utils/testingHelper";
 
@@ -16,82 +16,99 @@ import BigNumber from "bignumber.js";
 import { balanceDelta } from "./utils/token";
 
 const testPendle = ({ wallet, network, provider }: TestingRunParams) => {
-  const USDC = CONTRACT_ADDRESS[network].USDC;
   const weETH = "0x35751007a407ca6feffe80b3cb397736d2cf4dbe";
   const PTweETH = "0xab7f3837e6e721abbc826927b655180af6a04388";
   const PTweETH_matured = "0xe2b2d203577c7cb3d043e89ccf90b5e24d19b66f";
+  const WEETH_BALANCEOF_SLOT = 51;
 
   let dhedge: Dhedge;
   let pool: Pool;
-  jest.setTimeout(100000);
+  jest.setTimeout(200000);
 
   describe(`pool on ${network}`, () => {
     beforeAll(async () => {
       dhedge = new Dhedge(wallet, network);
       pool = await dhedge.loadPool(wallet.address, false);
-      // top up gas
       await provider.send("hardhat_setBalance", [
         wallet.address,
         "0x10000000000000000"
       ]);
       await provider.send("evm_mine", []);
-      // top up USDC
-      await setUSDCAmount({
-        amount: new BigNumber(2000).times(1e6).toFixed(0),
-        userAddress: pool.address,
-        network,
-        provider
+
+      await setTokenAmount({
+        amount: new BigNumber(1).times(1e18).toString(),
+        provider,
+        tokenAddress: weETH,
+        slot: WEETH_BALANCEOF_SLOT,
+        userAddress: pool.address
       });
-      await pool.approve(Dapp.ODOS, USDC, MAX_AMOUNT);
-      await pool.trade(
-        Dapp.ODOS,
-        USDC,
-        weETH,
-        "2000000000",
-        0.5,
-        await getTxOptions(network)
-      );
     });
 
     it("swaps weETH to PTweETH on Pendle", async () => {
       await pool.approve(Dapp.PENDLE, weETH, MAX_AMOUNT);
       const weEthBalance = await pool.utils.getBalance(weETH, pool.address);
-      await pool.trade(
-        Dapp.PENDLE,
-        weETH,
-        PTweETH,
-        weEthBalance,
-        0.5,
-        await getTxOptions(network)
-      );
+      // See note in the PT→weETH test: Pendle may include a limit-order route
+      // whose maker signature can't validate on a fork.
+      try {
+        const tx = await pool.trade(
+          Dapp.PENDLE,
+          weETH,
+          PTweETH,
+          weEthBalance,
+          1,
+          await getTxOptions(network)
+        );
+        await tx.wait(1);
+      } catch (e) {
+        if (String(e).includes("LOP: bad signature")) {
+          console.warn(
+            "[swaps weETH to PTweETH on Pendle] Pendle returned a limit-order route; signature can't validate on fork — skipping assertion"
+          );
+          return;
+        }
+        throw e;
+      }
       const ptWeEthBalanceDelta = await balanceDelta(
         pool.address,
         PTweETH,
         pool.signer
       );
-      expect(ptWeEthBalanceDelta.gt(0));
+      expect(ptWeEthBalanceDelta.gt(0)).toBe(true);
     });
 
-    // it("swaps PTweETH to weETH on Pendle", async () => {
-    //   await pool.approve(Dapp.PENDLE, PTweETH, MAX_AMOUNT);
-    //   const PTweEthBalance = await pool.utils.getBalance(PTweETH, pool.address);
-    //   console.log("PTweEthBalance", PTweEthBalance.toString());
-    //   await wait(3);
-    //   await pool.trade(
-    //     Dapp.PENDLE,
-    //     PTweETH,
-    //     weETH,
-    //     PTweEthBalance,
-    //     0.5,
-    //     await getTxOptions(network)
-    //   );
-    //   const weEthBalanceDelta = await balanceDelta(
-    //     pool.address,
-    //     weETH,
-    //     pool.signer
-    //   );
-    //   expect(weEthBalanceDelta.gt(0));
-    // });
+    it("swaps PTweETH to weETH on Pendle", async () => {
+      await pool.approve(Dapp.PENDLE, PTweETH, MAX_AMOUNT);
+      const PTweEthBalance = await pool.utils.getBalance(PTweETH, pool.address);
+      // Pendle's API may return a route that includes an off-chain limit order
+      // signed by a market maker. Those signatures don't validate on a fork
+      // (maker nonce/state diverges), so the swap reverts with "LOP: bad signature".
+      // Skip the assertion in that case — the SDK code path was still exercised.
+      try {
+        const tx = await pool.trade(
+          Dapp.PENDLE,
+          PTweETH,
+          weETH,
+          PTweEthBalance,
+          1,
+          await getTxOptions(network)
+        );
+        await tx.wait(1);
+      } catch (e) {
+        if (String(e).includes("LOP: bad signature")) {
+          console.warn(
+            "[swaps PTweETH to weETH on Pendle] Pendle returned a limit-order route; signature can't validate on fork — skipping assertion"
+          );
+          return;
+        }
+        throw e;
+      }
+      const weEthBalanceDelta = await balanceDelta(
+        pool.address,
+        weETH,
+        pool.signer
+      );
+      expect(weEthBalanceDelta.gt(0)).toBe(true);
+    });
 
     it("exit matured PTweETH to weETH on Pendle", async () => {
       await setTokenAmount({
@@ -106,23 +123,46 @@ const testPendle = ({ wallet, network, provider }: TestingRunParams) => {
         PTweETH_matured,
         pool.address
       );
-      await pool.trade(
+      const tx = await pool.trade(
         Dapp.PENDLE,
         PTweETH_matured,
         weETH,
         PTweEthBalance,
-        0.5,
+        1,
         await getTxOptions(network)
       );
+      await tx.wait(1);
       const weEthBalanceDelta = await balanceDelta(
         pool.address,
         weETH,
         pool.signer
       );
-      expect(weEthBalanceDelta.eq(PTweEthBalance));
+
+      // After maturity, PT redeems via SY at SY.exchangeRate(): out = in * 1e18 / rate.
+      // Allow a small rounding tolerance from integer division on-chain.
+      const ptContract = new ethers.Contract(
+        PTweETH_matured,
+        ["function SY() view returns (address)"],
+        pool.signer
+      );
+      const syContract = new ethers.Contract(
+        await ptContract.SY(),
+        ["function exchangeRate() view returns (uint256)"],
+        pool.signer
+      );
+      const exchangeRate = await syContract.exchangeRate();
+      const expectedOut = PTweEthBalance.mul(ethers.constants.WeiPerEther).div(
+        exchangeRate
+      );
+      expect(
+        weEthBalanceDelta
+          .sub(expectedOut)
+          .abs()
+          .lte(1)
+      ).toBe(true);
     });
 
-    it("exit matured PTweETH to weETH on Pendle", async () => {
+    it("estimates exit matured PTweETH to weETH on Pendle", async () => {
       await setTokenAmount({
         amount: new BigNumber(1).times(1e18).toString(),
         provider,
@@ -140,7 +180,7 @@ const testPendle = ({ wallet, network, provider }: TestingRunParams) => {
         PTweETH_matured,
         weETH,
         PTweEthBalance,
-        0.5,
+        1,
         await getTxOptions(network),
         true
       );

package/src/test/{pendleMint.test.ts → pendleMint.onchain.test.ts}

@@ -1,13 +1,24 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
+/**
+ * Pendle mint on-chain tests for PT/SY minting on Plasma.
+ * These require a live chain connection (onFork: false) because Pendle's
+ * SDK router endpoint only returns swap data against real chain state.
+ *
+ * Prerequisites:
+ *   - PRIVATE_KEY in .env (must be the pool manager or trader)
+ *   - PLASMA_URL in .env
+ *   - The test pool must already hold a non-zero USDE balance
+ */
+
 import { Dhedge, Pool } from "..";
 
 import { Network } from "../types";
-import { CONTRACT_ADDRESS } from "./constants";
+import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
 import { getTxOptions } from "./txOptions";
 import { TestingRunParams, testingHelper } from "./utils/testingHelper";
 
-const testPendle = ({ wallet, network }: TestingRunParams) => {
+const testPendleMint = ({ wallet, network }: TestingRunParams) => {
   const USDE = CONTRACT_ADDRESS[network].USDE;
   const PTJan26Usde = "0x93b544c330f60a2aa05ced87aeeffb8d38fd8c9a";
 
@@ -18,9 +29,11 @@ const testPendle = ({ wallet, network }: TestingRunParams) => {
   describe(`pool on ${network}`, () => {
     beforeAll(async () => {
       dhedge = new Dhedge(wallet, network);
-      pool = await dhedge.loadPool(
-        "0xdad21646ebb0997eb59de1f6a68a67059daf4c31"
-      );
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+      const usdeBalance = await pool.utils.getBalance(USDE, pool.address);
+      if (usdeBalance.isZero()) {
+        throw new Error("pool has no USDE — fund the pool before running");
+      }
     });
 
     it("can get TX Data for mint PT and SY", async () => {
@@ -37,15 +50,16 @@ const testPendle = ({ wallet, network }: TestingRunParams) => {
       expect(minAmountOut).not.toBeNull();
     });
 
-    it("can get for mint PT and SY", async () => {
+    it("mints PT and SY", async () => {
       const usdeBalance = await pool.utils.getBalance(USDE, pool.address);
-      await pool.mintPendle(
+      const tx = await pool.mintPendle(
         USDE,
         PTJan26Usde,
         usdeBalance,
         0.5,
         await getTxOptions(network)
       );
+      await tx.wait(1);
       const ptBalance = await pool.utils.getBalance(PTJan26Usde, pool.address);
       expect(ptBalance.gt(0)).toBe(true);
     });
@@ -55,5 +69,5 @@ const testPendle = ({ wallet, network }: TestingRunParams) => {
 testingHelper({
   network: Network.PLASMA,
   onFork: false,
-  testingRun: testPendle
+  testingRun: testPendleMint
 });