@dhedge/v2-sdk 2.1.5 → 2.1.7

package/src/entities/pool.ts

@@ -19,7 +19,8 @@ import {
   nonfungiblePositionManagerAddress,
   routerAddress,
   stakingAddress,
-  SYNTHETIX_TRACKING_CODE
+  SYNTHETIX_TRACKING_CODE,
+  limitOrderAddress
 } from "../config";
 import {
   Dapp,
@@ -31,7 +32,8 @@ import {
   LyraOptionType,
   LyraTradeType,
   LyraPosition,
-  SDKOptions
+  SDKOptions,
+  LimitOrderInfo
 } from "../types";
 
 import { Utils } from "./utils";
@@ -57,8 +59,8 @@ import { getLyraOptionTxData } from "../services/lyra/trade";
 import { getOptionPositions } from "../services/lyra/positions";
 import { getDeadline } from "../utils/deadline";
 import {
-  getFuturesChangePositionTxData,
-  getFuturesChangeMarginTxData
+  getFuturesChangeMarginTxData,
+  getFuturesChangePositionTxData
 } from "../services/futures";
 import { getFuturesCancelOrderTxData } from "../services/futures/trade";
 import { getOneInchSwapTxData } from "../services/oneInch";
@@ -86,7 +88,25 @@ import {
 import { getOdosSwapTxData } from "../services/odos";
 import { getPendleMintTxData, getPendleSwapTxData } from "../services/pendle";
 import { getCompleteWithdrawalTxData } from "../services/toros/completeWithdrawal";
+import {
+  getCreateLimitOrderTxData,
+  getModifyLimitOrderTxData,
+  getDeleteLimitOrderTxData,
+  getTorosLimitOrder,
+  hasActiveTorosLimitOrder
+} from "../services/toros/limitOrder";
 import { getKyberSwapTxData } from "../services/kyberSwap";
+import {
+  getClosePositionHyperliquidTxData,
+  getDepositHyperliquidTxData,
+  getLimitOrderHyperliquidTxData,
+  getSendAssetHyperliquidTxData,
+  getWithdrawSpotHyperliquidTxData
+} from "../services/hyperliquid";
+import {
+  CORE_WRITER_ADDRESS,
+  SPOT_DEX_ID
+} from "../services/hyperliquid/constants";
 
 export class Pool {
   public readonly poolLogic: Contract;
@@ -2147,4 +2167,362 @@ export class Pool {
     );
     return tx;
   }
+
+  /** Deposit USDC from EVM to a HyperCore trading dex via the CoreDepositWallet.
+   *  This bridges USDC on-chain to Hyperliquid for perp/spot trading.
+   *
+   * @param {BigNumber | string} amount USDC amount to deposit (6 decimals, e.g. "1000000" = 1 USDC)
+   * @param {number} dexId Destination dex ID where USDC will be available (default 0)
+   *   - 0: Core Perp dex (standard perps like BTC, ETH)
+   *   - 1: xyz HIP-3 dex (builder perps like TSLA, GOLD)
+   * @param {any} options Transaction options
+   * @param {SDKOptions} sdkOptions SDK options including estimateGas
+   * @returns {Promise<any>} Transaction
+   */
+  async depositHyperliquid(
+    amount: BigNumber | string,
+    dexId = 0,
+    options: any = null,
+    sdkOptions: SDKOptions = {
+      estimateGas: false
+    }
+  ): Promise<any> {
+    const tx = await getPoolTxOrGasEstimate(
+      this,
+      [
+        routerAddress[this.network][Dapp.HYPERLIQUID],
+        getDepositHyperliquidTxData(dexId, amount),
+        options
+      ],
+      sdkOptions
+    );
+    return tx;
+  }
+
+  /** Move USDC from a HyperCore trading dex to the Spot wallet.
+   *  Required before calling withdrawHyperliquid() to bridge USDC back to EVM.
+   *
+   * @param {number} dexId Source dex ID where USDC currently sits
+   *   - 0: Core Perp dex (standard perps like BTC, ETH)
+   *   - 1: xyz HIP-3 dex (builder perps like TSLA, GOLD)
+   * @param {BigNumber | string} amount USDC amount to transfer (6 decimals, e.g. "1000000" = 1 USDC)
+   * @param {any} options Transaction options
+   * @param {SDKOptions} sdkOptions SDK options including estimateGas
+   * @returns {Promise<any>} Transaction
+   */
+
+  async perpToSpotHyperliquid(
+    dexId: number,
+    amount: BigNumber | string,
+    options: any = null,
+    sdkOptions: SDKOptions = {
+      estimateGas: false
+    }
+  ): Promise<any> {
+    const tx = await getPoolTxOrGasEstimate(
+      this,
+      [
+        CORE_WRITER_ADDRESS,
+        getSendAssetHyperliquidTxData(dexId, SPOT_DEX_ID, this.address, amount),
+        options
+      ],
+      sdkOptions
+    );
+    return tx;
+  }
+
+  /** Move USDC from HyperCore spot wallet to a trading dex.
+   *
+   * @param {number} dexId Destination dex ID where USDC will be moved to
+   *   - 0: Core Perp dex (standard perps like BTC, ETH)
+   *   - 1: xyz HIP-3 dex (builder perps like TSLA, GOLD)
+   * @param {BigNumber | string} amount USDC amount to transfer (6 decimals, e.g. "1000000" = 1 USDC)
+   * @param {any} options Transaction options
+   * @param {SDKOptions} sdkOptions SDK options including estimateGas
+   * @returns {Promise<any>} Transaction
+   */
+
+  async spotToPerpHyperliquid(
+    dexId: number,
+    amount: BigNumber | string,
+    options: any = null,
+    sdkOptions: SDKOptions = {
+      estimateGas: false
+    }
+  ): Promise<any> {
+    const tx = await getPoolTxOrGasEstimate(
+      this,
+      [
+        CORE_WRITER_ADDRESS,
+        getSendAssetHyperliquidTxData(SPOT_DEX_ID, dexId, this.address, amount),
+        options
+      ],
+      sdkOptions
+    );
+    return tx;
+  }
+
+  /** Withdraw USDC from Hyperliquid Spot wallet back to EVM.
+   *  USDC must be in the Spot wallet first — use perpToSpotHyperliquid() to move it from a trading dex.
+   *
+   * @param {BigNumber | string} amount USDC amount to withdraw (6 decimals, e.g. "1000000" = 1 USDC)
+   * @param {any} options Transaction options
+   * @param {SDKOptions} sdkOptions SDK options including estimateGas
+   * @returns {Promise<any>} Transaction
+   */
+
+  async withdrawHyperliquid(
+    amount: BigNumber | string,
+    options: any = null,
+    sdkOptions: SDKOptions = {
+      estimateGas: false
+    }
+  ): Promise<any> {
+    const tx = await getPoolTxOrGasEstimate(
+      this,
+      [CORE_WRITER_ADDRESS, getWithdrawSpotHyperliquidTxData(amount), options],
+      sdkOptions
+    );
+    return tx;
+  }
+
+  /** Open a market order on Hyperliquid
+   *  @param {number} assetId Asset id
+   * @param {boolean} isLong Long or short (Note: Spot assets only support long positions)
+   * @param {number} value Order value in base asset units (positive for opening/increasing,
+   *        negative for closing/reducing or selling spot)
+   * @param {number } slippage Slippage tolerance in %
+   * @param {any} options Transaction options
+   * @param {SDKOptions} sdkOptions SDK options including estimateGas
+   * @returns {Promise<any>} Transaction
+   */
+  async openMarketOrderHyperliquid(
+    assetId: number,
+    isLong: boolean,
+    value: number,
+    slippage = 0.5,
+    options: any = null,
+    sdkOptions: SDKOptions = {
+      estimateGas: false
+    }
+  ): Promise<any> {
+    const tx = await getPoolTxOrGasEstimate(
+      this,
+      [
+        CORE_WRITER_ADDRESS,
+        await getLimitOrderHyperliquidTxData(assetId, isLong, value, slippage),
+        options
+      ],
+      sdkOptions
+    );
+    return tx;
+  }
+
+  /** Close a position on Hyperliquid
+   *  @param {number} assetId Asset id
+   * @param {number} percentageToClose Percentage of position to close (0-100)
+   * @param {number } slippage Slippage tolerance in %
+   * @param {any} options Transaction options
+   * @param {SDKOptions} sdkOptions SDK options including estimateGas
+   * @returns {Promise<any>} Transaction
+   */
+  async closePositionHyperliquid(
+    assetId: number,
+    percentageToClose = 100,
+    slippage = 0.5,
+    options: any = null,
+    sdkOptions: SDKOptions = {
+      estimateGas: false
+    }
+  ): Promise<any> {
+    const tx = await getPoolTxOrGasEstimate(
+      this,
+      [
+        CORE_WRITER_ADDRESS,
+        await getClosePositionHyperliquidTxData(
+          assetId,
+          percentageToClose,
+          slippage,
+          this.address
+        ),
+        options
+      ],
+      sdkOptions
+    );
+    return tx;
+  }
+
+  /**
+   * Approve the Toros vault token for the PoolLimitOrderManager
+   * Must be called before createTorosLimitOrder
+   * @param {string} vaultAddress Address of the Toros vault token to approve
+   * @param {BigNumber | string} amount Amount to approve
+   * @param {any} options Transaction options
+   * @param {SDKOptions} sdkOptions SDK options including estimateGas
+   * @returns {Promise<any>} Transaction
+   */
+  async approveTorosLimitOrder(
+    vaultAddress: string,
+    amount: BigNumber | string,
+    options: any = null,
+    sdkOptions: SDKOptions = { estimateGas: false }
+  ): Promise<any> {
+    const managerAddress = limitOrderAddress[this.network];
+    const iERC20 = new ethers.utils.Interface(IERC20.abi);
+    const approveTxData = iERC20.encodeFunctionData("approve", [
+      managerAddress,
+      amount
+    ]);
+    return getPoolTxOrGasEstimate(
+      this,
+      [vaultAddress, approveTxData, options],
+      sdkOptions
+    );
+  }
+
+  /**
+   * Create a Toros limit order (stop-loss / take-profit)
+   * @param {string} vaultAddress Address of the Toros vault token
+   * @param {BigNumber | string} amount Vault token amount (18 decimals)
+   * @param {BigNumber | string | null | undefined} stopLossPriceD18 Stop-loss price in D18 (0 or null/undefined = disabled)
+   * @param {BigNumber | string | null | undefined} takeProfitPriceD18 Take-profit price in D18 (MaxUint256 or null/undefined = disabled)
+   * @param {string} pricingAsset Address of the pricing asset (e.g. USDC)
+   * @param {any} options Transaction options
+   * @param {SDKOptions} sdkOptions SDK options including estimateGas
+   * @returns {Promise<any>} Transaction
+   */
+  async createTorosLimitOrder(
+    vaultAddress: string,
+    amount: BigNumber | string,
+    stopLossPriceD18: BigNumber | string | null | undefined,
+    takeProfitPriceD18: BigNumber | string | null | undefined,
+    pricingAsset: string,
+    options: any = null,
+    sdkOptions: SDKOptions = { estimateGas: false }
+  ): Promise<any> {
+    const managerAddress = limitOrderAddress[this.network];
+    if (!managerAddress) {
+      throw new Error(`Limit orders not supported on ${this.network}`);
+    }
+    const resolvedStopLoss =
+      stopLossPriceD18 == null
+        ? BigNumber.from(0)
+        : BigNumber.from(stopLossPriceD18);
+    const resolvedTakeProfit =
+      takeProfitPriceD18 == null
+        ? ethers.constants.MaxUint256
+        : BigNumber.from(takeProfitPriceD18);
+    const info: LimitOrderInfo = {
+      amount: BigNumber.from(amount),
+      stopLossPriceD18: resolvedStopLoss,
+      takeProfitPriceD18: resolvedTakeProfit,
+      user: this.address,
+      pool: vaultAddress,
+      pricingAsset
+    };
+    const txData = getCreateLimitOrderTxData(info);
+    return getPoolTxOrGasEstimate(
+      this,
+      [managerAddress, txData, options],
+      sdkOptions
+    );
+  }
+
+  /**
+   * Modify an existing Toros limit order
+   * @param {string} vaultAddress Address of the Toros vault token
+   * @param {BigNumber | string} amount New vault token amount (18 decimals)
+   * @param {BigNumber | string | null | undefined} stopLossPriceD18 New stop-loss price in D18 (0 or null/undefined = disabled)
+   * @param {BigNumber | string | null | undefined} takeProfitPriceD18 New take-profit price in D18 (MaxUint256 or null/undefined = disabled)
+   * @param {string} pricingAsset Address of the pricing asset
+   * @param {any} options Transaction options
+   * @param {SDKOptions} sdkOptions SDK options including estimateGas
+   * @returns {Promise<any>} Transaction
+   */
+  async modifyTorosLimitOrder(
+    vaultAddress: string,
+    amount: BigNumber | string,
+    stopLossPriceD18: BigNumber | string | null | undefined,
+    takeProfitPriceD18: BigNumber | string | null | undefined,
+    pricingAsset: string,
+    options: any = null,
+    sdkOptions: SDKOptions = { estimateGas: false }
+  ): Promise<any> {
+    const managerAddress = limitOrderAddress[this.network];
+    if (!managerAddress) {
+      throw new Error(`Limit orders not supported on ${this.network}`);
+    }
+    const resolvedStopLoss =
+      stopLossPriceD18 == null
+        ? BigNumber.from(0)
+        : BigNumber.from(stopLossPriceD18);
+    const resolvedTakeProfit =
+      takeProfitPriceD18 == null
+        ? ethers.constants.MaxUint256
+        : BigNumber.from(takeProfitPriceD18);
+    const info: LimitOrderInfo = {
+      amount: BigNumber.from(amount),
+      stopLossPriceD18: resolvedStopLoss,
+      takeProfitPriceD18: resolvedTakeProfit,
+      user: this.address,
+      pool: vaultAddress,
+      pricingAsset
+    };
+    const txData = getModifyLimitOrderTxData(info);
+    return getPoolTxOrGasEstimate(
+      this,
+      [managerAddress, txData, options],
+      sdkOptions
+    );
+  }
+
+  /**
+   * Delete an existing Toros limit order
+   * @param {string} vaultAddress Address of the Toros vault token
+   * @param {any} options Transaction options
+   * @param {SDKOptions} sdkOptions SDK options including estimateGas
+   * @returns {Promise<any>} Transaction
+   */
+  async deleteTorosLimitOrder(
+    vaultAddress: string,
+    options: any = null,
+    sdkOptions: SDKOptions = { estimateGas: false }
+  ): Promise<any> {
+    const managerAddress = limitOrderAddress[this.network];
+    if (!managerAddress) {
+      throw new Error(`Limit orders not supported on ${this.network}`);
+    }
+    const txData = getDeleteLimitOrderTxData(vaultAddress);
+    return getPoolTxOrGasEstimate(
+      this,
+      [managerAddress, txData, options],
+      sdkOptions
+    );
+  }
+
+  /**
+   * Fetch a Toros limit order for a given user and vault
+   * @param {string} userAddress Address of the order owner (the dHEDGE pool)
+   * @param {string} vaultAddress Address of the Toros vault token
+   * @returns {Promise<LimitOrderInfo | null>} Order info, or null if none exists
+   */
+  async getTorosLimitOrder(
+    userAddress: string,
+    vaultAddress: string
+  ): Promise<LimitOrderInfo | null> {
+    return getTorosLimitOrder(this, userAddress, vaultAddress);
+  }
+
+  /**
+   * Check whether an active Toros limit order exists for a given user and vault
+   * @param {string} userAddress Address of the order owner (the dHEDGE pool)
+   * @param {string} vaultAddress Address of the Toros vault token
+   * @returns {Promise<boolean>}
+   */
+  async hasActiveTorosLimitOrder(
+    userAddress: string,
+    vaultAddress: string
+  ): Promise<boolean> {
+    return hasActiveTorosLimitOrder(this, userAddress, vaultAddress);
+  }
 }

package/src/services/hyperliquid/constants.ts

@@ -0,0 +1,23 @@
+export const USDC_TOKEN_ID = 0;
+export const USDC_CORE_ADDRESS = "0x2000000000000000000000000000000000000000";
+export const CORE_WRITER_ADDRESS = "0x3333333333333333333333333333333333333333";
+export const PERP_DEX_ID = 0;
+export const SPOT_DEX_ID = 4294967295; // max uint32;
+export const HYPERLIQUID_VERSION = 1;
+
+//Action IDs
+export const SPOT_SEND_ACTION = 6;
+export const SEND_ASSET_ACTION = 13;
+export const LIMIT_ORDER_ACTION = 1;
+
+//Order Time In Force options
+export const LIMIT_ORDER_TIF_ALO = 1;
+export const LIMIT_ORDER_TIF_GTC = 2;
+export const LIMIT_ORDER_TIF_IOC = 3;
+
+export const dexIdNameMap: { [key: number]: string } = {
+  0: "",
+  1: "xyz"
+};
+
+export const API_URL = "https://api.hyperliquid.xyz/info";

package/src/services/hyperliquid/index.ts

@@ -0,0 +1,178 @@
+import { ethers } from "ethers";
+import ICoreDepositWalletAbi from "../../abi/hyperliquid/ICoreDepositWallet.json";
+import ICoreWriterAbi from "../../abi/hyperliquid/ICoreWriter.json";
+import {
+  HYPERLIQUID_VERSION,
+  LIMIT_ORDER_ACTION,
+  LIMIT_ORDER_TIF_IOC,
+  SEND_ASSET_ACTION,
+  SPOT_SEND_ACTION,
+  USDC_CORE_ADDRESS,
+  USDC_TOKEN_ID
+} from "./constants";
+
+import {
+  calculatePrice,
+  calculateSize,
+  getAssetInfo,
+  getMidPrice,
+  isSpotAsset,
+  scaleSize
+} from "./marketData";
+import { getPositionSize } from "./positionData";
+
+const depositWallet = new ethers.utils.Interface(ICoreDepositWalletAbi);
+const coreWriter = new ethers.utils.Interface(ICoreWriterAbi);
+
+export const getDepositHyperliquidTxData = (
+  dexId: number,
+  amount: ethers.BigNumber | string
+): string => {
+  return depositWallet.encodeFunctionData("deposit", [amount, dexId]);
+};
+
+export const getWithdrawSpotHyperliquidTxData = (
+  amount: ethers.BigNumber | string
+): string => {
+  const coreAmount = ethers.BigNumber.from(amount).mul(100); //USDC on Core has two more decimals
+  //Hardcoded to USDC address and id on Hyperliquid Core
+  //From Spot to EVM
+  const innerEncoded = ethers.utils.defaultAbiCoder.encode(
+    //to, token, amount
+    ["address", "uint64", "uint64"],
+    [USDC_CORE_ADDRESS, USDC_TOKEN_ID, coreAmount]
+  );
+
+  const rawTXData = ethers.utils.solidityPack(
+    ["uint8", "uint24", "bytes"],
+    [HYPERLIQUID_VERSION, SPOT_SEND_ACTION, innerEncoded]
+  );
+  return coreWriter.encodeFunctionData("sendRawAction", [rawTXData]);
+};
+export const getSendAssetHyperliquidTxData = (
+  sourceDex: number,
+  destinationDex: number,
+  receiver: string,
+  amount: ethers.BigNumber | string
+): string => {
+  // Convert 6-decimal EVM USDC to 8-decimal HyperCore USDC (spot, main perp, and xyz)
+  // Transfer USDC between dexes (perp, spot, xyz)
+  const coreAmount = ethers.BigNumber.from(amount).mul(100);
+  //From Perp to Spot
+  const innerEncoded = ethers.utils.defaultAbiCoder.encode(
+    //destination, subAccount, sourceDex, destinationDex, token, amount
+    ["address", "address", "uint32", "uint32", "uint64", "uint64"],
+    [
+      receiver,
+      ethers.constants.AddressZero,
+      sourceDex,
+      destinationDex,
+      USDC_TOKEN_ID,
+      coreAmount
+    ]
+  );
+
+  const rawTXData = ethers.utils.solidityPack(
+    ["uint8", "uint24", "bytes"],
+    [HYPERLIQUID_VERSION, SEND_ASSET_ACTION, innerEncoded]
+  );
+
+  return coreWriter.encodeFunctionData("sendRawAction", [rawTXData]);
+};
+
+export const getLimitOrderHyperliquidTxData = async (
+  assetId: number,
+  isLong: boolean,
+  changeAmount: number,
+  slippage: number
+): Promise<string> => {
+  let isBuy = isLong;
+  let reduceOnly = false;
+  if (changeAmount < 0) {
+    changeAmount = changeAmount * -1;
+    isBuy = !isLong;
+    reduceOnly = !isSpotAsset(assetId);
+  }
+
+  //Calculate price with slippage
+  const { assetName, szDecimals } = await getAssetInfo(assetId);
+  const midPrice = await getMidPrice(assetId, assetName);
+  const price = calculatePrice(
+    isSpotAsset(assetId),
+    szDecimals,
+    midPrice,
+    isBuy,
+    slippage
+  );
+  const size = calculateSize(szDecimals, changeAmount, midPrice);
+
+  const innerEncoded = ethers.utils.defaultAbiCoder.encode(
+    //assetIndex, isBuy, price, size, reduceOnly, tif, clientOrderId
+    ["uint32", "bool", "uint64", "uint64", "bool", "uint8", "uint128"],
+    [
+      assetId,
+      isBuy,
+      price,
+      size,
+      reduceOnly,
+      LIMIT_ORDER_TIF_IOC, // immediate or cancel
+      ethers.BigNumber.from(0) //client order id
+    ]
+  );
+
+  const rawTXData = ethers.utils.solidityPack(
+    ["uint8", "uint24", "bytes"],
+    [HYPERLIQUID_VERSION, LIMIT_ORDER_ACTION, innerEncoded]
+  );
+
+  return coreWriter.encodeFunctionData("sendRawAction", [rawTXData]);
+};
+
+export const getClosePositionHyperliquidTxData = async (
+  assetId: number,
+  percentageToClose: number,
+  slippage: number,
+  poolAddress: string
+): Promise<string> => {
+  const isSpot = isSpotAsset(assetId);
+  const { assetName, szDecimals, baseTokenName } = await getAssetInfo(assetId);
+  const positionSize = await getPositionSize(
+    assetId,
+    isSpot,
+    baseTokenName ?? assetName,
+    poolAddress
+  );
+  const isBuy = positionSize < 0; // if position size is negative, we need to buy to close, otherwise sell
+  const sizeRaw = scaleSize(szDecimals, positionSize, percentageToClose);
+
+  //Calculate price with slippage
+  const midPrice = await getMidPrice(assetId, assetName);
+  const price = calculatePrice(
+    isSpotAsset(assetId),
+    szDecimals,
+    midPrice,
+    isBuy,
+    slippage
+  );
+
+  const innerEncoded = ethers.utils.defaultAbiCoder.encode(
+    //assetIndex, isBuy, price, size, reduceOnly, tif, clientOrderId
+    ["uint32", "bool", "uint64", "uint64", "bool", "uint8", "uint128"],
+    [
+      assetId,
+      positionSize < 0, // if position size is negative, we need to buy to close, otherwise sell
+      price,
+      sizeRaw,
+      !isSpot,
+      LIMIT_ORDER_TIF_IOC, // immediate or cancel
+      ethers.BigNumber.from(0) //client order id
+    ]
+  );
+
+  const rawTXData = ethers.utils.solidityPack(
+    ["uint8", "uint24", "bytes"],
+    [HYPERLIQUID_VERSION, LIMIT_ORDER_ACTION, innerEncoded]
+  );
+
+  return coreWriter.encodeFunctionData("sendRawAction", [rawTXData]);
+};