@lifi/perps-sdk-provider-hyperliquid 15.0.0 → 17.0.0

package/src/services/getAccount.ts

@@ -11,17 +11,18 @@ import type {
   Asset,
   Balance,
   HyperliquidAccountConfig,
+  HyperliquidDexAccountState,
   Position,
 } from '@lifi/perps-types'
-import Big from 'big.js'
+import type Big from 'big.js'
 import { PROVIDER_KEY } from '../constants.js'
 import type { HyperliquidContext } from '../context.js'
-import {
+import type {
   HlAbstractionMode,
-  type HlClearinghouseState,
-  type HlExtraAgents,
-  type HlSpotClearinghouseState,
-  type HlUserFees,
+  HlClearinghouseState,
+  HlExtraAgents,
+  HlSpotClearinghouseState,
+  HlUserFees,
 } from '../types/index.js'
 import { isUnifiedAbstraction } from '../utils/abstractionMode.js'
 import { toWireBig } from '../utils/decimal.js'
@@ -29,9 +30,11 @@ import {
   assetIsOutcome,
   partitionSpotBalances,
   perpsDexNames,
+  perpsTotals,
   spotAssetFromToken,
   spotBalance,
   spotPriceById,
+  sumUnrealizedPnl,
 } from '../utils/index.js'
 import { hlInfoOptions, infoRequest } from '../utils/infoClient.js'
 import { isOpenAssetPosition, mapPosition } from '../utils/mapPosition.js'
@@ -49,45 +52,14 @@ export type GetAccountParams = ProviderGetAccountParams
 const getAccountValue = (state: HlClearinghouseState): Big =>
   toWireBig(state.marginSummary.accountValue, 'marginSummary.accountValue')
 
-const getTotalMarginUsed = (state: HlClearinghouseState): Big =>
-  toWireBig(
-    state.marginSummary.totalMarginUsed,
-    'marginSummary.totalMarginUsed'
-  )
-
-const getMarginUsed = (
-  abstraction: HlAbstractionMode | null,
-  positions: Position[],
-  stateByDex: Map<string, HlClearinghouseState>
-): string => {
-  if (
-    abstraction === HlAbstractionMode.UNIFIED_ACCOUNT ||
-    abstraction === HlAbstractionMode.PORTFOLIO_MARGIN
-  ) {
-    // Per HL docs, individual per-dex states are not meaningful for these
-    // modes; derive total margin from the already-mapped positions.
-    const total = positions.reduce(
-      (sum, position) =>
-        sum.plus(toWireBig(position.marginUsed, 'positions.marginUsed')),
-      new Big(0)
-    )
-    return total.toFixed()
-  }
-
-  if (abstraction === HlAbstractionMode.DEX_ABSTRACTION) {
-    let total = new Big(0)
-    for (const [, state] of stateByDex) {
-      total = total.plus(getTotalMarginUsed(state))
-    }
-    return total.toFixed()
-  }
-
-  const mainState = stateByDex.get('')
-  if (!mainState) {
-    return '0'
-  }
-  return getTotalMarginUsed(mainState).toFixed()
-}
+/** Venue buying power for the quote asset the perps dex settles in. */
+const getAvailableAfterMaintenance = (
+  spotState: HlSpotClearinghouseState,
+  quoteAssetId: string | undefined
+): string | undefined =>
+  spotState.tokenToAvailableAfterMaintenance.find(
+    ([token]) => String(token) === quoteAssetId
+  )?.[1]
 
 interface BalancePartition {
   balances: Balance[]
@@ -106,8 +78,7 @@ const buildBalances = (
     spotState.balances
       .filter((b) => !assetIsOutcome(b.coin))
       .map((b) => spotBalance(spotAssetFromToken(b), b.total, priceById)),
-    quoteAssetIds,
-    abstraction === HlAbstractionMode.PORTFOLIO_MARGIN
+    quoteAssetIds
   )
 
   // Unified/portfolio modes hold everything in spot — per-dex equity would
@@ -238,15 +209,29 @@ export const getAccount = async (
     stateByDex.set(dexNames[i], state)
   })
 
-  const totalUnrealizedPnl = positions.reduce(
-    (sum, p) => sum + Number.parseFloat(p.unrealizedPnl),
-    0
+  const dexStates: HyperliquidDexAccountState[] = stateResults.map(
+    (state, i) => ({
+      dex: dexNames[i],
+      marginSummary: state.marginSummary,
+      crossMarginSummary: state.crossMarginSummary,
+      crossMaintenanceMarginUsed: state.crossMaintenanceMarginUsed,
+      withdrawable: state.withdrawable,
+    })
   )
 
   const config: HyperliquidAccountConfig = {
     provider: PROVIDER_KEY,
     abstractionMode: abstractionResult,
     agents: agentsResult,
+    dexStates,
+    ...(isUnifiedAbstraction(abstractionResult)
+      ? {
+          availableAfterMaintenance: getAvailableAfterMaintenance(
+            spotState,
+            quoteAssetByCategory.get(PROVIDER_KEY)?.id
+          ),
+        }
+      : {}),
   }
 
   const { balances, collateralBalances } = buildBalances(
@@ -264,8 +249,8 @@ export const getAccount = async (
     balances,
     collateralBalances,
     positions,
-    marginUsed: getMarginUsed(abstractionResult, positions, stateByDex),
-    unrealizedPnl: totalUnrealizedPnl.toString(),
+    marginUsed: perpsTotals(dexStates).marginUsed.toFixed(),
+    unrealizedPnl: sumUnrealizedPnl(positions).toFixed(),
     feeTier: {
       maker: feesResult.userAddRate ?? '0',
       taker: feesResult.userCrossRate ?? '0',

package/src/services/getAvailableToTrade.ts

@@ -0,0 +1,72 @@
+import {
+  getMarketRegistry,
+  PerpsError,
+  type SDKRequestOptions,
+  toAssetDisplay,
+} from '@lifi/perps-sdk'
+import type { AvailableToTrade } from '@lifi/perps-types'
+import { PerpsErrorCode } from '@lifi/perps-types'
+import type { Address } from 'viem'
+import { PROVIDER_KEY, SPOT_MARKET_ID } from '../constants.js'
+import type { HyperliquidContext } from '../context.js'
+import { fetchActiveAssetData } from './activeAssetData.js'
+
+/**
+ * Parameters for {@link getAvailableToTrade}.
+ *
+ * @public
+ */
+export interface GetAvailableToTradeParams {
+  address: Address
+  marketId: string
+}
+
+/**
+ * The amounts the account can still buy and sell on one perps market, read
+ * from `activeAssetData`. The amounts are denominated in the market's margin
+ * asset: USDC on the main dex, and the dex margin asset on a builder-deployed
+ * dex. Resolves `undefined` for a spot market, which carries no such state.
+ *
+ * @throws {PerpsError} On an unknown market, an `availableToTrade` payload
+ *   that is not a buy/sell pair, Hyperliquid REST error, network, or parsing
+ *   failures.
+ * @public
+ */
+export const getAvailableToTrade = async (
+  context: HyperliquidContext,
+  params: GetAvailableToTradeParams,
+  options?: SDKRequestOptions
+): Promise<AvailableToTrade | undefined> => {
+  const registry = getMarketRegistry(context.client, PROVIDER_KEY)
+  await registry.sync()
+  const market = registry.require(params.marketId)
+  if (market.categoryId === SPOT_MARKET_ID) {
+    return undefined
+  }
+  const data = await fetchActiveAssetData(
+    context,
+    params.address,
+    params.marketId,
+    options
+  )
+  // The wire type states the pair; nothing verifies the response, so read it
+  // as a plain list to keep the length check in reach of the type checker.
+  const amounts: readonly string[] = data.availableToTrade
+  if (amounts.length !== 2) {
+    const err = new PerpsError(
+      PerpsErrorCode.ValidationError,
+      `Hyperliquid returned ${amounts.length} availableToTrade amounts for market '${params.marketId}'. Expected a buy amount and a sell amount.`
+    )
+    err.tool = PROVIDER_KEY
+    throw err
+  }
+  // Hyperliquid orders the pair buy-side first, sell-side second.
+  const [buy, sell] = amounts
+  return {
+    providerId: market.providerId,
+    marketId: market.id,
+    asset: toAssetDisplay(market.quoteAsset),
+    buy,
+    sell,
+  }
+}

package/src/services/getMarketSettings.ts

@@ -7,8 +7,7 @@ import {
 import type { Address } from 'viem'
 import { SPOT_MARKET_ID } from '../constants.js'
 import type { HyperliquidContext } from '../context.js'
-import type { HlActiveAssetData } from '../types/index.js'
-import { hlInfoOptions, infoRequest } from '../utils/infoClient.js'
+import { fetchActiveAssetData } from './activeAssetData.js'
 
 /**
  * Parameters for {@link getMarketSettings}.
@@ -27,7 +26,7 @@ export interface GetMarketSettingsParams {
  * @public
  */
 export const getMarketSettings = async (
-  { client, apiUrl }: HyperliquidContext,
+  context: HyperliquidContext,
   params: GetMarketSettingsParams,
   options?: SDKRequestOptions
 ): Promise<MarketSettings | undefined> => {
@@ -35,14 +34,11 @@ export const getMarketSettings = async (
   if (params.market.categoryId === SPOT_MARKET_ID) {
     return undefined
   }
-  const data = await infoRequest<HlActiveAssetData>(
-    apiUrl,
-    {
-      type: 'activeAssetData',
-      user: params.address,
-      coin: params.market.marketId,
-    },
-    hlInfoOptions(client, options)
+  const data = await fetchActiveAssetData(
+    context,
+    params.address,
+    params.market.marketId,
+    options
   )
   const leverage = data.leverage
   if (!leverage) {

package/src/services/getOrder.ts

@@ -12,6 +12,7 @@ import type {
   HlOrderStatusResponse,
   HlTwapHistoryEntry,
 } from '../types/index.js'
+import { withExplorerLinks } from '../utils/explorer.js'
 import { assetIsOutcome, mapOrder } from '../utils/index.js'
 import { hlInfoOptions, infoRequest } from '../utils/infoClient.js'
 
@@ -47,17 +48,18 @@ export const getOrder = async (
     throw err
   }
 
+  const infoOpts = hlInfoOptions(client, options)
   const status = await infoRequest<HlOrderStatusResponse>(
     apiUrl,
     { type: 'orderStatus', user: params.address, oid },
-    hlInfoOptions(client, options)
+    infoOpts
   )
 
   if (status.status !== 'order') {
     const history = await infoRequest<HlTwapHistoryEntry[]>(
       apiUrl,
       { type: 'twapHistory', user: params.address },
-      hlInfoOptions(client, options)
+      infoOpts
     )
     const twap = history.find(
       (entry) =>
@@ -81,5 +83,10 @@ export const getOrder = async (
 
   const registry = getMarketRegistry(client, PROVIDER_KEY)
   await registry.sync()
-  return mapOrder(status.order, registry.require(status.order.order.coin))
+  const order = mapOrder(
+    status.order,
+    registry.require(status.order.order.coin)
+  )
+  const [linked] = await withExplorerLinks([order], params.address, infoOpts)
+  return linked
 }

package/src/services/getOrders.ts

@@ -1,8 +1,6 @@
 import {
   ACTIVE_ORDER_STATUSES,
   createWarnOnce,
-  ExplorerChainId,
-  explorerTxUrl,
   getMarketRegistry,
   isActiveOrderStatus,
   type MarketRegistry,
@@ -14,34 +12,21 @@ import type { MarketDisplay, Order, OrdersResponse } from '@lifi/perps-types'
 import { PROVIDER_KEY } from '../constants.js'
 import type { HyperliquidContext } from '../context.js'
 import type {
-  HlExplorerTx,
   HlFrontendOpenOrders,
   HlHistoricalOrders,
   HlTwapHistoryEntry,
 } from '../types/index.js'
-import {
-  assetIsOutcome,
-  fetchUserTransactions,
-  mapOrder,
-  matchOrderActionHash,
-  perpsDexNames,
-} from '../utils/index.js'
-import {
-  hlInfoOptions,
-  type InfoRequestOptions,
-  infoRequest,
-} from '../utils/infoClient.js'
+import { withExplorerLinks } from '../utils/explorer.js'
+import { assetIsOutcome, mapOrder, perpsDexNames } from '../utils/index.js'
+import { hlInfoOptions, infoRequest } from '../utils/infoClient.js'
 
 /** Parameters for a lifecycle-filtered Hyperliquid order read. */
 export type GetOrdersParams = ProviderGetOrdersParams
 
 const warn = createWarnOnce()
 
-const warnOnce = (key: string, detail?: string): void => {
-  warn(
-    key,
-    `[${PROVIDER_KEY}] ${detail === undefined ? key : `${key}: ${detail}`}`
-  )
+const warnOnce = (key: string): void => {
+  warn(key, `[${PROVIDER_KEY}] ${key}`)
 }
 
 /**
@@ -73,42 +58,6 @@ const mapRow = (
   }
 }
 
-/**
- * Set `explorerLink` on each row whose placement transaction the explorer
- * window still holds. One explorer read serves the whole page, and it is
- * skipped when no row carries a client order id to match on. The link is
- * supplementary, so an explorer failure warns and leaves the rows unlinked
- * instead of failing the order read.
- */
-const withExplorerLinks = async (
-  orders: Order[],
-  address: string,
-  options: InfoRequestOptions
-): Promise<Order[]> => {
-  if (!orders.some((order) => order.clientOrderId !== undefined)) {
-    return orders
-  }
-  let txs: HlExplorerTx[]
-  try {
-    txs = await fetchUserTransactions(address, options)
-  } catch (error) {
-    if (!(error instanceof PerpsError)) {
-      throw error
-    }
-    // The message stays out of the key: a transport failure names hosts and
-    // ports, so keying on it would let the dedupe set grow without bound.
-    warnOnce('explorer link lookup failed', error.message)
-    return orders
-  }
-  return orders.map((order) => {
-    const explorerLink = explorerTxUrl(
-      ExplorerChainId.HYPERLIQUID,
-      matchOrderActionHash(txs, order)
-    )
-    return explorerLink === undefined ? order : { ...order, explorerLink }
-  })
-}
-
 /** Read regular, trigger, and TWAP orders from the requested lifecycle feeds. */
 export const getOrders = async (
   { client, apiUrl }: HyperliquidContext,

package/src/services/getWithdrawableBalances.ts

@@ -0,0 +1,94 @@
+import {
+  getMarketRegistry,
+  getProviders,
+  PerpsError,
+  type ProviderGetWithdrawableBalancesParams,
+  type ProviderWithdrawableBalance,
+  type SDKRequestOptions,
+} from '@lifi/perps-sdk'
+import { PerpsErrorCode } from '@lifi/perps-types'
+import { MAIN_MARKET_ID, PROVIDER_KEY } from '../constants.js'
+import type { HyperliquidContext } from '../context.js'
+import type {
+  HlAbstractionMode,
+  HlClearinghouseState,
+  HlSpotClearinghouseState,
+} from '../types/index.js'
+import { hlInfoOptions, infoRequest } from '../utils/infoClient.js'
+import { hyperliquidWithdrawableBalances } from '../utils/withdrawableBalances.js'
+
+/**
+ * Parameters for {@link getWithdrawableBalances}.
+ *
+ * @public
+ */
+export type GetWithdrawableBalancesParams =
+  ProviderGetWithdrawableBalancesParams
+
+/**
+ * The `(asset, route)` pairs `params.address` can withdraw from Hyperliquid,
+ * read from the venue's own `withdrawable` and spot `total`/`hold` figures.
+ * Hyperliquid charges its flat withdrawal fee in USDC, so the backend's
+ * `withdrawalFeeUsd` is the fee in quote-asset units on every USDC row.
+ *
+ * Only the main perps dex is read: a withdrawal to L1 draws on that account,
+ * and a sub-dex balance reaches it through a transfer first.
+ *
+ * @throws {PerpsError} On Hyperliquid REST or backend `/providers` error,
+ * network, or parsing failures, and `SDKError` when the market registry
+ * carries no main perps market to name the quote asset.
+ * @public
+ */
+export const getWithdrawableBalances = async (
+  { client, apiUrl }: HyperliquidContext,
+  params: GetWithdrawableBalancesParams,
+  options?: SDKRequestOptions
+): Promise<ProviderWithdrawableBalance[]> => {
+  const registry = getMarketRegistry(client, PROVIDER_KEY)
+  const infoOpts = hlInfoOptions(client, options)
+
+  const [{ providers }, markets, abstraction, state, spotState] =
+    await Promise.all([
+      getProviders(client, options),
+      registry.sync(),
+      infoRequest<HlAbstractionMode | null>(
+        apiUrl,
+        { type: 'userAbstraction', user: params.address },
+        infoOpts
+      ),
+      infoRequest<HlClearinghouseState>(
+        apiUrl,
+        { type: 'clearinghouseState', user: params.address },
+        infoOpts
+      ),
+      infoRequest<HlSpotClearinghouseState>(
+        apiUrl,
+        { type: 'spotClearinghouseState', user: params.address },
+        infoOpts
+      ),
+    ])
+
+  const quoteAsset = markets.find(
+    (market) => market.categoryId === MAIN_MARKET_ID
+  )?.quoteAsset
+  if (quoteAsset === undefined) {
+    const error = new PerpsError(
+      PerpsErrorCode.SDKError,
+      `Hyperliquid market registry carries no '${MAIN_MARKET_ID}' market to name the withdrawal quote asset`
+    )
+    error.tool = PROVIDER_KEY
+    throw error
+  }
+
+  const feeUsd = providers.find(
+    (provider) => provider.key === PROVIDER_KEY
+  )?.withdrawalFeeUsd
+
+  return hyperliquidWithdrawableBalances(
+    abstraction,
+    state,
+    spotState,
+    quoteAsset.id,
+    feeUsd === undefined ? undefined : String(feeUsd)
+  )
+}

package/src/types/account.ts

@@ -51,6 +51,19 @@ export type HlAssetPosition = {
   position: HlPosition
 }
 
+/**
+ * Margin totals block of a Hyperliquid clearinghouse state. Monetary fields
+ * are decimal strings in the account's quote asset.
+ * @public
+ */
+export type HlMarginSummary = {
+  /** Total equity: locked margin and unrealized PnL included. */
+  accountValue: string
+  totalNtlPos: string
+  totalRawUsd: string
+  totalMarginUsed: string
+}
+
 /**
  * Perpetual clearinghouse account state returned by Hyperliquid `/info`.
  * `assetPositions` includes zero-size rows that callers may discard. Monetary
@@ -60,14 +73,10 @@ export type HlAssetPosition = {
  */
 export type HlClearinghouseState = {
   assetPositions: HlAssetPosition[]
-  marginSummary: {
-    accountValue: string
-    totalMarginUsed: string
-  }
-  crossMarginSummary: {
-    accountValue: string
-    totalMarginUsed: string
-  }
+  marginSummary: HlMarginSummary
+  crossMarginSummary: HlMarginSummary
+  crossMaintenanceMarginUsed: string
+  withdrawable: string
 }
 
 /**
@@ -90,6 +99,11 @@ export type HlSpotBalance = {
  */
 export type HlSpotClearinghouseState = {
   balances: HlSpotBalance[]
+  /**
+   * Venue buying power per spot token, as `[token index, amount]` pairs.
+   * The venue reports the amount after maintenance margin.
+   */
+  tokenToAvailableAfterMaintenance: [number, string][]
 }
 
 /**

package/src/types/ws.ts

@@ -184,6 +184,18 @@ export type HlWsUserFillsData = {
   fills: HlUserFill[]
 }
 
+/**
+ * One sub-dex slice of an `allDexsClearinghouseState` frame. `marginSummary`
+ * is absent on a frame that reports positions only, so a reader must treat it
+ * as optional.
+ * @public
+ */
+export type HlWsDexClearinghouseState = Pick<
+  HlClearinghouseState,
+  'assetPositions'
+> &
+  Partial<Pick<HlClearinghouseState, 'marginSummary'>>
+
 /**
  * Per-dex clearinghouse event for one user. Each tuple contains a wire DEX name
  * and the perp positions/equity fields supplied by that DEX.
@@ -191,14 +203,15 @@ export type HlWsUserFillsData = {
  */
 export type HlWsAllDexsClearinghouseStateData = {
   user: string
-  clearinghouseStates: [
-    string,
-    Pick<HlClearinghouseState, 'assetPositions' | 'marginSummary'>,
-  ][]
+  clearinghouseStates: [string, HlWsDexClearinghouseState][]
 }
 
 /** User spot clearinghouse event containing the current spot balances. @public */
 export type HlWsSpotStateData = {
   user: string
-  spotState: { balances: HlSpotBalance[] }
+  spotState: {
+    balances: HlSpotBalance[]
+    /** Absent on some frames; the REST `spotClearinghouseState` read covers it. */
+    tokenToAvailableAfterMaintenance?: [number, string][]
+  }
 }

package/src/utils/abstractionMode.ts

@@ -6,7 +6,7 @@ import { HlAbstractionMode } from '../types/account.js'
  * per-dex, apart from the spot balances.
  */
 export const isUnifiedAbstraction = (
-  abstraction: HlAbstractionMode | null
+  abstraction: HlAbstractionMode | string | null
 ): boolean =>
   abstraction === HlAbstractionMode.UNIFIED_ACCOUNT ||
   abstraction === HlAbstractionMode.PORTFOLIO_MARGIN

package/src/utils/explorer.ts

@@ -1,6 +1,12 @@
-import type { OrderBase } from '@lifi/perps-types'
+import {
+  createWarnOnce,
+  ExplorerChainId,
+  explorerTxUrl,
+  PerpsError,
+} from '@lifi/perps-sdk'
+import type { Order, OrderBase } from '@lifi/perps-types'
 import { isHex } from 'viem'
-import { HYPERLIQUID_EXPLORER_RPC_URL } from '../constants.js'
+import { HYPERLIQUID_EXPLORER_RPC_URL, PROVIDER_KEY } from '../constants.js'
 import { type HlExplorerTx, isHlExplorerTx } from '../types/explorer.js'
 import { hlPostJson, type InfoRequestOptions } from './infoClient.js'
 
@@ -91,3 +97,46 @@ export const matchOrderActionHash = (
   )
   return match?.hash
 }
+
+const warn = createWarnOnce()
+
+/**
+ * Set `explorerLink` on each order whose placement transaction the explorer
+ * window still holds. One explorer read serves every order, and it is skipped
+ * when no order carries a client order id to match on. The link is
+ * supplementary, so an explorer failure warns and leaves the orders unlinked
+ * instead of failing the order read. A caller cancellation still rejects.
+ */
+export const withExplorerLinks = async (
+  orders: Order[],
+  address: string,
+  options: InfoRequestOptions
+): Promise<Order[]> => {
+  if (!orders.some((order) => order.clientOrderId !== undefined)) {
+    return orders
+  }
+  let txs: HlExplorerTx[]
+  try {
+    txs = await fetchUserTransactions(address, options)
+  } catch (error) {
+    // `hlPostJson` wraps a signal timeout as a `ServerError`, so the signal,
+    // not the error type, tells a caller cancellation from an explorer failure.
+    if (!(error instanceof PerpsError) || options.signal?.aborted) {
+      throw error
+    }
+    // The message stays out of the key: a transport failure names hosts and
+    // ports, so keying on it would let the dedupe set grow without bound.
+    warn(
+      'explorer link lookup failed',
+      `[${PROVIDER_KEY}] explorer link lookup failed: ${error.message}`
+    )
+    return orders
+  }
+  return orders.map((order) => {
+    const explorerLink = explorerTxUrl(
+      ExplorerChainId.HYPERLIQUID,
+      matchOrderActionHash(txs, order)
+    )
+    return explorerLink === undefined ? order : { ...order, explorerLink }
+  })
+}

package/src/utils/index.ts

@@ -56,4 +56,10 @@ export {
   spotPriceById,
 } from './spotBalance.js'
 export { partitionSpotBalances, type SpotPartition } from './spotCollateral.js'
-export { positionMarginConstraints } from './transferMargin.js'
+export { positionRemovableMargin } from './transferMargin.js'
+export {
+  type DexMarginSummary,
+  perpsTotals,
+  sumUnrealizedPnl,
+} from './venueTotals.js'
+export { hyperliquidWithdrawableBalances } from './withdrawableBalances.js'

package/src/utils/mapPosition.ts

@@ -30,10 +30,6 @@ export const mapPosition = (
   const leverage = new Big(pos.leverage.value)
   const marginMode =
     pos.leverage.type === 'cross' ? MarginMode.CROSS : MarginMode.ISOLATED
-  const marginUsed =
-    marginMode === MarginMode.ISOLATED
-      ? new Big(pos.marginUsed).minus(pos.unrealizedPnl).toFixed()
-      : pos.marginUsed
 
   return {
     market,
@@ -45,7 +41,7 @@ export const mapPosition = (
     unrealizedPnl: pos.unrealizedPnl,
     accruedFunding: new Big(pos.cumFunding.sinceOpen).neg().toFixed(),
     leverage: ap.position.leverage.value,
-    marginUsed,
+    marginUsed: pos.marginUsed,
     initialMarginRequirement: positionValue.div(leverage).toFixed(),
     marginMode,
   }