@lifi/perps-sdk-provider-hyperliquid 24.0.0 → 26.0.0

package/src/services/getAccount.ts

@@ -2,20 +2,22 @@ import {
   calculateTransferable,
   getMarketRegistry,
   getMarketsContext,
+  isDecimalStringGreaterThan,
   type ProviderGetAccountParams,
-  parseDecimal,
   type SDKRequestOptions,
+  subtractDecimalString,
   toPerpsMarketDisplay,
+  unknownToDecimalString,
 } from '@lifi/perps-sdk'
 import type {
   AccountResponse,
   Asset,
   Balance,
+  DecimalString,
   HyperliquidAccountConfig,
   HyperliquidDexAccountState,
   Position,
 } from '@lifi/perps-types'
-import type Big from 'big.js'
 import { PROVIDER_KEY } from '../constants.js'
 import type { HyperliquidContext } from '../context.js'
 import type {
@@ -26,19 +28,17 @@ import type {
   HlUserFees,
 } from '../types/index.js'
 import { isUnifiedAbstraction } from '../utils/abstractionMode.js'
-import { toWireBig } from '../utils/decimal.js'
 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'
+import { safeSumDecimalStrings } from '../utils/venueTotals.js'
 import { requireAccountExists } from './getAccountExists.js'
 
 /**
@@ -48,12 +48,6 @@ import { requireAccountExists } from './getAccountExists.js'
  */
 export type GetAccountParams = ProviderGetAccountParams
 
-// `marginSummary` covers the whole account (cross AND isolated positions);
-// `crossMarginSummary` is the cross-only subset and would drop isolated
-// equity/margin.
-const getAccountValue = (state: HlClearinghouseState): Big =>
-  toWireBig(state.marginSummary.accountValue, 'marginSummary.accountValue')
-
 /** Venue buying power for the quote asset the perps dex settles in. */
 const getAvailableAfterMaintenance = (
   spotState: HlSpotClearinghouseState,
@@ -73,21 +67,28 @@ const buildBalances = (
   spotState: HlSpotClearinghouseState,
   stateByDex: Map<string, HlClearinghouseState>,
   quoteAssetIds: ReadonlySet<string>,
-  priceById: Map<string, number>,
+  priceById: ReadonlyMap<string, DecimalString>,
   quoteAssetByCategory: Map<string, Asset>
 ): BalancePartition => {
   const { balances, collateralBalances } = partitionSpotBalances(
     spotState.balances
       .filter((b) => !assetIsOutcome(b.coin))
       .map((b) => {
-        const total = toWireBig(b.total, 'spotClearinghouseState.total')
+        const total = unknownToDecimalString(
+          b.total,
+          'spotClearinghouseState.total',
+          PROVIDER_KEY
+        )
+        const hold = unknownToDecimalString(
+          b.hold,
+          'spotClearinghouseState.hold',
+          PROVIDER_KEY
+        )
         return {
-          ...spotBalance(spotAssetFromToken(b), b.total, priceById),
+          ...spotBalance(spotAssetFromToken(b), total, priceById),
           transferable: calculateTransferable(
+            subtractDecimalString(total, hold),
             total
-              .minus(toWireBig(b.hold, 'spotClearinghouseState.hold'))
-              .toFixed(),
-            total.toFixed()
           ),
         }
       }),
@@ -101,8 +102,15 @@ const buildBalances = (
   if (!isUnifiedAbstraction(abstraction)) {
     for (const [dex, state] of stateByDex) {
       const categoryId = dex || PROVIDER_KEY
-      const value = getAccountValue(state)
-      if (!value.gt(0)) {
+      // `marginSummary` covers the whole account (cross AND isolated positions);
+      // `crossMarginSummary` is the cross-only subset and would drop isolated
+      // equity/margin.
+      const value = unknownToDecimalString(
+        state.marginSummary.accountValue,
+        'marginSummary.accountValue',
+        PROVIDER_KEY
+      )
+      if (!isDecimalStringGreaterThan(value, '0')) {
         continue
       }
       collateralBalances.push({
@@ -110,15 +118,16 @@ const buildBalances = (
         // Always present: every dex in `stateByDex` derives from `markets`,
         // which is what populates `quoteAssetByCategory`.
         asset: quoteAssetByCategory.get(categoryId)!,
-        units: value.toFixed(),
-        valueUsd: value.toFixed(),
+        units: value,
+        valueUsd: value,
         price: '1',
         transferable: calculateTransferable(
-          toWireBig(
+          unknownToDecimalString(
             state.withdrawable,
-            'clearinghouseState.withdrawable'
-          ).toFixed(),
-          value.toFixed()
+            'clearinghouseState.withdrawable',
+            PROVIDER_KEY
+          ),
+          value
         ),
       })
     }
@@ -209,9 +218,7 @@ export const getAccount = async (
 
   const priceById = spotPriceById(
     markets,
-    new Map(
-      prices.map((p) => [p.marketId, parseDecimal(p.markPrice) ?? Number.NaN])
-    )
+    new Map(prices.map((p) => [p.marketId, p.markPrice]))
   )
 
   const positions: Position[] = stateResults.flatMap((state) =>
@@ -219,12 +226,13 @@ export const getAccount = async (
       .filter(
         (ap) => !assetIsOutcome(ap.position.coin) && isOpenAssetPosition(ap)
       )
-      .map((ap) =>
-        mapPosition(
+      .flatMap((ap) => {
+        const position = mapPosition(
           ap,
           toPerpsMarketDisplay(registry.require(ap.position.coin))
         )
-      )
+        return position === undefined ? [] : [position]
+      })
   )
 
   const stateByDex = new Map<string, HlClearinghouseState>()
@@ -266,14 +274,23 @@ export const getAccount = async (
     quoteAssetByCategory
   )
 
+  const marginUsed = safeSumDecimalStrings(
+    dexStates.flatMap(({ marginSummary }) =>
+      marginSummary === undefined ? [] : [marginSummary.totalMarginUsed]
+    )
+  )
+  const unrealizedPnl = safeSumDecimalStrings(
+    positions.map((position) => position.unrealizedPnl)
+  )
+
   return {
     provider: PROVIDER_KEY,
     address: params.address,
     balances,
     collateralBalances,
     positions,
-    marginUsed: perpsTotals(dexStates).marginUsed.toFixed(),
-    unrealizedPnl: sumUnrealizedPnl(positions).toFixed(),
+    ...(marginUsed === undefined ? {} : { marginUsed }),
+    ...(unrealizedPnl === undefined ? {} : { unrealizedPnl }),
     feeTier: {
       maker: feesResult.userAddRate ?? '0',
       taker: feesResult.userCrossRate ?? '0',

package/src/services/getFills.ts

@@ -67,7 +67,8 @@ export const getFills = async (
           return []
         }
         const market = registry.get(fill.coin)
-        return market === undefined ? [] : [mapFill(fill, market)]
+        const mapped = market && mapFill(fill, market)
+        return mapped ? [mapped] : []
       })
       return { items, saturated: false }
     },

package/src/services/getMarketSettings.ts

@@ -1,4 +1,8 @@
-import { PerpsError, type SDKRequestOptions } from '@lifi/perps-sdk'
+import {
+  numberToDecimalString,
+  PerpsError,
+  type SDKRequestOptions,
+} from '@lifi/perps-sdk'
 import {
   MarginMode,
   type MarketRef,
@@ -66,6 +70,6 @@ export const getMarketSettings = async (
   return {
     marginMode:
       leverage.type === 'isolated' ? MarginMode.ISOLATED : MarginMode.CROSS,
-    leverage: leverage.value,
+    leverage: numberToDecimalString(leverage.value),
   }
 }

package/src/services/getOrder.ts

@@ -24,6 +24,15 @@ import { requireAccountExists } from './getAccountExists.js'
  */
 export type GetOrderParams = ProviderGetOrderParams
 
+const orderNotFound = (id: string): PerpsError => {
+  const err = new PerpsError(
+    PerpsErrorCode.OrderNotFound,
+    `Order not found: ${id}`
+  )
+  err.tool = PROVIDER_KEY
+  return err
+}
+
 /**
  * Read getOrder direct from the Hyperliquid REST API.
  *
@@ -70,17 +79,16 @@ export const getOrder = async (
     if (twap !== undefined) {
       const registry = getMarketRegistry(client, PROVIDER_KEY)
       await registry.sync()
-      return mapOrder(twap, registry.require(twap.state.coin))
+      const order = mapOrder(twap, registry.require(twap.state.coin))
+      if (order === undefined) {
+        throw orderNotFound(params.id)
+      }
+      return order
     }
   }
 
   if (status.status !== 'order' || assetIsOutcome(status.order.order.coin)) {
-    const err = new PerpsError(
-      PerpsErrorCode.OrderNotFound,
-      `Order not found: ${params.id}`
-    )
-    err.tool = PROVIDER_KEY
-    throw err
+    throw orderNotFound(params.id)
   }
 
   const registry = getMarketRegistry(client, PROVIDER_KEY)
@@ -89,6 +97,9 @@ export const getOrder = async (
     status.order,
     registry.require(status.order.order.coin)
   )
+  if (order === undefined) {
+    throw orderNotFound(params.id)
+  }
   const [linked] = await withExplorerLinks([order], params.address, infoOpts)
   return linked
 }

package/src/services/getOrders.ts

@@ -39,7 +39,7 @@ const warnOnce = (key: string): void => {
 const mapRow = (
   coin: string,
   registry: MarketRegistry,
-  map: (market: MarketDisplay) => Order
+  map: (market: MarketDisplay) => Order | undefined
 ): Order | undefined => {
   if (assetIsOutcome(coin)) {
     return undefined
@@ -114,14 +114,17 @@ export const getOrders = async (
       rows.set(key, order)
     }
   }
+  const seenHistorical = new Set<string>()
   for (const detail of historical) {
     const key = String(detail.order.oid)
     // The feed carries one row per lifecycle transition, newest first, and a
     // terminal row shares its timestamp with the `open` row beneath it, so
-    // only the first row of an id states that order's current status.
-    if (rows.has(key)) {
+    // only the first row of an id states that order's current status, even
+    // when the mapper skips that row.
+    if (seenHistorical.has(key)) {
       continue
     }
+    seenHistorical.add(key)
     keep(
       key,
       mapRow(detail.order.coin, registry, (market) => mapOrder(detail, market))

package/src/services/getPortfolioHistory.ts

@@ -1,11 +1,17 @@
-import { PerpsError, type SDKRequestOptions } from '@lifi/perps-sdk'
 import {
+  PerpsError,
+  type SDKRequestOptions,
+  warnSkippedVenueRow,
+} from '@lifi/perps-sdk'
+import {
+  type DecimalString,
   PerpsErrorCode,
   type PortfolioHistoryPoint,
   type PortfolioHistoryRange,
   type PortfolioHistoryResponse,
 } from '@lifi/perps-types'
 import type { Address } from 'viem'
+import { PROVIDER_KEY } from '../constants.js'
 import type { HyperliquidContext } from '../context.js'
 import type {
   HlAbstractionMode,
@@ -40,19 +46,39 @@ const PERP_PERIOD_BY_RANGE: Record<PortfolioHistoryRange, HlPortfolioPeriod> = {
   all: 'perpAllTime',
 }
 
+/** The samples with a finite timestamp; each other sample is skipped. */
+const validSamples = (
+  samples: HlPortfolioWindow['pnlHistory'],
+  row: string
+): [number, DecimalString][] =>
+  samples.flatMap(([timestamp, value]): [number, DecimalString][] => {
+    if (!Number.isFinite(timestamp)) {
+      warnSkippedVenueRow(
+        PROVIDER_KEY,
+        row,
+        'timestamp',
+        timestamp,
+        'timestamp'
+      )
+      return []
+    }
+    return [[timestamp, value]]
+  })
+
 /**
  * Join the window's two series on their timestamps. `pnlHistory` is cumulative
  * from the window's start, so a point with no PnL sample carries the last
  * sampled value — `'0'` before the first one.
  */
 const joinWindow = (
-  window: HlPortfolioWindow,
+  accountValueHistory: [number, DecimalString][],
+  pnlHistory: [number, DecimalString][],
   period: HlPortfolioPeriod
 ): PortfolioHistoryPoint[] => {
-  const pnlByTimestamp = new Map(window.pnlHistory)
+  const pnlByTimestamp = new Map(pnlHistory)
   let matched = 0
   let cumulative = '0'
-  const points = window.accountValueHistory.map(([timestamp, accountValue]) => {
+  const points = accountValueHistory.map(([timestamp, accountValue]) => {
     const sample = pnlByTimestamp.get(timestamp)
     if (sample !== undefined) {
       matched += 1
@@ -60,7 +86,7 @@ const joinWindow = (
     }
     return { timestamp, accountValue, pnl: cumulative }
   })
-  if (points.length > 0 && window.pnlHistory.length > 0 && matched === 0) {
+  if (points.length > 0 && pnlHistory.length > 0 && matched === 0) {
     throw new PerpsError(
       PerpsErrorCode.ThirdPartyError,
       `Hyperliquid portfolio window '${period}' samples PnL on no ` +
@@ -111,10 +137,15 @@ export async function getPortfolioHistory(
     )
   }
 
+  const pnlHistory = validSamples(window.pnlHistory, 'portfolio PnL sample')
   return {
     range: params.range,
-    points: joinWindow(window, period),
+    points: joinWindow(
+      validSamples(window.accountValueHistory, 'portfolio value sample'),
+      pnlHistory,
+      period
+    ),
     volume: window.vlm,
-    totalPnl: window.pnlHistory.at(-1)?.[1],
+    totalPnl: pnlHistory.at(-1)?.[1],
   }
 }

package/src/services/getPositions.ts

@@ -67,12 +67,13 @@ export const getPositions = async (
       .filter(
         (ap) => !assetIsOutcome(ap.position.coin) && isOpenAssetPosition(ap)
       )
-      .map((ap) =>
-        mapPosition(
+      .flatMap((ap) => {
+        const position = mapPosition(
           ap,
           toPerpsMarketDisplay(registry.require(ap.position.coin))
         )
-      )
+        return position === undefined ? [] : [position]
+      })
   )
 
   if (params.marketId !== undefined) {

package/src/services/getWithdrawableBalances.ts

@@ -27,7 +27,7 @@ export type GetWithdrawableBalancesParams =
   ProviderGetWithdrawableBalancesParams
 
 /**
- * The `(asset, route)` pairs `params.address` can withdraw from Hyperliquid,
+ * The `(asset, category)` 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.

package/src/types/ws.ts

@@ -1,5 +1,6 @@
 // Hyperliquid WebSocket incoming message types.
 
+import type { DecimalString } from '@lifi/perps-types'
 import type { HlClearinghouseState, HlSpotBalance } from './account.js'
 import type { HlCandle, HlL2Book } from './asset.js'
 import type { HlUserFill } from './fill.js'
@@ -77,8 +78,8 @@ export type HlWsMessage = {
  * @public
  */
 export type HlWsFastAssetCtx = {
-  markPx?: string
-  midPx?: string | null
+  markPx?: DecimalString
+  midPx?: DecimalString | null
 }
 
 /**

package/src/utils/liquidation.ts

@@ -12,7 +12,11 @@
  * - margin_available = isolated_margin - maintenance_margin_required
  */
 
-import { estimateLiquidationPrice } from '@lifi/perps-sdk'
+import {
+  divideDecimalString,
+  numberToDecimalString,
+  safeEstimateLiquidationPrice,
+} from '@lifi/perps-sdk'
 
 /**
  * Calculate the maintenance margin fraction for a Hyperliquid asset.
@@ -56,19 +60,21 @@ export function calculateMaintenanceMarginRate(
  * @public
  */
 export function calculateLiquidationPrice(
-  entryPrice: number,
-  leverage: number,
+  entryPrice: string,
+  leverage: string,
   isLong: boolean,
   maxLeverage: number
-): number | undefined {
-  const mmr = calculateMaintenanceMarginRate(maxLeverage)
-  if (mmr === undefined) {
+): string | undefined {
+  if (maxLeverage === 0) {
     return undefined
   }
-  return estimateLiquidationPrice({
+  return safeEstimateLiquidationPrice({
     entryPrice,
     leverage,
     isLong,
-    maintenanceMarginRate: mmr,
+    maintenanceMarginRate: divideDecimalString(
+      '1',
+      numberToDecimalString(2 * maxLeverage)
+    ),
   })
 }

package/src/utils/mapActivity.ts

@@ -3,6 +3,10 @@ import {
   ExplorerChainId,
   explorerTxUrl,
   PerpsError,
+  safeAddDecimalString,
+  safeMultiplyDecimalString,
+  safeSubtractDecimalString,
+  warnSkippedVenueRow,
 } from '@lifi/perps-sdk'
 import type {
   ActivityItem,
@@ -16,7 +20,6 @@ import type {
   WithdrawalActivity,
 } from '@lifi/perps-types'
 import { ActivityType, PerpsErrorCode } from '@lifi/perps-types'
-import Big from 'big.js'
 import { zeroHash } from 'viem'
 import type {
   HlBorrowLendOperation,
@@ -35,6 +38,7 @@ import {
   isVaultTransferDelta,
   isWithdrawDelta,
 } from '../types/index.js'
+import { rowTimestampToIsoStringOrUndefined } from './rowTimestamp.js'
 
 /**
  * Hyperliquid settles every perp deposit and withdrawal in USDC, and charges
@@ -96,11 +100,12 @@ export const mapLedgerEntry = (
   resolveMarket: (coin: string) => MarketDisplay | undefined
 ): ActivityItem | null => {
   const { delta } = entry
-  const base = {
-    id: entry.hash,
-    provider: providerKey,
-    timestamp: new Date(entry.time).toISOString(),
+  const timestamp = rowTimestampToIsoStringOrUndefined(entry.time)
+  if (timestamp === undefined) {
+    warnSkippedVenueRow(providerKey, 'ledger', 'time', entry.time, 'timestamp')
+    return null
   }
+  const base = { id: entry.hash, provider: providerKey, timestamp }
 
   if (
     isSpotTransferDelta(delta) ||
@@ -315,7 +320,11 @@ export const mapFundingActivity = (
   if (market === undefined) {
     return null
   }
-  const timestamp = new Date(entry.time).toISOString()
+  const timestamp = rowTimestampToIsoStringOrUndefined(entry.time)
+  if (timestamp === undefined) {
+    warnSkippedVenueRow(providerKey, 'funding', 'time', entry.time, 'timestamp')
+    return null
+  }
   return {
     id: `funding:${entry.delta.coin}:${timestamp}`,
     provider: providerKey,
@@ -334,7 +343,8 @@ export const mapFundingActivity = (
  * parties, so only fills whose `liquidatedUser` is the queried address count.
  * A fill whose hash a ledger liquidation row already carries is the same
  * event and is skipped. The size sign follows the closed position: a sell
- * fill closes a long. Groups whose market does not resolve are dropped.
+ * fill closes a long. Groups whose market or time does not resolve are
+ * dropped; an invalid fill size or price leaves the derived field absent.
  * @public
  */
 export const mapLiquidationFills = (
@@ -363,26 +373,38 @@ export const mapLiquidationFills = (
     if (market === undefined) {
       return []
     }
-    let size = new Big(0)
-    let notional = new Big(0)
-    let time = first.time
-    for (const fill of group) {
-      size = size.plus(fill.sz)
-      notional = notional.plus(new Big(fill.px).times(fill.sz))
-      time = Math.max(time, fill.time)
+    const size = group.reduce<string | undefined>(
+      (sum, fill) =>
+        sum === undefined ? undefined : safeAddDecimalString(sum, fill.sz),
+      '0'
+    )
+    const notional = group.reduce<string | undefined>((sum, fill) => {
+      const fillNotional = safeMultiplyDecimalString(fill.px, fill.sz)
+      return sum === undefined || fillNotional === undefined
+        ? undefined
+        : safeAddDecimalString(sum, fillNotional)
+    }, '0')
+    const time = Math.max(...group.map((fill) => fill.time))
+    const timestamp = rowTimestampToIsoStringOrUndefined(time)
+    if (timestamp === undefined) {
+      warnSkippedVenueRow(providerKey, 'liquidation', 'time', time, 'timestamp')
+      return []
     }
+    const closedSize =
+      size === undefined || first.side === 'A'
+        ? size
+        : safeSubtractDecimalString('0', size)
     return [
       {
         id: `liquidation:${oid}`,
         provider: providerKey,
-        timestamp: new Date(time).toISOString(),
+        timestamp,
         type: ActivityType.LIQUIDATION,
-        liquidatedNotionalPosition: notional.toFixed(),
+        ...(notional === undefined
+          ? {}
+          : { liquidatedNotionalPosition: notional }),
         liquidatedPositions: [
-          {
-            market,
-            size: (first.side === 'A' ? size : size.neg()).toFixed(),
-          },
+          { market, ...(closedSize === undefined ? {} : { size: closedSize }) },
         ],
       } satisfies LiquidationActivity,
     ]

package/src/utils/mapFill.ts

@@ -2,6 +2,7 @@ import {
   classifyFillFromPosition,
   ExplorerChainId,
   explorerTxUrl,
+  warnSkippedVenueRow,
 } from '@lifi/perps-sdk'
 import type { Fill, MarketDisplay } from '@lifi/perps-types'
 import {
@@ -10,20 +11,32 @@ import {
   OrderSide,
   OrderType,
 } from '@lifi/perps-types'
-import { SPOT_MARKET_ID } from '../constants.js'
+import { PROVIDER_KEY, SPOT_MARKET_ID } from '../constants.js'
 import type { HlUserFill } from '../types/index.js'
+import { rowTimestampToIsoStringOrUndefined } from './rowTimestamp.js'
 
 /** Re-export the shared fill-position classifier used by Hyperliquid mappings. @public */
 export { classifyFillFromPosition }
 
 /**
  * Spot-ness comes from the resolved market's category, not the coin string —
- * HL's canonical spot pair 0 is addressed as `PURR/USDC`, not `@0`.
+ * HL's canonical spot pair 0 is addressed as `PURR/USDC`, not `@0`. A fill with
+ * an invalid time gives `undefined`.
  * @public
  */
-export const mapFill = (fill: HlUserFill, market: MarketDisplay): Fill => {
+export const mapFill = (
+  fill: HlUserFill,
+  market: MarketDisplay
+): Fill | undefined => {
+  const size = fill.sz
+  const createdAt = rowTimestampToIsoStringOrUndefined(fill.time)
+  if (createdAt === undefined) {
+    warnSkippedVenueRow(PROVIDER_KEY, 'fill', 'time', fill.time, 'timestamp')
+    return undefined
+  }
   // HL charges the builder portion in the same token as the total fee.
   const feeAsset = fill.feeToken ?? market.quoteAsset.displaySymbol
+  const side = fill.side === 'B' ? OrderSide.BUY : OrderSide.SELL
 
   return {
     ...(market.categoryId === SPOT_MARKET_ID
@@ -33,16 +46,16 @@ export const mapFill = (fill: HlUserFill, market: MarketDisplay): Fill => {
     orderId: String(fill.oid),
     clientOrderId: fill.cloid,
     market,
-    side: fill.side === 'B' ? OrderSide.BUY : OrderSide.SELL,
+    side,
     // HL fills don't carry the originating order type. A maker fill (crossed:
     // false) can only come from a resting order, so it's necessarily a limit;
     // a taker fill (crossed: true) may be a market OR an aggressive limit order,
     // which the payload can't distinguish, so the type is left undefined.
     type: fill.crossed ? undefined : OrderType.LIMIT,
-    size: fill.sz,
+    size,
     price: fill.px,
     liquidity: fill.crossed ? LiquidityRole.TAKER : LiquidityRole.MAKER,
-    filledSize: fill.sz,
+    filledSize: size,
     fee: {
       amount: fill.fee,
       asset: feeAsset,
@@ -55,10 +68,10 @@ export const mapFill = (fill: HlUserFill, market: MarketDisplay): Fill => {
     explorerLink: explorerTxUrl(ExplorerChainId.HYPERLIQUID, fill.hash),
     classification:
       market.categoryId === SPOT_MARKET_ID
-        ? fill.side === 'B'
+        ? side === OrderSide.BUY
           ? FillClassification.SPOT_BUY
           : FillClassification.SPOT_SELL
-        : classifyFillFromPosition(fill.startPosition, fill.side, fill.sz),
-    createdAt: new Date(fill.time).toISOString(),
+        : classifyFillFromPosition(fill.startPosition, side, size),
+    createdAt,
   }
 }