@dhedge/v2-sdk 2.1.4 → 2.1.6

package/src/services/hyperliquid/index.ts

@@ -0,0 +1,176 @@
+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_DEX_ID,
+  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 getPerpToSpotHyperliquidTxData = (
+  dexId: number,
+  receiver: string,
+  amount: ethers.BigNumber | string
+): string => {
+  const coreAmount = ethers.BigNumber.from(amount).mul(100); //USDC on Core has two more decimals
+  //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,
+      dexId,
+      SPOT_DEX_ID,
+      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]);
+};

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/odos/index.ts

@@ -1,10 +1,29 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import axios from "axios";
 import { ApiError, ethers } from "../..";
-import { networkChainIdMap } from "../../config";
+import { networkChainIdMap, OdosSwapFeeRecipient } from "../../config";
 import { Pool } from "../../entities";
+import OdosRouterV3Abi from "../../abi/odos/OdosRouterV3.json";
+import BigNumber from "bignumber.js";
 
-export const odosBaseUrl = "https://api.odos.xyz/sor";
+export const odosBaseUrl = "https://enterprise-api.odos.xyz/sor";
+
+// Types for Odos Router V3 swap function parameters
+export interface SwapTokenInfo {
+  inputToken: string;
+  inputAmount: ethers.BigNumber;
+  inputReceiver: string;
+  outputToken: string;
+  outputQuote: ethers.BigNumber;
+  outputMin: ethers.BigNumber;
+  outputReceiver: string;
+}
+
+export interface SwapReferralInfo {
+  code: ethers.BigNumber;
+  fee: ethers.BigNumber;
+  feeRecipient: string;
+}
 
 export async function getOdosSwapTxData(
   pool: Pool,
@@ -13,13 +32,13 @@ export async function getOdosSwapTxData(
   amountIn: ethers.BigNumber | string,
   slippage: number
 ): Promise<{ swapTxData: string; minAmountOut: 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 referralFeeBips = 2; // 2 basis points = 0.02%
+
   const quoteParams = {
     chainId: networkChainIdMap[pool.network],
     inputTokens: [
@@ -36,12 +55,20 @@ export async function getOdosSwapTxData(
     ],
     slippageLimitPercent: slippage,
     userAddr: pool.address,
-    referralCode
+    compact: false,
+    referralFeeRecipient: OdosSwapFeeRecipient[pool.network],
+    referralFee: referralFeeBips // 0.02% fee
   };
   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 = {
@@ -51,10 +78,67 @@ export async function getOdosSwapTxData(
 
     const assembleResult = await axios.post(
       `${odosBaseUrl}/assemble`,
-      assembleParams
+      assembleParams,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": ODOS_API_KEY
+        }
+      }
     );
+
+    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 {
+        swapTxData: assembleResult.data.transaction.data,
+        minAmountOut: assembleResult.data.outputTokens[0].amount
+      };
+    }
+
+    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 {
-      swapTxData: assembleResult.data.transaction.data,
+      swapTxData: correctedTxData,
       minAmountOut: assembleResult.data.outputTokens[0].amount
     };
   } catch (e) {

package/src/services/toros/completeWithdrawal.ts

@@ -25,7 +25,7 @@ const getSwapWithdrawData = async (
   swapDestMinDestAmount: BigNumber
 ) => {
   const srcData = [];
-  const routerKey = ethers.utils.formatBytes32String("ODOS_V2");
+  const routerKey = ethers.utils.formatBytes32String("ODOS_V3");
   // const destData
   for (const { token, balance } of trackedAssets) {
     if (token.toLowerCase() === receiveToken.toLowerCase()) {

package/src/services/toros/initWithdrawal.ts

@@ -46,7 +46,7 @@ const getAaveAssetWithdrawData = async (
   const { srcData, dstData } = swapDataParams;
 
   const srcDataToEncode: unknown[] = [];
-  const routerKey = ethers.utils.formatBytes32String("ODOS_V2");
+  const routerKey = ethers.utils.formatBytes32String("ODOS_V3");
   for (const { asset, amount } of srcData) {
     const swapData = await retry({
       fn: () => {

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