@dhedge/v2-sdk 2.1.8 → 2.2.1

package/src/test/cowswap.test.ts

@@ -1,12 +1,26 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
+/**
+ * CowSwap tests require a live chain connection (onFork: false).
+ * CowSwap orders are settled off-chain by solvers, so they cannot
+ * be tested on a Hardhat fork. Run with a funded wallet and
+ * PRIVATE_KEY + POLYGON_URL set in .env.
+ *
+ * Flow: approve CoW vault relayer → trade
+ * Note: estimateGas and onlyGetTxData are not supported for CowSwap
+ * because it requires two sequential transactions (submit + preSign).
+ */
+
 import { Dhedge, Pool } from "..";
 
 import { Dapp, Network } from "../types";
-import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
 import { getTxOptions } from "./txOptions";
 import { TestingRunParams, testingHelper } from "./utils/testingHelper";
-import { balanceDelta } from "./utils/token";
+import { allowanceDelta, balanceDelta } from "./utils/token";
+
+// CoW Protocol Vault Relayer — must be approved before CowSwap trades
+const COWSWAP_VAULT_RELAYER = "0xC92E8bdf79f0507f65a392b0ab4667716BFE0110";
 
 const testCowswap = ({ wallet, network }: TestingRunParams) => {
   const USDC = CONTRACT_ADDRESS[network].USDC;
@@ -16,44 +30,27 @@ const testCowswap = ({ wallet, network }: TestingRunParams) => {
   let pool: Pool;
   jest.setTimeout(100000);
 
-  describe(`pool on ${network}`, () => {
+  describe(`[${network}] cowswap tests`, () => {
     beforeAll(async () => {
       dhedge = new Dhedge(wallet, network);
       pool = await dhedge.loadPool(TEST_POOL[network]);
     });
 
-    // it("approves unlimited USDC on Cowswap", async () => {
-    //   await pool.approveSpender(
-    //     "0xC92E8bdf79f0507f65a392b0ab4667716BFE0110", //Vault relayer
-    //     USDC,
-    //     MAX_AMOUNT,
-    //     await getTxOptions(network)
-    //   );
-    //   const usdcAllowanceDelta = await allowanceDelta(
-    //     pool.address,
-    //     USDC,
-    //     "0xC92E8bdf79f0507f65a392b0ab4667716BFE0110", //Vault relayer
-    //     pool.signer
-    //   );
-    //   await expect(usdcAllowanceDelta.gt(0).toBe(true));
-    // });
-
-    // it("gets gas estimation for 2 USDC into WETH on Cowswap", async () => {
-    //   const gasEstimate = await pool.trade(
-    //     Dapp.COWSWAP,
-    //     USDC,
-    //     WETH,
-    //     "2000000",
-    //     1,
-    //     await getTxOptions(network),
-    //     true
-    //   );
-    //   console.log(
-    //     "Gas estimate for trading 2 USDC to WETH on Cowswap:",
-    //     gasEstimate
-    //   );
-    //   expect(gasEstimate.minAmountOut).not.toBeNull();
-    // });
+    it("approves unlimited USDC on Cowswap vault relayer", async () => {
+      await pool.approveSpender(
+        COWSWAP_VAULT_RELAYER,
+        USDC,
+        MAX_AMOUNT,
+        await getTxOptions(network)
+      );
+      const usdcAllowanceDelta = await allowanceDelta(
+        pool.address,
+        USDC,
+        COWSWAP_VAULT_RELAYER,
+        pool.signer
+      );
+      expect(usdcAllowanceDelta.gt(0)).toBe(true);
+    });
 
     it("trades 2 USDC into WETH on Cowswap", async () => {
       await pool.trade(
@@ -74,6 +71,7 @@ const testCowswap = ({ wallet, network }: TestingRunParams) => {
   });
 };
 
+// CowSwap requires live chain — cannot run on fork
 testingHelper({
   network: Network.POLYGON,
   testingRun: testCowswap,

package/src/test/dhedge.test.ts

@@ -1,32 +1,65 @@
 import { Dhedge } from "..";
 import { Network } from "../types";
+import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
+import {
+  testingHelper,
+  TestingRunParams,
+  beforeAfterReset
+} from "./utils/testingHelper";
 
-import { testingHelper, TestingRunParams } from "./utils/testingHelper";
-
-const testDhedge = ({ wallet, network }: TestingRunParams) => {
+const testDhedge = ({ wallet, network, provider }: TestingRunParams) => {
   let dhedge: Dhedge;
 
   jest.setTimeout(200000);
 
   describe(`dHEDGE on ${network}`, () => {
     beforeAll(async () => {
+      // Fund the test wallet with gas
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
       dhedge = new Dhedge(wallet, network);
     });
 
-    it("create a pool", async () => {
-      const pool = await dhedge.createPool("Test", "Test", "TEST", [
-        ["0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34", true],
-        ["0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb", false],
-        ["0x925a2A7214Ed92428B5b1B090F80b25700095e12", false]
-      ]);
-      console.log(pool.address);
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    it("creates a pool with USDC and WETH", async () => {
+      const pool = await dhedge.createPool(
+        "Test Manager",
+        "Test Fund",
+        "TEST",
+        [
+          [CONTRACT_ADDRESS[network].USDC, true],
+          [CONTRACT_ADDRESS[network].WETH, false]
+        ]
+      );
+      expect(pool.address).toBeDefined();
       expect(pool.poolLogic.address).toBe(pool.address);
     });
+
+    it("loads an existing pool", async () => {
+      const pool = await dhedge.loadPool(TEST_POOL[network]);
+      expect(pool.address).toBe(TEST_POOL[network]);
+      expect(pool.poolLogic.address).toBe(TEST_POOL[network]);
+    });
+
+    it("validates a real pool address", async () => {
+      const isValid = await dhedge.validatePool(TEST_POOL[network]);
+      expect(isValid).toBe(true);
+    });
+
+    it("rejects an invalid pool address", async () => {
+      const isValid = await dhedge.validatePool(
+        "0x0000000000000000000000000000000000000001"
+      );
+      expect(isValid).toBe(false);
+    });
   });
 };
 
 testingHelper({
-  network: Network.PLASMA,
-  onFork: false,
+  network: Network.ARBITRUM,
+  onFork: true,
   testingRun: testDhedge
 });

package/src/test/flatmoney.test.ts

@@ -1,7 +1,6 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import BigNumber from "bignumber.js";
 import { Dhedge, Pool } from "../entities";
-import { AssetEnabled, Network } from "../types";
+import { Network } from "../types";
 import {
   TestingRunParams,
   runWithImpersonateAccount,
@@ -12,7 +11,6 @@ import { Contract, ethers } from "ethers";
 import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
 import { flatMoneyContractAddresses } from "../config";
 import DelayedOrderAbi from "../abi/flatmoney/DelayedOrder.json";
-import { allowanceDelta } from "./utils/token";
 import { getKeeperFee } from "../services/flatmoney/keeperFee";
 
 const COLLATERAL_SLOT = 0; // same for RETH(base) and WBTC(optimism)
@@ -32,19 +30,15 @@ const testFlatMoney = ({
   let delayOrderContract: Contract;
   let COLLATERAL: string;
   jest.setTimeout(200000);
+  // FlatMoney's OracleModule reverts with ETHPriceStale() when the forked block's
+  // Chainlink ETH/USD price is older than maxAge. Re-run the fork before this suite
+  // so the oracle timestamp is fresh (there is no helper to override maxAge here).
   describe(`flatmoney on ${network}`, () => {
     beforeAll(async () => {
       await provider.send("evm_mine", []);
       dhedge = new Dhedge(wallet, network);
       pool = await dhedge.loadPool(TEST_POOL[network]);
 
-      await runWithImpersonateAccount(
-        { provider, account: await pool.managerLogic.manager() },
-        async ({ signer }) => {
-          await pool.managerLogic.connect(signer).setTrader(wallet.address);
-        }
-      );
-
       const flatMoneyContracts = flatMoneyContractAddresses[pool.network];
       if (!flatMoneyContracts) {
         throw new Error("testFlatMoney: network not supported");
@@ -56,7 +50,20 @@ const testFlatMoney = ({
         pool.signer
       );
 
-      // top up gas
+      await runWithImpersonateAccount(
+        { provider, account: await pool.managerLogic.manager() },
+        async ({ signer }) => {
+          await pool.managerLogic.connect(signer).setTrader(wallet.address);
+          await pool.managerLogic.connect(signer).changeAssets(
+            [
+              [COLLATERAL, false],
+              [CONTRACT_ADDRESS[network].UNIT, false]
+            ],
+            []
+          );
+        }
+      );
+
       await provider.send("hardhat_setBalance", [
         wallet.address,
         "0x10000000000000000"
@@ -77,45 +84,24 @@ const testFlatMoney = ({
         slot: UNIT_SLOT,
         userAddress: pool.address
       });
-
-      const currentAssets: any[] = await pool.managerLogic.getSupportedAssets();
-      const exisitingAssets = currentAssets.map(item => {
-        return {
-          asset: item[0],
-          isDeposit: item[1]
-        };
-      });
-
-      const newAssets: AssetEnabled[] = [
-        ...exisitingAssets,
-        { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
-        { asset: CONTRACT_ADDRESS[network].WETH, isDeposit: true },
-        {
-          asset: CONTRACT_ADDRESS[network].UNIT,
-          isDeposit: false
-        },
-        {
-          asset: COLLATERAL,
-          isDeposit: false
-        }
-      ];
-      await pool.changeAssets(newAssets);
     });
 
     it("mint UNIT", async () => {
-      //approve
       await pool.approveSpender(
         delayOrderContract.address,
         COLLATERAL,
         MAX_AMOUNT
       );
-      const collateralAllowanceDelta = await allowanceDelta(
-        pool.address,
+      const iERC20 = new ethers.Contract(
         COLLATERAL,
-        delayOrderContract.address,
+        ["function allowance(address,address) view returns (uint256)"],
         pool.signer
       );
-      await expect(collateralAllowanceDelta.gt(0));
+      const collateralAllowance = await iERC20.allowance(
+        pool.address,
+        delayOrderContract.address
+      );
+      expect(collateralAllowance.gt(0)).toBe(true);
 
       const depositAmountStr = new BigNumber(1).times(1e18).toString();
       const estimateData = await pool.mintUnitViaFlatMoney(

package/src/test/fluid.test.ts

@@ -1,19 +1,20 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import BigNumber from "bignumber.js";
+import { ethers } from "ethers";
 import { Dhedge, Pool } from "..";
-import { AssetEnabled, Network } from "../types";
+import { Network } from "../types";
 import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
 import {
   TestingRunParams,
   beforeAfterReset,
   setWETHAmount,
+  runWithImpersonateAccount,
   testingHelper
 } from "./utils/testingHelper";
-import { allowanceDelta, balanceDelta } from "./utils/token";
-import { getWalletData } from "./wallet";
+import { balanceDelta } from "./utils/token";
 
-const testFluid = ({ network, provider }: TestingRunParams) => {
+const testFluid = ({ wallet, network, provider }: TestingRunParams) => {
   const WETH = CONTRACT_ADDRESS[network].WETH;
   const FLUID_WETH = CONTRACT_ADDRESS[network].FLUID_WETH;
 
@@ -21,16 +22,15 @@ const testFluid = ({ network, provider }: TestingRunParams) => {
   let pool: Pool;
   jest.setTimeout(100000);
 
-  describe(`[${network}] compound V3 tests`, () => {
+  describe(`[${network}] fluid tests`, () => {
     beforeAll(async () => {
-      const { wallet } = getWalletData(network);
-      // 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]);
+
       await setWETHAmount({
         amount: new BigNumber(1e18).toFixed(0),
         userAddress: pool.address,
@@ -38,26 +38,31 @@ const testFluid = ({ network, provider }: TestingRunParams) => {
         provider
       });
 
-      const newAssets: AssetEnabled[] = [
-        { asset: WETH, isDeposit: true },
-        {
-          asset: FLUID_WETH,
-          isDeposit: false
+      // Impersonate 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 = [
+            [WETH, true],
+            [FLUID_WETH, false]
+          ];
+          await pool.managerLogic.connect(signer).changeAssets(newAssets, []);
         }
-      ];
-      await pool.managerLogic.changeAssets(newAssets, []);
+      );
     });
     beforeAfterReset({ beforeAll, afterAll, provider });
 
     it("approves unlimited WETH for fWETH market", async () => {
-      await pool.approveSpender(FLUID_WETH, WETH, MAX_AMOUNT);
-      const wethAllowanceDelta = await allowanceDelta(
-        pool.address,
+      const tx = await pool.approveSpender(FLUID_WETH, WETH, MAX_AMOUNT);
+      await tx.wait(1);
+      const iERC20 = new ethers.Contract(
         WETH,
-        FLUID_WETH,
+        ["function allowance(address,address) view returns (uint256)"],
         pool.signer
       );
-      await expect(wethAllowanceDelta.gt(0));
+      const wethAllowance = await iERC20.allowance(pool.address, FLUID_WETH);
+      expect(wethAllowance.gt(0)).toBe(true);
     });
 
     it("lends WETH to Fluid WETH market", async () => {
@@ -69,17 +74,21 @@ const testFluid = ({ network, provider }: TestingRunParams) => {
         FLUID_WETH,
         pool.signer
       );
-      expect(fWETHTokenDelta.gt(0));
+      expect(fWETHTokenDelta.gt(0)).toBe(true);
     });
 
-    it("withdraw WETH from Fluid WETH market", async () => {
+    it("withdraws WETH from Fluid WETH market", async () => {
       const fWETHBalance = await pool.utils.getBalance(
         FLUID_WETH,
         pool.address
       );
       await pool.withdrawCompoundV3(FLUID_WETH, WETH, fWETHBalance);
-      const wethBalance = await balanceDelta(pool.address, WETH, pool.signer);
-      expect(wethBalance.gt(0));
+      const wethBalanceDelta = await balanceDelta(
+        pool.address,
+        WETH,
+        pool.signer
+      );
+      expect(wethBalanceDelta.gt(0)).toBe(true);
     });
   });
 };

package/src/test/hyperliquid.onchain.test.ts

@@ -0,0 +1,131 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+/**
+ * Hyperliquid on-chain tests for deposit/withdraw/perp-spot/open/close flows.
+ * These require a live chain connection (onFork: false) because Hyperliquid
+ * precompile and CoreWriter state cannot be faithfully forked.
+ *
+ * Prerequisites:
+ *   - PRIVATE_KEY in .env (must be the pool manager or trader)
+ *   - HYPERLIQUID_URL in .env
+ *   - The test pool must hold USDC and an existing ETH perp position
+ *   - Spot wallet must hold the amount expected by the withdraw test
+ */
+
+import { ethers } from "ethers";
+import { Dhedge, Pool } from "..";
+
+import { Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import { routerAddress } from "../config";
+import { getTxOptions } from "./txOptions";
+
+import { TestingRunParams, testingHelper } from "./utils/testingHelper";
+
+const testHyperliquid = ({ wallet, network }: TestingRunParams) => {
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(200000);
+
+  describe(`pool on ${network}`, () => {
+    beforeAll(async () => {
+      if (!process.env.PRIVATE_KEY || !process.env.HYPERLIQUID_URL) {
+        console.warn(
+          "Skipping hyperliquid on-chain tests: PRIVATE_KEY and HYPERLIQUID_URL env vars required"
+        );
+        return;
+      }
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+    });
+
+    it("approves unlimited USDC on Hyperliquid Core Wallet", async () => {
+      if (!process.env.PRIVATE_KEY || !process.env.HYPERLIQUID_URL) return;
+      const tx = await pool.approve(
+        Dapp.HYPERLIQUID,
+        USDC,
+        MAX_AMOUNT,
+        await getTxOptions(network)
+      );
+      await tx.wait(1);
+      const iERC20 = new ethers.Contract(
+        USDC,
+        ["function allowance(address,address) view returns (uint256)"],
+        pool.signer
+      );
+      const allowance = await iERC20.allowance(
+        pool.address,
+        routerAddress[network][Dapp.HYPERLIQUID]!
+      );
+      expect(allowance.gt(0)).toBe(true);
+    });
+
+    it("deposits 30 USDC into Hyperliquid Core Wallet", async () => {
+      if (!process.env.PRIVATE_KEY || !process.env.HYPERLIQUID_URL) return;
+      const usdcBefore = await pool.utils.getBalance(USDC, pool.address);
+      const tx = await pool.depositHyperliquid(
+        "30000000", // 30 USDC (6 decimals)
+        4294967295,
+        await getTxOptions(network)
+      );
+      await tx.wait(1);
+      const usdcAfter = await pool.utils.getBalance(USDC, pool.address);
+      expect(usdcBefore.sub(usdcAfter).eq("30000000")).toBe(true);
+    });
+
+    it("moves 5 USDC from Perp (dex 0) to Spot wallet", async () => {
+      if (!process.env.PRIVATE_KEY || !process.env.HYPERLIQUID_URL) return;
+      const tx = await pool.perpToSpotHyperliquid(
+        0,
+        "5000000", // 5 USDC (6 decimals)
+        await getTxOptions(network)
+      );
+      await tx.wait(1);
+      expect(tx).toBeDefined();
+    });
+
+    it("withdraws USDC from Hyperliquid Spot Wallet", async () => {
+      if (!process.env.PRIVATE_KEY || !process.env.HYPERLIQUID_URL) return;
+      const tx = await pool.withdrawHyperliquid(
+        "784577548", // 784.577548 USDC (6 decimals)
+        await getTxOptions(network)
+      );
+      await tx.wait(1);
+      expect(tx).toBeDefined();
+    });
+
+    it("opens a XAUT0 spot buy order", async () => {
+      if (!process.env.PRIVATE_KEY || !process.env.HYPERLIQUID_URL) return;
+      const tx = await pool.openMarketOrderHyperliquid(
+        10182, // XAUT0/USDC spot asset id (10000 + spot index 182)
+        true, // long
+        25, // $25 notional
+        1, // 1% slippage
+        await getTxOptions(network)
+      );
+      await tx.wait(1);
+      expect(tx).toBeDefined();
+    });
+
+    it("closes 50% of ETH perp position", async () => {
+      if (!process.env.PRIVATE_KEY || !process.env.HYPERLIQUID_URL) return;
+      const tx = await pool.closePositionHyperliquid(
+        1, // ETH Perp asset id
+        50, // 50% to close
+        1, // 1% slippage
+        await getTxOptions(network)
+      );
+      await tx.wait(1);
+      expect(tx).toBeDefined();
+    });
+  });
+};
+
+// Requires live chain — cannot run on fork
+testingHelper({
+  network: Network.HYPERLIQUID,
+  testingRun: testHyperliquid,
+  onFork: false
+});

package/src/test/kyberSwap.test.ts

@@ -1,19 +1,22 @@
 /* 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 {
   TestingRunParams,
+  fixOracleAggregatorStaleness,
+  runWithImpersonateAccount,
+  setChainlinkTimeout,
   setUSDCAmount,
   testingHelper,
   wait
 } from "./utils/testingHelper";
-
-import { allowanceDelta, balanceDelta } from "./utils/token";
-import { routerAddress } from "../config";
-import BigNumber from "bignumber.js";
+import { balanceDelta } from "./utils/token";
 
 const testKyberSwap = ({ wallet, network, provider }: TestingRunParams) => {
   const USDC = CONTRACT_ADDRESS[network].USDC;
@@ -25,15 +28,30 @@ const testKyberSwap = ({ wallet, network, provider }: TestingRunParams) => {
 
   describe(`kyberswap 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", []);
-      // top up USDC
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+
+      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 setUSDCAmount({
         amount: new BigNumber(2).times(1e6).toFixed(0),
         userAddress: pool.address,
@@ -44,13 +62,16 @@ const testKyberSwap = ({ wallet, network, provider }: TestingRunParams) => {
 
     it("approves unlimited USDC on KyberSwap", async () => {
       await pool.approve(Dapp.KYBERSWAP, USDC, MAX_AMOUNT);
-      const usdcAllowanceDelta = await allowanceDelta(
-        pool.address,
+      const iERC20 = new ethers.Contract(
         USDC,
-        routerAddress[network]["kyberswap"]!,
+        ["function allowance(address,address) view returns (uint256)"],
         pool.signer
       );
-      await expect(usdcAllowanceDelta.gt(0));
+      const usdcAllowance = await iERC20.allowance(
+        pool.address,
+        routerAddress[network][Dapp.KYBERSWAP]!
+      );
+      expect(usdcAllowance.gt(0)).toBe(true);
     });
 
     it("gets only amount and txData for 2 USDC into WETH on KyberSwap", async () => {
@@ -77,7 +98,7 @@ const testKyberSwap = ({ wallet, network, provider }: TestingRunParams) => {
         WETH,
         pool.signer
       );
-      expect(wethBalanceDelta.gt(0));
+      expect(wethBalanceDelta.gt(0)).toBe(true);
     });
   });
 };
@@ -96,11 +117,11 @@ testingHelper({
 // testingHelper({
 //   network: Network.POLYGON,
 //   onFork: false,
-//   testingRun: testOdos
+//   testingRun: testKyberSwap
 // });
 
 // testingHelper({
 //   network: Network.BASE,
 //   onFork: false,
-//   testingRun: testOdos
+//   testingRun: testKyberSwap
 // });