@dhedge/v2-sdk 2.1.5 → 2.1.7

package/src/services/hyperliquid/marketData.ts

@@ -0,0 +1,157 @@
+import axios from "axios";
+import { API_URL, dexIdNameMap } from "./constants";
+import { BigNumber } from "bignumber.js";
+import { ApiError } from "../..";
+
+export const perpDexIndex = (assetId: number): number => {
+  return Math.max(Math.floor((assetId - 100000) / 10000), 0);
+};
+
+const assetIndex = (assetId: number): number => {
+  if (assetId > 100000) {
+    //builder-deployed perps
+    return (assetId - 100000) % 10000;
+  } else return assetId;
+};
+
+export const spotAssetIndex = (assetId: number): number => {
+  return assetId - 10000;
+};
+
+export const isSpotAsset = (assetId: number): boolean => {
+  return assetId > 10000 && assetId < 100000;
+};
+
+export const getMidPrice = async (
+  assetId: number,
+  assetName: string
+): Promise<number> => {
+  const response = await axios.post(API_URL, {
+    type: "allMids",
+    dex: dexIdNameMap[perpDexIndex(assetId)]
+  });
+  const raw = response.data[assetName];
+  if (raw === undefined || raw === null) {
+    throw new ApiError(
+      `Hyperliquid allMids response missing price for asset "${assetName}"`
+    );
+  }
+  const price = +raw;
+  if (isNaN(price)) {
+    throw new ApiError(
+      `Hyperliquid allMids returned non-numeric price for asset "${assetName}": ${raw}`
+    );
+  }
+  return price;
+};
+
+export const getAssetInfo = async (
+  assetId: number
+): Promise<{
+  assetName: string;
+  szDecimals: number;
+  baseTokenName?: string;
+}> => {
+  if (isSpotAsset(assetId)) {
+    const response = await axios.post(API_URL, {
+      type: "spotMeta"
+    });
+    const asset = response.data.universe.find(
+      (e: { index: number }) => e.index === spotAssetIndex(assetId)
+    );
+    if (!asset) {
+      throw new ApiError(
+        `Hyperliquid spotMeta response contains no asset for assetId ${assetId} (index ${spotAssetIndex(
+          assetId
+        )})`
+      );
+    }
+    const baseToken = response.data.tokens[asset.tokens[0]];
+    return {
+      assetName: asset.name,
+      szDecimals: baseToken.szDecimals,
+      baseTokenName: baseToken.name
+    };
+  } else {
+    const dex = dexIdNameMap[perpDexIndex(assetId)];
+    const response = await axios.post(API_URL, {
+      type: "metaAndAssetCtxs",
+      dex
+    });
+    if (!Array.isArray(response.data) || response.data.length === 0) {
+      throw new ApiError(
+        `Hyperliquid metaAndAssetCtxs response has invalid data for assetId ${assetId} (dex ${String(
+          dex
+        )})`
+      );
+    }
+    const meta = response.data[0];
+    if (!meta || !Array.isArray(meta.universe)) {
+      throw new ApiError(
+        `Hyperliquid metaAndAssetCtxs response contains no universe for assetId ${assetId} (dex ${String(
+          dex
+        )})`
+      );
+    }
+    const assets = meta.universe;
+    const index = assetIndex(assetId);
+    if (index < 0 || index >= assets.length) {
+      throw new ApiError(
+        `Hyperliquid metaAndAssetCtxs response contains no asset for assetId ${assetId} (dex ${String(
+          dex
+        )}, index ${index}, universe length ${assets.length})`
+      );
+    }
+    const asset = assets[index];
+    return {
+      assetName: asset.name,
+      szDecimals: asset.szDecimals
+    };
+  }
+};
+
+export const calculatePrice = (
+  isSpotAsset: boolean,
+  szDecimals: number,
+  midPrice: number,
+  isBuy: boolean,
+  slippage: number
+): string => {
+  // 1. Apply slippage
+  const price = midPrice * (isBuy ? 1 + slippage / 100 : 1 - slippage / 100);
+
+  // 2. Round to 5 significant figures
+  const roundedSignificant = parseFloat(price.toPrecision(5));
+
+  // 3. For perp base decimals = 6
+  const baseDecimals = isSpotAsset ? 8 : 6;
+  const finalDecimals = baseDecimals - szDecimals;
+  const factor = Math.pow(10, finalDecimals);
+  const roundedDecimals = Math.round(roundedSignificant * factor) / factor;
+  return new BigNumber(roundedDecimals).times(1e8).toFixed(0);
+};
+
+export const calculateSize = (
+  szDecimals: number,
+  value: number,
+  price: number
+): string => {
+  const factor = Math.pow(10, szDecimals);
+  return new BigNumber(Math.round((value / price) * factor) / factor)
+    .times(1e8)
+    .toFixed(0);
+};
+
+export const scaleSize = (
+  szDecimals: number,
+  positionSize: number,
+  percentageToClose: number
+): string => {
+  const factor = Math.pow(10, szDecimals);
+  return new BigNumber(
+    Math.round(((positionSize * percentageToClose) / 100) * factor) / factor
+  )
+    .times(1e8)
+    .abs()
+    .toFixed(0);
+};

package/src/services/hyperliquid/positionData.ts

@@ -0,0 +1,33 @@
+import axios from "axios";
+import { API_URL, dexIdNameMap } from "./constants";
+import { perpDexIndex } from "./marketData";
+
+export const getPositionSize = async (
+  assetId: number,
+  isSpot: boolean,
+  assetName: string,
+  user: string
+): Promise<number> => {
+  if (isSpot) {
+    const response = await axios.post(API_URL, {
+      type: "spotClearinghouseState",
+      user
+    });
+    const balance = response.data.balances.find(
+      (e: { coin: string }) => e.coin === assetName
+    );
+    if (!balance) throw new Error(`No balance found for asset ${assetName}`);
+    return +balance.total;
+  } else {
+    const response = await axios.post(API_URL, {
+      type: "clearinghouseState",
+      user,
+      dex: dexIdNameMap[perpDexIndex(assetId)]
+    });
+    const position = response.data.assetPositions.find(
+      (e: { position: { coin: string } }) => e.position.coin === assetName
+    );
+    if (!position) throw new Error(`No position found for asset ${assetName}`);
+    return +position.position.szi;
+  }
+};

package/src/services/toros/limitOrder.ts

@@ -0,0 +1,86 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ethers } from "ethers";
+import { Pool } from "../..";
+import { limitOrderAddress } from "../../config";
+import { LimitOrderInfo } from "../../types";
+import IPoolLimitOrderManager from "../../abi/toros/IPoolLimitOrderManager.json";
+
+const iface = new ethers.utils.Interface(IPoolLimitOrderManager);
+
+export function getLimitOrderId(
+  userAddress: string,
+  vaultAddress: string
+): string {
+  return ethers.utils.solidityKeccak256(
+    ["address", "address"],
+    [userAddress, vaultAddress]
+  );
+}
+
+export function getCreateLimitOrderTxData(info: LimitOrderInfo): string {
+  return iface.encodeFunctionData("createLimitOrder", [
+    [
+      info.amount,
+      info.stopLossPriceD18,
+      info.takeProfitPriceD18,
+      info.user,
+      info.pool,
+      info.pricingAsset
+    ]
+  ]);
+}
+
+export function getModifyLimitOrderTxData(info: LimitOrderInfo): string {
+  return iface.encodeFunctionData("modifyLimitOrder", [
+    [
+      info.amount,
+      info.stopLossPriceD18,
+      info.takeProfitPriceD18,
+      info.user,
+      info.pool,
+      info.pricingAsset
+    ]
+  ]);
+}
+
+export function getDeleteLimitOrderTxData(vaultAddress: string): string {
+  return iface.encodeFunctionData("deleteLimitOrder", [vaultAddress]);
+}
+
+export async function getTorosLimitOrder(
+  pool: Pool,
+  userAddress: string,
+  vaultAddress: string
+): Promise<LimitOrderInfo | null> {
+  const managerAddress = limitOrderAddress[pool.network];
+  if (!managerAddress) return null;
+
+  const orderId = getLimitOrderId(userAddress, vaultAddress);
+  const contract = new ethers.Contract(
+    managerAddress,
+    IPoolLimitOrderManager,
+    pool.signer
+  );
+
+  const result = await contract.limitOrders(orderId);
+  // If amount is zero, the order doesn't exist
+  if (result.amount.isZero()) return null;
+
+  return {
+    amount: result.amount,
+    stopLossPriceD18: result.stopLossPriceD18,
+    takeProfitPriceD18: result.takeProfitPriceD18,
+    user: result.user,
+    pool: result.pool,
+    pricingAsset: result.pricingAsset
+  };
+}
+
+export async function hasActiveTorosLimitOrder(
+  pool: Pool,
+  userAddress: string,
+  vaultAddress: string
+): Promise<boolean> {
+  const order = await getTorosLimitOrder(pool, userAddress, vaultAddress);
+  return order !== null;
+}

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 = {
@@ -170,8 +171,11 @@ export const CONTRACT_ADDRESS = {
     USDC: "",
     WETH: "0x9895d81bb462a195b4922ed7de0e3acd007c32cb",
     USDT: "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb",
-    USDE: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34",
-    TOROS: ""
+    USDE: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34"
+  },
+  [Network.HYPERLIQUID]: {
+    USDC: "0xb88339cb7199b77e23db6e890353e22632ba630f",
+    WETH: ""
   }
 };
 
@@ -183,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 = {
@@ -192,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/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 = (