@dhedge/v2-sdk 2.1.4 → 2.1.6

package/src/services/toros/swapData.ts

@@ -1,6 +1,9 @@
 import axios from "axios";
 import BigNumber from "bignumber.js";
-import { odosBaseUrl } from "../odos";
+import { ethers } from "ethers";
+import { odosBaseUrl, SwapReferralInfo, SwapTokenInfo } from "../odos";
+import { networkChainIdMap, OdosSwapFeeRecipient } from "../../config";
+import OdosRouterV3Abi from "../../abi/odos/OdosRouterV3.json";
 
 export const SWAPPER_ADDERSS = "0x4F754e0F0924afD74980886b0B479Fa1D7C58D0D";
 
@@ -22,13 +25,19 @@ export const getSwapDataViaOdos = async ({
   from,
   slippage
 }: SwapParams): Promise<string> => {
-  let referralCode = 0; //  Defaults to 0 for unregistered activity.
-  if (
-    process.env.ODOS_REFERAL_CODE &&
-    Number(process.env.ODOS_REFERAL_CODE) > 0
-  ) {
-    referralCode = Number(process.env.ODOS_REFERAL_CODE);
+  if (!process.env.ODOS_API_KEY) {
+    throw new Error("ODOS_API_KEY is not set");
   }
+  const ODOS_API_KEY = process.env.ODOS_API_KEY;
+  const network = (Object.keys(networkChainIdMap) as Array<
+    keyof typeof networkChainIdMap
+  >).find(key => networkChainIdMap[key] === chainId);
+  if (!network) {
+    throw new Error(`Unsupported chainId: ${chainId}`);
+  }
+
+  const referralFeeBips = 2; // 2 basis points = 0.02%
+
   const quoteParams = {
     chainId: chainId,
     inputTokens: [
@@ -45,12 +54,20 @@ export const getSwapDataViaOdos = async ({
     ],
     slippageLimitPercent: new BigNumber(slippage).div(100).toString(), // Convert basis points to percentage
     userAddr: from,
-    referralCode
+    referralFee: referralFeeBips, // 0.02% fee
+    referralFeeRecipient: OdosSwapFeeRecipient[network],
+    compact: false
   };
   try {
     const quoteResult = await axios.post(
-      `${odosBaseUrl}/quote/v2`,
-      quoteParams
+      `${odosBaseUrl}/quote/v3`,
+      quoteParams,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": ODOS_API_KEY
+        }
+      }
     );
 
     const assembleParams = {
@@ -60,9 +77,63 @@ export const getSwapDataViaOdos = async ({
 
     const assembleResult = await axios.post(
       `${odosBaseUrl}/assemble`,
-      assembleParams
+      assembleParams,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": ODOS_API_KEY
+        }
+      }
     );
-    return assembleResult.data.transaction.data;
+
+    const txData = assembleResult.data.transaction.data;
+
+    // Decode the transaction data
+    const iface = new ethers.utils.Interface(OdosRouterV3Abi.abi);
+    const decodedData = iface.parseTransaction({ data: txData });
+
+    const tokenInfo = decodedData.args[0] as SwapTokenInfo;
+    const pathDefinition = decodedData.args[1] as string;
+    const executor = decodedData.args[2] as string;
+    const referralInfo = decodedData.args[3] as SwapReferralInfo;
+
+    if (
+      referralInfo.fee.lte(
+        ethers.BigNumber.from((referralFeeBips * 1e18) / 10000)
+      )
+    ) {
+      // Referral fee is already correct, return original txData
+      return txData;
+    }
+
+    const FEE_DENOM = new BigNumber(1e18);
+    const correctedFee = new BigNumber((referralFeeBips * 1e18) / 10000);
+    const factor = 1.1;
+    const correctedOutputQuote = new BigNumber(tokenInfo.outputQuote.toString())
+      .times(
+        FEE_DENOM.minus(correctedFee).div(
+          FEE_DENOM.minus(referralInfo.fee.toString())
+        )
+      )
+      .times(factor);
+
+    // example referralInfo.fee could be 0.0005 * 1e18 = 500000000000000, which is 0.05%
+    // Create corrected referral info
+    const correctedTxData = iface.encodeFunctionData(decodedData.name, [
+      {
+        ...tokenInfo,
+        outputQuote: correctedOutputQuote.toFixed(0)
+      },
+      pathDefinition,
+      executor,
+      {
+        code: referralInfo.code,
+        fee: correctedFee.toFixed(0), // align with referralFeeBips
+        feeRecipient: referralInfo.feeRecipient
+      }
+    ]);
+
+    return correctedTxData;
   } catch (e) {
     console.error("Error in Odos API request:", e);
     throw new Error("Swap api request of Odos failed");

package/src/test/constants.ts

@@ -44,7 +44,8 @@ export const TEST_POOL = {
   [Network.ARBITRUM]: "0x0b5f6591c8eb23e5a68102d3d39ebbb464ee5c14",
   [Network.BASE]: "0x4842b42F68524383F609aa46eAfc18c1459cE3cD",
   [Network.ETHEREUM]: "0xe8e74f664d2d6a919a18b911990db0979789b6f7",
-  [Network.PLASMA]: "0xdad21646ebb0997eb59de1f6a68a67059daf4c31"
+  [Network.PLASMA]: "0xdad21646ebb0997eb59de1f6a68a67059daf4c31",
+  [Network.HYPERLIQUID]: "0x3b4427283148c30b13b33a564264c73443ed12d1"
 };
 
 export const CONTRACT_ADDRESS = {
@@ -171,6 +172,10 @@ export const CONTRACT_ADDRESS = {
     WETH: "0x9895d81bb462a195b4922ed7de0e3acd007c32cb",
     USDT: "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb",
     USDE: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34"
+  },
+  [Network.HYPERLIQUID]: {
+    USDC: "0xb88339cb7199b77e23db6e890353e22632ba630f",
+    WETH: ""
   }
 };
 
@@ -182,7 +187,8 @@ export const USDC_BALANCEOF_SLOT = {
   [Network.POLYGON]: 0,
   [Network.BASE]: 9,
   [Network.ETHEREUM]: 9,
-  [Network.PLASMA]: 9 //Currently no USDC on Plasma
+  [Network.PLASMA]: 9,
+  [Network.HYPERLIQUID]: 9
 };
 
 export const WETH_BALANCEOF_SLOT = {
@@ -191,5 +197,6 @@ export const WETH_BALANCEOF_SLOT = {
   [Network.POLYGON]: 0,
   [Network.BASE]: 0,
   [Network.ETHEREUM]: 3,
-  [Network.PLASMA]: 1
+  [Network.PLASMA]: 1,
+  [Network.HYPERLIQUID]: 1
 };

package/src/test/hyperliquid.test.ts

@@ -0,0 +1,107 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+import { Dhedge, Pool } from "..";
+
+import { Network } from "../types";
+import { TEST_POOL } from "./constants";
+
+import { TestingRunParams, testingHelper } from "./utils/testingHelper";
+
+// import { balanceDelta } from "./utils/token";
+
+const testHyperliquid = ({ wallet, network }: TestingRunParams) => {
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
+
+  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", []);
+      // // top up USDC
+      // await setUSDCAmount({
+      //   amount: new BigNumber(2).times(1e6).toFixed(0),
+      //   userAddress: pool.address,
+      //   network,
+      //   provider
+      // });
+    });
+
+    // it("approves unlimited USDC on Hyperliquid Core Wallet", async () => {
+    //   await pool.approve(
+    //     Dapp.HYPERLIQUID,
+    //     USDC,
+    //     MAX_AMOUNT,
+    //     await getTxOptions(network)
+    //   );
+    //   const usdcAllowanceDelta = await allowanceDelta(
+    //     pool.address,
+    //     USDC,
+    //     routerAddress[network][Dapp.HYPERLIQUID]!,
+    //     pool.signer
+    //   );
+    //   await expect(usdcAllowanceDelta.gt(0));
+    // });
+
+    // it("deposits USDC into Hyperliquid Core Wallet", async () => {
+    //   await pool.depositHyperliquid(
+    //     "30000000", // 5 USDC with 6 decimals,
+    //     4294967295
+    //   );
+    //   expect(
+    //     (await balanceDelta(pool.address, USDC, pool.signer)).eq("-20000000")
+    //   ).toBe(true);
+    // });
+
+    // it("move 5 USDC from Perp to Spot Wallet", async () => {
+    //   const tx = await pool.perpToSpotHyperliquid(
+    //     0,
+    //     "5000000" // 5 USDC with 6 decimals
+    //   );
+    //   expect(tx).toBeDefined();
+    // });
+
+    // it("withdraws USDC from Hyperliquid Spot Wallet", async () => {
+    //   const tx = await pool.withdrawHyperliquid(
+    //     "784577548" // 5 USDC with 6 decimals
+    //   );
+    //   expect(tx).toBeDefined();
+    // });
+
+    // it("sets up a BTC_USDC buy order", async () => {
+    //   const tx = await pool.openMarketOrderHyperliquid(
+    //     10182, // HYPE SPOT
+    //     true, // is long
+    //     25, // 25 USD value of BTC,
+    //     1, // 0.5% slippage,
+    //     null,
+    //     true
+    //   );
+    //   expect(tx).toBeDefined();
+    // });
+
+    it("closes a position on Hyperliquid", async () => {
+      const tx = await pool.closePositionHyperliquid(
+        1, // ETH Perp,
+        50, // percentage to close
+        1, // 0.5% slippage,
+        null,
+        true
+      );
+      expect(tx).toBeDefined();
+    });
+  });
+};
+
+testingHelper({
+  network: Network.HYPERLIQUID,
+  testingRun: testHyperliquid,
+  onFork: false
+});

package/src/test/odos.test.ts

@@ -13,7 +13,7 @@ import {
 import { allowanceDelta, balanceDelta } from "./utils/token";
 import { getTxOptions } from "./txOptions";
 import BigNumber from "bignumber.js";
-import { routerAddress } from "../config";
+import { OdosSwapFeeRecipient, routerAddress } from "../config";
 
 const testOdos = ({ wallet, network, provider }: TestingRunParams) => {
   const USDC = CONTRACT_ADDRESS[network].USDC;
@@ -35,7 +35,7 @@ const testOdos = ({ wallet, network, provider }: TestingRunParams) => {
       await provider.send("evm_mine", []);
       // top up USDC
       await setUSDCAmount({
-        amount: new BigNumber(2).times(1e6).toFixed(0),
+        amount: new BigNumber(20).times(1e6).toFixed(0),
         userAddress: pool.address,
         network,
         provider
@@ -53,12 +53,12 @@ const testOdos = ({ wallet, network, provider }: TestingRunParams) => {
       await expect(usdcAllowanceDelta.gt(0));
     });
 
-    it("gets gas estimation for 2 USDC into WETH on Odos", async () => {
+    it("gets gas estimation for 10 USDC into WETH on Odos", async () => {
       const gasEstimate = await pool.trade(
         Dapp.ODOS,
         USDC,
         WETH,
-        "2000000",
+        "10000000",
         1,
         await getTxOptions(network),
         true
@@ -67,13 +67,13 @@ const testOdos = ({ wallet, network, provider }: TestingRunParams) => {
       expect(gasEstimate.minAmountOut).not.toBeNull();
     });
 
-    it("trades 2 USDC into WETH on Odos", async () => {
+    it("trades 10 USDC into WETH on Odos", async () => {
       await wait(1);
       await pool.trade(
         Dapp.ODOS,
         USDC,
         WETH,
-        "2000000",
+        "10000000",
         0.5,
         await getTxOptions(network)
       );
@@ -83,20 +83,51 @@ const testOdos = ({ wallet, network, provider }: TestingRunParams) => {
         pool.signer
       );
       expect(wethBalanceDelta.gt(0));
+      const wethBalanceDeltaForFeeRecipient = await balanceDelta(
+        OdosSwapFeeRecipient[network],
+        WETH,
+        pool.signer
+      );
+
+      // diffRatio  = (1 - fee) / (0.8 * fee)
+      // 0.8 is the split percentage for fee recipient
+      // e.g. for 0.02% fee, diffRatio = 0.9998 / 0.00016 = 6248.75
+      // e.g. for 0.03% fee, diffRatio = 0.9997 / 0.00024 = 4165.42
+      // e.g. for 0.04% fee, diffRatio = 0.9996 / 0.00032 = 3123.75
+      // e.g. for 0.05% fee, diffRatio = 0.9995 / 0.00040 = 2498.75
+      const diffRatio = wethBalanceDelta.div(wethBalanceDeltaForFeeRecipient);
+      console.log("diff ratio:", diffRatio.toString());
+      expect(diffRatio.gt(6200)).toBe(true);
+      expect(diffRatio.lt(6260)).toBe(true);
+      const wethBalanceDeltaForRouter = await balanceDelta(
+        routerAddress[network]["odos"]!,
+        WETH,
+        pool.signer
+      );
+      // diffRatio  = (1 - fee) / (0.2 * fee)
+      // 0.2 is the split percentage for router
+      // e.g. for 0.02% fee, diffRatio = 0.9998 / 0.00004 = 24995
+      // e.g. for 0.03% fee, diffRatio = 0.9997 / 0.00006 = 16661.67
+      // e.g. for 0.04% fee, diffRatio = 0.9996 / 0.00008 = 12495
+      // e.g. for 0.05% fee, diffRatio = 0.9995 / 0.00010 = 9995
+      const diffRatioRouter = wethBalanceDelta.div(wethBalanceDeltaForRouter);
+      console.log("diff ratio router:", diffRatioRouter.toString());
+      expect(diffRatioRouter.gt(24000)).toBe(true);
+      expect(diffRatioRouter.lt(26000)).toBe(true);
     });
   });
 };
 
-testingHelper({
-  network: Network.OPTIMISM,
-  testingRun: testOdos
-});
-
 // testingHelper({
-//   network: Network.ARBITRUM,
+//   network: Network.OPTIMISM,
 //   testingRun: testOdos
 // });
 
+testingHelper({
+  network: Network.ARBITRUM,
+  testingRun: testOdos
+});
+
 // testingHelper({
 //   network: Network.POLYGON,
 //   onFork: false,

package/src/test/pool.test.ts

@@ -1,12 +1,12 @@
-import { BigNumber } from "ethers";
-import { Dhedge, Pool } from "..";
-import { Network } from "../types";
-import { TEST_POOL } from "./constants";
+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, provider }: TestingRunParams) => {
+const testPool = ({ wallet, network }: TestingRunParams) => {
   let dhedge: Dhedge;
   let pool: Pool;
 
@@ -16,31 +16,26 @@ const testPool = ({ wallet, network, provider }: TestingRunParams) => {
     beforeAll(async () => {
       dhedge = new Dhedge(wallet, network);
       pool = await dhedge.loadPool(TEST_POOL[network]);
-
-      await provider.send("hardhat_setBalance", [
-        wallet.address,
-        "0x10000000000000000"
-      ]);
     });
 
-    it("checks fund composition", async () => {
-      const result = await pool.getComposition();
-      // console.log(result);
-      expect(result.length).toBeGreaterThan(0);
-    });
+    // 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 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);
@@ -51,10 +46,9 @@ const testPool = ({ wallet, network, provider }: TestingRunParams) => {
     //   const assetsBefore = await pool.getComposition();
 
     //   const newAssets: AssetEnabled[] = [
-    //     { asset: CONTRACT_ADDRESS[network].USDT, isDeposit: true },
-    //     { asset: CONTRACT_ADDRESS[network].USDE, isDeposit: true },
+    //     { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
     //     {
-    //       asset: "0x925a2A7214Ed92428B5b1B090F80b25700095e12",
+    //       asset: "0x3333333333333333333333333333333333333333",
     //       isDeposit: false
     //     }
     //   ];
@@ -65,7 +59,7 @@ const testPool = ({ wallet, network, provider }: TestingRunParams) => {
 
     // it("approves USDT balance of User for Deposit", async () => {
     //   await pool.approveDeposit(
-    //     CONTRACT_ADDRESS[network].USDT,
+    //     CONTRACT_ADDRESS[network].USDC,
     //     ethers.constants.MaxUint256
     //   );
     //   const usdtAllowanceDelta = await allowanceDelta(
@@ -77,18 +71,15 @@ const testPool = ({ wallet, network, provider }: TestingRunParams) => {
     //   expect(usdtAllowanceDelta.gt(0));
     // });
 
-    // it("deposits 200 USDT into Pool", async () => {
-    //   await pool.deposit(
-    //     CONTRACT_ADDRESS[network].USDT,
-    //     (200000000).toString()
-    //   );
-    //   const poolTokenDelta = await balanceDelta(
-    //     pool.address,
-    //     USDT,
-    //     pool.signer
-    //   );
-    //   expect(poolTokenDelta.gt(0));
-    // });
+    it("deposits 200 USDT into Pool", async () => {
+      await pool.deposit(CONTRACT_ADDRESS[network].USDC, (30000000).toString());
+      const poolTokenDelta = await balanceDelta(
+        pool.address,
+        CONTRACT_ADDRESS[network].USDC,
+        pool.signer
+      );
+      expect(poolTokenDelta.gt(0));
+    });
 
     //   it("get available Manager Fee", async () => {
     //     const result = await pool.getAvailableManagerFee();
@@ -120,6 +111,7 @@ const testPool = ({ wallet, network, provider }: TestingRunParams) => {
 // });
 
 testingHelper({
-  network: Network.ARBITRUM,
-  testingRun: testPool
+  network: Network.HYPERLIQUID,
+  testingRun: testPool,
+  onFork: false
 });

package/src/test/torosLimitOrder.test.ts

@@ -0,0 +1,130 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+// import { ethers } from "ethers";
+import { Dhedge, Pool } from "..";
+// import { limitOrderAddress } from "../config";
+
+import { Network } from "../types";
+// import { MAX_AMOUNT } from "./constants";
+import { testingHelper, TestingRunParams } from "./utils/testingHelper";
+
+// import { allowanceDelta } from "./utils/token";
+
+// cspell:ignore goldbull
+const TOROS_GOLDBULL2X = "0xc8e7e840ca82804c14061a27aaca1b97a5a592ab";
+// const GOLD_PRICING_ASSET = "0x7624cccCc59361D583F28BEC40D37e7771d2ef5D";
+
+const testTorosLimitOrder = ({ wallet, network }: TestingRunParams) => {
+  // const ORDER_AMOUNT = ethers.utils.parseEther("0.001");
+  // const STOP_LOSS = ethers.utils.parseEther("3000");
+  // const TAKE_PROFIT = ethers.utils.parseEther("6000");
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
+
+  describe(`toros limit order on ${network}`, () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(
+        "0xdd3d575fae102a12aaa086d97c7a8814eff42ebc" // MCP test pool (with GOLDBULL2X)
+      );
+    });
+
+    it("approves Toros vault token for LimitOrderManager", async () => {
+      const tx = await pool.approveTorosLimitOrder(
+        TOROS_GOLDBULL2X,
+        MAX_AMOUNT
+      );
+      await tx.wait(1);
+      const delta = await allowanceDelta(
+        pool.address,
+        TOROS_GOLDBULL2X,
+        limitOrderAddress[network],
+        pool.signer
+      );
+      expect(delta.gt(0)).toBe(true);
+    });
+
+    it("creates a limit order", async () => {
+      const tx = await pool.createTorosLimitOrder(
+        TOROS_GOLDBULL2X,
+        ORDER_AMOUNT,
+        STOP_LOSS,
+        TAKE_PROFIT,
+        GOLD_PRICING_ASSET
+      );
+      await tx.wait(1);
+      const order = await pool.getTorosLimitOrder(
+        pool.address,
+        TOROS_GOLDBULL2X
+      );
+      expect(order).not.toBeNull();
+      expect(order!.amount.eq(ORDER_AMOUNT)).toBe(true);
+      expect(order!.stopLossPriceD18.eq(STOP_LOSS)).toBe(true);
+      expect(order!.takeProfitPriceD18.eq(TAKE_PROFIT)).toBe(true);
+      expect(order!.pool.toLowerCase()).toBe(TOROS_GOLDBULL2X.toLowerCase());
+      expect(order!.pricingAsset.toLowerCase()).toBe(
+        GOLD_PRICING_ASSET.toLowerCase()
+      );
+    });
+
+    it("modifies a toros limit order", async () => {
+      const order = await pool.getTorosLimitOrder(
+        pool.address,
+        TOROS_GOLDBULL2X
+      );
+      if (!order) throw new Error("No existing order found");
+
+      const newStopLoss = order.stopLossPriceD18
+        .mul(90)
+        .div(100)
+        .toString();
+      const newTakeProfit = order.takeProfitPriceD18
+        .mul(110)
+        .div(100)
+        .toString();
+
+      const tx = await pool.modifyTorosLimitOrder(
+        TOROS_GOLDBULL2X,
+        order.amount,
+        newStopLoss,
+        newTakeProfit,
+        order.pricingAsset
+      );
+      await tx.wait(1);
+
+      const modifiedOrder = await pool.getTorosLimitOrder(
+        pool.address,
+        TOROS_GOLDBULL2X
+      );
+      expect(modifiedOrder).not.toBeNull();
+      expect(modifiedOrder!.stopLossPriceD18.toString()).toBe(newStopLoss);
+      expect(modifiedOrder!.takeProfitPriceD18.toString()).toBe(newTakeProfit);
+    });
+
+    it("deletes a toros limit order", async () => {
+      const order = await pool.getTorosLimitOrder(
+        pool.address,
+        TOROS_GOLDBULL2X
+      );
+      if (!order) throw new Error("No existing order found");
+
+      const tx = await pool.deleteTorosLimitOrder(TOROS_GOLDBULL2X);
+      await tx.wait(1);
+
+      const deletedOrder = await pool.getTorosLimitOrder(
+        pool.address,
+        TOROS_GOLDBULL2X
+      );
+      expect(deletedOrder).toBeNull();
+    });
+  });
+};
+
+testingHelper({
+  network: Network.ARBITRUM,
+  testingRun: testTorosLimitOrder,
+  onFork: false
+});

package/src/test/wallet.ts

@@ -9,7 +9,8 @@ export const networkPortMap = {
   [Network.ARBITRUM]: 8540,
   [Network.BASE]: 8546,
   [Network.ETHEREUM]: 8547,
-  [Network.PLASMA]: 8548
+  [Network.PLASMA]: 8548,
+  [Network.HYPERLIQUID]: 8549
 };
 
 export const getWalletData = (

package/src/types.ts

@@ -7,7 +7,8 @@ export enum Network {
   ARBITRUM = "arbitrum",
   BASE = "base",
   ETHEREUM = "ethereum",
-  PLASMA = "plasma"
+  PLASMA = "plasma",
+  HYPERLIQUID = "hyperliquid"
 }
 
 export enum Dapp {
@@ -33,7 +34,8 @@ export enum Dapp {
   COMPOUNDV3 = "compoundV3",
   ODOS = "odos",
   PENDLE = "pendle",
-  KYBERSWAP = "kyberswap"
+  KYBERSWAP = "kyberswap",
+  HYPERLIQUID = "hyperliquid"
 }
 
 export enum Transaction {
@@ -111,3 +113,12 @@ export type SDKOptions =
       useTraderAddressAsFrom?: boolean;
     }
   | boolean; // shorthand for { estimateGas: true/false }; for backward compatibility
+
+export type LimitOrderInfo = {
+  amount: BigNumber;
+  stopLossPriceD18: BigNumber;
+  takeProfitPriceD18: BigNumber;
+  user: string;
+  pool: string;
+  pricingAsset: string;
+};