@dhedge/v2-sdk 2.1.7 → 2.2.0

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

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