@dhedge/v2-sdk 2.1.8 → 2.2.0

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

package/src/test/pool.test.ts

@@ -1,12 +1,20 @@
-import { Dhedge, Network, Pool } from "..";
-import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
-
-import { testingHelper, TestingRunParams } from "./utils/testingHelper";
-import { balanceDelta } from "./utils/token";
-// import { allowanceDelta } from "./utils/token";
-// import { balanceDelta } from "./utils/token";
-
-const testPool = ({ wallet, network }: TestingRunParams) => {
+import BigNumber from "bignumber.js";
+import { Dhedge, ethers, Network, Pool } from "..";
+import { AssetEnabled } from "../types";
+import { CONTRACT_ADDRESS } from "./constants";
+
+import {
+  testingHelper,
+  TestingRunParams,
+  beforeAfterReset,
+  setUSDCAmount,
+  setWETHAmount,
+  setChainlinkTimeout,
+  fixOracleAggregatorStaleness
+} from "./utils/testingHelper";
+import { allowanceDelta, balanceDelta } from "./utils/token";
+
+const testPool = ({ wallet, network, provider }: TestingRunParams) => {
   let dhedge: Dhedge;
   let pool: Pool;
 
@@ -14,104 +22,153 @@ const testPool = ({ wallet, network }: TestingRunParams) => {
 
   describe(`pool on ${network}`, () => {
     beforeAll(async () => {
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
       dhedge = new Dhedge(wallet, network);
-      pool = await dhedge.loadPool(TEST_POOL[network]);
+
+      // Create a fresh pool with USDC and WETH
+      pool = await dhedge.createPool("Test Manager", "Pool Test Fund", "PTF", [
+        [CONTRACT_ADDRESS[network].USDC, true],
+        [CONTRACT_ADDRESS[network].WETH, false]
+      ]);
+
+      // Extend oracle timeouts so price feeds work on fork
+      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
+      await fixOracleAggregatorStaleness({ pool, provider });
+
+      // Fund wallet with USDC for deposit test
+      await setUSDCAmount({
+        amount: (100 * 1e6).toString(),
+        userAddress: wallet.address,
+        network,
+        provider
+      });
+    });
+
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    it("checks fund composition", async () => {
+      const result = await pool.getComposition();
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it("skips removing assets with a non-zero balance and warns", async () => {
+      // The pool currently has [USDC, WETH]. PoolManagerLogic.changeAssets
+      // reverts on-chain if you try to remove an asset with a non-zero pool
+      // balance. Pool.changeAssets() simulates each removal via callStatic
+      // and skips the ones that would revert, so the real tx still succeeds.
+      // This test proves that path: fund WETH → ask to remove it →
+      // expect WETH to stay in the composition and a warn line to be logged.
+
+      // 1. Give WETH a non-zero balance so its removal simulation will revert.
+      await setWETHAmount({
+        amount: new BigNumber(1).times(1e18).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
+
+      // 2. Spy on console.warn so we can assert the skip was reported.
+      //    mockImplementation silences the output during the test run.
+      const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {
+        /* swallow warnings so they don't pollute test output */
+      });
+
+      // 3. Ask changeAssets to end up with [USDC] only — i.e. drop WETH.
+      //    Internally, the WETH removal simulation will revert, so WETH is
+      //    dropped from `removedAssets` and the real tx never tries to remove it.
+      const newAssets: AssetEnabled[] = [
+        { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true }
+      ];
+      await pool.changeAssets(newAssets);
+
+      // 4. WETH should still be an enabled asset (skip worked).
+      const assetsAfter = await pool.getComposition();
+      const wethStillPresent = assetsAfter.some(
+        a =>
+          a.asset.toLowerCase() === CONTRACT_ADDRESS[network].WETH.toLowerCase()
+      );
+      expect(wethStillPresent).toBe(true);
+
+      // 5. And the skip should have been logged via console.warn.
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("skipping removal of")
+      );
+      warnSpy.mockRestore();
+
+      // 6. Restore pre-test state: drain WETH so the next test — which
+      //    expects WETH to be removable — isn't affected by our funding.
+      await setWETHAmount({
+        amount: "0",
+        userAddress: pool.address,
+        network,
+        provider
+      });
+    });
+
+    it("changes enabled assets (removes WETH, keeps USDC only)", async () => {
+      const assetsBefore = await pool.getComposition();
+      const newAssets: AssetEnabled[] = [
+        { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true }
+      ];
+      await pool.changeAssets(newAssets);
+      const assetsAfter = await pool.getComposition();
+      expect(assetsAfter.length).toBeLessThan(assetsBefore.length);
+    });
+
+    it("approves USDC for deposit", async () => {
+      await pool.approveDeposit(
+        CONTRACT_ADDRESS[network].USDC,
+        ethers.constants.MaxUint256
+      );
+      const usdcAllowanceDelta = await allowanceDelta(
+        wallet.address,
+        CONTRACT_ADDRESS[network].USDC,
+        pool.address,
+        pool.signer
+      );
+      expect(usdcAllowanceDelta.gt(0)).toBe(true);
     });
 
-    // it("checks fund composition", async () => {
-    //   const result = await pool.getComposition();
-    //   console.log(result);
-    //   expect(result.length).toBeGreaterThan(0);
-    // });
-
-    // it("sets max supply cap", async () => {
-    //   const totalSupply: BigNumber = await pool.poolLogic.totalSupply();
-    //   let initCap = totalSupply;
-    //   if (totalSupply.eq(0)) {
-    //     initCap = BigNumber.from(1000).mul(BigNumber.from(10).pow(18));
-    //   }
-    //   await pool.setMaxCap(initCap.mul(2), null, true);
-    //   const tx = await pool.setMaxCap(initCap.mul(2));
-    //   await tx.wait(1);
-    //   const maxCapAfter: BigNumber = await pool.managerLogic.maxSupplyCap();
-    //   expect(maxCapAfter).toEqual(initCap.mul(2));
-    // });
-
-    // it("sets pool private", async () => {
-    //   const result = await pool.setPrivate(true);
-    //   expect(result).not.toBeNull();
-    // });
-
-    // it("adds WBTC to enabled assets", async () => {
-    //   const assetsBefore = await pool.getComposition();
-
-    //   const newAssets: AssetEnabled[] = [
-    //     { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
-    //     {
-    //       asset: "0x3333333333333333333333333333333333333333",
-    //       isDeposit: false
-    //     }
-    //   ];
-    //   await pool.changeAssets(newAssets);
-    //   const assetsAfter = await pool.getComposition();
-    //   expect(assetsAfter.length).toBeLessThanOrEqual(assetsBefore.length);
-    // });
-
-    // it("approves USDT balance of User for Deposit", async () => {
-    //   await pool.approveDeposit(
-    //     CONTRACT_ADDRESS[network].USDC,
-    //     ethers.constants.MaxUint256
-    //   );
-    //   const usdtAllowanceDelta = await allowanceDelta(
-    //     pool.signer.address,
-    //     CONTRACT_ADDRESS[network].USDC,
-    //     pool.address,
-    //     pool.signer
-    //   );
-    //   expect(usdtAllowanceDelta.gt(0));
-    // });
-
-    it("deposits 200 USDT into Pool", async () => {
-      await pool.deposit(CONTRACT_ADDRESS[network].USDC, (30000000).toString());
+    it("deposits 30 USDC into pool", async () => {
+      await pool.deposit(CONTRACT_ADDRESS[network].USDC, (30 * 1e6).toString());
       const poolTokenDelta = await balanceDelta(
+        wallet.address,
         pool.address,
-        CONTRACT_ADDRESS[network].USDC,
         pool.signer
       );
-      expect(poolTokenDelta.gt(0));
+      expect(poolTokenDelta.gt(0)).toBe(true);
+    });
+
+    it("gets available manager fee", async () => {
+      const result = await pool.getAvailableManagerFee();
+      expect(result).toBeDefined();
     });
 
-    //   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));
-    //   });
+    it("withdraws pool tokens", async () => {
+      // Wait for exit cooldown after deposit
+      await provider.send("evm_increaseTime", [24 * 60 * 60]);
+      await provider.send("evm_mine", []);
+      const poolTokenBalance = await dhedge.utils.getBalance(
+        pool.address,
+        wallet.address
+      );
+      expect(poolTokenBalance.gt(0)).toBe(true);
+      await pool.withdraw(poolTokenBalance.div(2).toString());
+      const poolTokenDelta = await balanceDelta(
+        wallet.address,
+        pool.address,
+        pool.signer
+      );
+      expect(poolTokenDelta.lt(0)).toBe(true);
+    });
   });
 };
 
-// testingHelper({
-//   network: Network.POLYGON,
-//   testingRun: testPool
-// });
-
 testingHelper({
-  network: Network.HYPERLIQUID,
+  network: Network.ARBITRUM,
   testingRun: testPool,
-  onFork: false
+  onFork: true
 });

package/src/test/toros.onchain.test.ts

@@ -0,0 +1,92 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+/**
+ * Toros on-chain tests for init and complete withdrawal.
+ * These require a live chain connection (onFork: false) because the
+ * withdrawal swap data from DEX aggregators (KyberSwap/1Inch) only
+ * works against real chain state, not a Hardhat fork.
+ *
+ * Prerequisites:
+ *   - PRIVATE_KEY in .env (must be the pool manager or trader)
+ *   - ARBITRUM_URL in .env
+ *   - The test pool must hold Toros tokens ready for withdrawal
+ *   - Cooldown period must have passed since the last deposit
+ */
+
+import { Dhedge, Pool } from "..";
+
+import { Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT } from "./constants";
+import { getTxOptions } from "./txOptions";
+import { testingHelper, TestingRunParams } from "./utils/testingHelper";
+
+const testTorosOnchain = ({ wallet, network }: TestingRunParams) => {
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const TOROS = CONTRACT_ADDRESS[network].TOROS;
+  const TEST_POOL_ADDRESS = "0x2d4cddd2c4fa854536593bcf61d0da3b63ed80cb";
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(200000);
+
+  describe(`[${network}] toros on-chain withdrawal tests`, () => {
+    beforeAll(async () => {
+      if (!process.env.PRIVATE_KEY || !process.env.ARBITRUM_URL) {
+        console.warn(
+          "Skipping toros on-chain tests: PRIVATE_KEY and ARBITRUM_URL env vars required"
+        );
+        return;
+      }
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL_ADDRESS);
+    });
+
+    it("init Toros Token for withdrawal", async () => {
+      if (!process.env.PRIVATE_KEY || !process.env.ARBITRUM_URL) return;
+      const torosBalanceBefore = await pool.utils.getBalance(
+        TOROS,
+        pool.address
+      );
+      await pool.approve(
+        Dapp.TOROS,
+        TOROS,
+        MAX_AMOUNT,
+        await getTxOptions(network)
+      );
+      const tx = await pool.trade(
+        Dapp.TOROS,
+        TOROS,
+        USDC,
+        torosBalanceBefore,
+        1.5,
+        await getTxOptions(network)
+      );
+      await tx.wait(4);
+      const torosBalanceAfter = await pool.utils.getBalance(
+        TOROS,
+        pool.address
+      );
+      expect(torosBalanceAfter.lt(torosBalanceBefore)).toBe(true);
+    });
+
+    it("complete withdrawal from Toros asset", async () => {
+      if (!process.env.PRIVATE_KEY || !process.env.ARBITRUM_URL) return;
+      const usdcBalanceBefore = await pool.utils.getBalance(USDC, pool.address);
+      const tx = await pool.completeTorosWithdrawal(
+        USDC,
+        1.5,
+        await getTxOptions(network)
+      );
+      await tx.wait(4);
+      const usdcBalanceAfter = await pool.utils.getBalance(USDC, pool.address);
+      expect(usdcBalanceAfter.gt(usdcBalanceBefore)).toBe(true);
+    });
+  });
+};
+
+// Requires live chain — cannot run on fork
+testingHelper({
+  network: Network.ARBITRUM,
+  testingRun: testTorosOnchain,
+  onFork: false
+});