@lifi/perps-sdk-provider-lighter 35.0.0 → 36.0.0

package/src/utils/mapOrder.ts

@@ -1,7 +1,12 @@
 import {
   isActiveOrderStatus,
+  isDecimalStringGreaterThan,
   PerpsError,
+  safeDivideDecimalString,
+  safeTimestampToIsoString,
   triggerConditionFor,
+  unknownToDecimalString,
+  warnSkippedVenueRow,
 } from '@lifi/perps-sdk'
 import type { MarketDisplay, Order, OrderBase } from '@lifi/perps-types'
 import {
@@ -11,8 +16,9 @@ import {
   PerpsErrorCode,
   TimeInForce,
 } from '@lifi/perps-types'
-import Big from 'big.js'
+import { LIGHTER_PROVIDER_KEY } from '../constants.js'
 import type { LtOrder } from '../types/index.js'
+import { rowTimestampToIsoStringOrUndefined } from './rowTimestamp.js'
 
 const mapOrderType = (type: string): Order['type'] => {
   switch (type.replace(/-/g, '_')) {
@@ -56,10 +62,20 @@ const mapTimeInForce = (tif: string): TimeInForce => {
   }
 }
 
-const mapOrderStatus = (
-  order: LtOrder,
-  filledSize = new Big(order.filled_base_amount)
-): OrderStatus => {
+const venueDecimal = (value: unknown, field: string): string | undefined => {
+  try {
+    return unknownToDecimalString(value, field, LIGHTER_PROVIDER_KEY)
+  } catch {
+    return undefined
+  }
+}
+
+const hasFill = (order: LtOrder): boolean => {
+  const filled = venueDecimal(order.filled_base_amount, 'filled_base_amount')
+  return filled !== undefined && isDecimalStringGreaterThan(filled, '0')
+}
+
+const mapOrderStatus = (order: LtOrder): OrderStatus => {
   switch (order.status) {
     case 'in-progress':
       return OrderStatus.ACCEPTED
@@ -69,7 +85,7 @@ const mapOrderStatus = (
       if (order.trigger_status === 'parent-order') {
         return OrderStatus.PENDING
       }
-      return filledSize.gt(0) ? OrderStatus.PARTIALLY_FILLED : OrderStatus.OPEN
+      return hasFill(order) ? OrderStatus.PARTIALLY_FILLED : OrderStatus.OPEN
     case 'triggered':
       return OrderStatus.TRIGGERED
     case 'filled':
@@ -97,11 +113,72 @@ const mapOrderStatus = (
   }
 }
 
-/** Map a Lighter order with its venue identity, lifecycle, and execution fields. */
-export const mapOrder = (order: LtOrder, market: MarketDisplay): Order => {
+const skipOrder = (field: string, value: unknown): undefined => {
+  warnSkippedVenueRow(LIGHTER_PROVIDER_KEY, 'order', field, value)
+  return undefined
+}
+
+const orderSizeOrSkip = (
+  field: 'initial_base_amount' | 'remaining_base_amount' | 'filled_base_amount',
+  value: string
+): string | undefined =>
+  venueDecimal(value, field) === undefined ? skipOrder(field, value) : value
+
+/**
+ * Map a Lighter order with its venue identity, lifecycle, and execution fields.
+ * A row with an invalid size or time gives `undefined`. An invalid limit price or
+ * filled quote amount omits that field.
+ */
+export const mapOrder = (
+  order: LtOrder,
+  market: MarketDisplay
+): Order | undefined => {
   const type = mapOrderType(order.type)
-  const filledSize = new Big(order.filled_base_amount)
-  const status = mapOrderStatus(order, filledSize)
+  const originalSize = orderSizeOrSkip(
+    'initial_base_amount',
+    order.initial_base_amount
+  )
+  if (originalSize === undefined) {
+    return undefined
+  }
+  const remainingSize = orderSizeOrSkip(
+    'remaining_base_amount',
+    order.remaining_base_amount
+  )
+  if (remainingSize === undefined) {
+    return undefined
+  }
+  const filledSize = orderSizeOrSkip(
+    'filled_base_amount',
+    order.filled_base_amount
+  )
+  if (filledSize === undefined) {
+    return undefined
+  }
+  const createdAt = rowTimestampToIsoStringOrUndefined(order.created_at * 1000)
+  if (createdAt === undefined) {
+    return skipOrder('created_at', order.created_at)
+  }
+  const updatedAt = rowTimestampToIsoStringOrUndefined(order.updated_at * 1000)
+  if (updatedAt === undefined) {
+    return skipOrder('updated_at', order.updated_at)
+  }
+  const filledQuote = venueDecimal(
+    order.filled_quote_amount,
+    'filled_quote_amount'
+  )
+  const filledAmount = venueDecimal(filledSize, 'filled_base_amount')
+  const averagePrice =
+    filledQuote !== undefined &&
+    filledAmount !== undefined &&
+    isDecimalStringGreaterThan(filledAmount, '0')
+      ? safeDivideDecimalString(filledQuote, filledAmount)
+      : undefined
+  const expiresAt =
+    order.order_expiry > 0
+      ? safeTimestampToIsoString(order.order_expiry)
+      : undefined
+  const status = mapOrderStatus(order)
   const base: OrderBase = {
     orderId: String(order.order_index),
     ...(order.client_order_index === 0
@@ -111,20 +188,14 @@ export const mapOrder = (order: LtOrder, market: MarketDisplay): Order => {
     side: order.is_ask ? OrderSide.SELL : OrderSide.BUY,
     status,
     ...(status === OrderStatus.CANCELLED ? { statusReason: order.status } : {}),
-    originalSize: order.initial_base_amount,
-    remainingSize: order.remaining_base_amount,
-    filledSize: order.filled_base_amount,
-    ...(filledSize.gt(0)
-      ? {
-          averagePrice: new Big(order.filled_quote_amount)
-            .div(filledSize)
-            .toFixed(),
-        }
-      : {}),
+    originalSize,
+    remainingSize,
+    filledSize,
+    ...(averagePrice === undefined ? {} : { averagePrice }),
     reduceOnly: order.reduce_only,
     ...(order.parent_order_id ? { parentOrderId: order.parent_order_id } : {}),
-    createdAt: new Date(order.created_at * 1000).toISOString(),
-    updatedAt: new Date(order.updated_at * 1000).toISOString(),
+    createdAt,
+    updatedAt,
   }
   switch (type) {
     case OrderType.TWAP:
@@ -137,17 +208,19 @@ export const mapOrder = (order: LtOrder, market: MarketDisplay): Order => {
     case OrderType.STOP_MARKET:
     case OrderType.STOP_LIMIT:
     case OrderType.TAKE_PROFIT_MARKET:
-    case OrderType.TAKE_PROFIT_LIMIT:
+    case OrderType.TAKE_PROFIT_LIMIT: {
       return {
         ...base,
         type,
         triggerPrice: order.trigger_price,
         triggerCondition: triggerConditionFor(type, base.side),
-        ...(type === OrderType.STOP_LIMIT ||
-        type === OrderType.TAKE_PROFIT_LIMIT
+        ...((type === OrderType.STOP_LIMIT ||
+          type === OrderType.TAKE_PROFIT_LIMIT) &&
+        venueDecimal(order.price, 'price') !== undefined
           ? { limitPrice: order.price }
           : {}),
       }
+    }
     case OrderType.MARKET:
     case OrderType.LIMIT:
       return {
@@ -155,9 +228,7 @@ export const mapOrder = (order: LtOrder, market: MarketDisplay): Order => {
         type,
         price: order.price,
         timeInForce: mapTimeInForce(order.time_in_force),
-        ...(order.order_expiry > 0
-          ? { expiresAt: new Date(order.order_expiry).toISOString() }
-          : {}),
+        ...(expiresAt === undefined ? {} : { expiresAt }),
       }
   }
 }

package/src/utils/mapPortfolioHistory.ts

@@ -1,33 +1,85 @@
+import {
+  addDecimalString,
+  numberToDecimalString,
+  subtractDecimalString,
+  warnSkippedVenueRow,
+} from '@lifi/perps-sdk'
 import type {
   PortfolioHistoryRange,
   PortfolioHistoryResponse,
 } from '@lifi/perps-types'
-import Big from 'big.js'
+import { LIGHTER_PROVIDER_KEY } from '../constants.js'
 import type { LtPnLEntry } from '../types/pnl.js'
 
-function getCumulativePnl(snapshot: LtPnLEntry): Big {
-  return new Big(snapshot.trade_pnl).plus(snapshot.trade_spot_pnl)
+const SNAPSHOT_DECIMAL_FIELDS = [
+  'trade_pnl',
+  'trade_spot_pnl',
+  'inflow',
+  'outflow',
+  'spot_inflow',
+  'spot_outflow',
+  'volume',
+] as const
+
+type SnapshotDecimalField = (typeof SNAPSHOT_DECIMAL_FIELDS)[number]
+
+const snapshotDecimal = (
+  snapshot: LtPnLEntry,
+  field: SnapshotDecimalField
+): string => numberToDecimalString(snapshot[field])
+
+function isValidSnapshot(snapshot: LtPnLEntry): boolean {
+  const invalid = SNAPSHOT_DECIMAL_FIELDS.find(
+    (field) => !Number.isFinite(snapshot[field])
+  )
+  if (invalid === undefined) {
+    return true
+  }
+  warnSkippedVenueRow(
+    LIGHTER_PROVIDER_KEY,
+    'portfolio history',
+    invalid,
+    snapshot[invalid]
+  )
+  return false
 }
 
-function getCumulativeNetFlow(snapshot: LtPnLEntry): Big {
-  return new Big(snapshot.inflow)
-    .minus(snapshot.outflow)
-    .plus(snapshot.spot_inflow)
-    .minus(snapshot.spot_outflow)
+function getCumulativePnl(snapshot: LtPnLEntry): string {
+  return addDecimalString(
+    snapshotDecimal(snapshot, 'trade_pnl'),
+    snapshotDecimal(snapshot, 'trade_spot_pnl')
+  )
+}
+
+function getCumulativeNetFlow(snapshot: LtPnLEntry): string {
+  return subtractDecimalString(
+    addDecimalString(
+      subtractDecimalString(
+        snapshotDecimal(snapshot, 'inflow'),
+        snapshotDecimal(snapshot, 'outflow')
+      ),
+      snapshotDecimal(snapshot, 'spot_inflow')
+    ),
+    snapshotDecimal(snapshot, 'spot_outflow')
+  )
 }
 
 /**
  * Derive window-relative history from Lighter's cumulative PnL snapshots.
- * Historical account values are anchored to the current account value.
+ * Historical account values are anchored to the current account value. A
+ * snapshot with a non-finite value is skipped.
+ *
+ * @throws {PerpsError} `ValidationError` when `currentValue` is not a decimal
+ *   string.
  */
 export const mapPortfolioHistory = (
   range: PortfolioHistoryRange,
   snapshots: LtPnLEntry[],
-  currentValue: Big
+  currentValue: string
 ): PortfolioHistoryResponse => {
-  const orderedSnapshots = [...snapshots].sort(
-    (a, b) => a.timestamp - b.timestamp
-  )
+  const orderedSnapshots = snapshots
+    .filter(isValidSnapshot)
+    .sort((a, b) => a.timestamp - b.timestamp)
   const firstSnapshot = orderedSnapshots[0]
   const latestSnapshot = orderedSnapshots.at(-1)
   if (!firstSnapshot || !latestSnapshot) {
@@ -41,27 +93,29 @@ export const mapPortfolioHistory = (
 
   const firstPnl = getCumulativePnl(firstSnapshot)
   const latestPnl = getCumulativePnl(latestSnapshot)
-  const accountValueOffset = currentValue
-    .minus(latestPnl)
-    .minus(getCumulativeNetFlow(latestSnapshot))
+  const accountValueOffset = subtractDecimalString(
+    subtractDecimalString(currentValue, latestPnl),
+    getCumulativeNetFlow(latestSnapshot)
+  )
   const points = orderedSnapshots.map((snapshot) => {
     const pnl = getCumulativePnl(snapshot)
     return {
       timestamp: snapshot.timestamp * 1_000,
-      accountValue: accountValueOffset
-        .plus(pnl)
-        .plus(getCumulativeNetFlow(snapshot))
-        .toFixed(),
-      pnl: pnl.minus(firstPnl).toFixed(),
+      accountValue: addDecimalString(
+        addDecimalString(accountValueOffset, pnl),
+        getCumulativeNetFlow(snapshot)
+      ),
+      pnl: subtractDecimalString(pnl, firstPnl),
     }
   })
 
   return {
     range,
     points,
-    volume: new Big(latestSnapshot.volume)
-      .minus(firstSnapshot.volume)
-      .toFixed(),
+    volume: subtractDecimalString(
+      snapshotDecimal(latestSnapshot, 'volume'),
+      snapshotDecimal(firstSnapshot, 'volume')
+    ),
     totalPnl: points.at(-1)?.pnl,
   }
 }

package/src/utils/mapPosition.ts

@@ -1,86 +1,109 @@
+import {
+  absDecimalString,
+  divideDecimalString,
+  isDecimalString,
+  isDecimalStringZero,
+  multiplyDecimalString,
+  safeDivideDecimalString,
+  safeIsDecimalStringGreaterThan,
+  safeNumberToDecimalString,
+  safeRoundDecimalString,
+  warnSkippedVenueRow,
+} from '@lifi/perps-sdk'
 import type { PerpsMarketDisplay, Position } from '@lifi/perps-types'
 import { MarginMode, PositionSide } from '@lifi/perps-types'
-import Big from 'big.js'
-import { LIGHTER_IMF_PERCENT_SCALE } from '../constants.js'
+import {
+  LIGHTER_IMF_PERCENT_SCALE,
+  LIGHTER_LEVERAGE_PRECISION,
+  LIGHTER_PROVIDER_KEY,
+} from '../constants.js'
 import type { LtAccountPosition } from '../types/index.js'
 import { LT_MARGIN_MODE_ISOLATED } from '../types/index.js'
-import { toPositiveRequiredBig, toRequiredBig } from './decimal.js'
 
 /**
  * Display leverage from an IMF percent string: `100 / IMF` in exact decimal
- * arithmetic before conversion to `number`. This value is for displaying the
- * venue setting; provider risk calculations consume the original decimal IMF
- * instead. `undefined` for a non-positive or unparsable IMF.
+ * arithmetic, rounded half-up to `LIGHTER_LEVERAGE_PRECISION`, so the value a
+ * client reads is the value it saved. Provider risk calculations consume the
+ * original decimal IMF instead. `undefined` for a non-positive or unparsable
+ * IMF.
  * @public
  */
-export const leverageFromImf = (imf: string): number | undefined => {
-  let parsed: Big
-  try {
-    parsed = new Big(imf)
-  } catch {
+export const leverageFromImf = (imf: string): string | undefined => {
+  if (safeIsDecimalStringGreaterThan(imf, '0') !== true) {
     return undefined
   }
-  if (parsed.lte(0)) {
-    return undefined
-  }
-  return new Big(100).div(parsed).toNumber()
+  const leverage = safeDivideDecimalString('100', imf)
+  return leverage === undefined
+    ? undefined
+    : safeRoundDecimalString(leverage, LIGHTER_LEVERAGE_PRECISION, 'round')
 }
 
 /**
  * Display leverage from an integer IMF on `LIGHTER_IMF_PERCENT_SCALE`, the
  * unit of trade rows and order-book details: `500` is 5.00%, so 20x.
- * `undefined` for a non-positive or unparsable IMF. Lighter declares the
+ * `undefined` for a non-positive or non-finite IMF. Lighter declares the
  * fraction a `StrictInt`, so the scale division is exact.
  */
-export const leverageFromScaledImf = (imf: number): number | undefined => {
-  let percent: string
-  try {
-    percent = new Big(imf).div(LIGHTER_IMF_PERCENT_SCALE).toFixed()
-  } catch {
-    return undefined
-  }
-  return leverageFromImf(percent)
+export const leverageFromScaledImf = (imf: number): string | undefined => {
+  const scaled = safeNumberToDecimalString(imf)
+  const percent =
+    scaled === undefined
+      ? undefined
+      : safeDivideDecimalString(scaled, String(LIGHTER_IMF_PERCENT_SCALE))
+  return percent === undefined ? undefined : leverageFromImf(percent)
+}
+
+const skipPosition = (field: string, value: unknown): undefined => {
+  warnSkippedVenueRow(LIGHTER_PROVIDER_KEY, 'position', field, value)
+  return undefined
 }
 
 /**
- * Map a raw Lighter account position to the generic Position type.
+ * Map a raw Lighter account position to the generic Position type. A row with
+ * an invalid size or value, or a non-positive initial margin fraction, gives
+ * `undefined`: the mapper derives the size, mark price, margin and leverage
+ * from them. Prices, PnL, funding and isolated margin pass through raw.
  * @param market - Backend-resolved market identity for `pos.market_id`.
  * @public
  */
 export const mapPosition = (
   pos: LtAccountPosition,
   market: PerpsMarketDisplay
-): Position => {
-  const size = toRequiredBig(pos.position, 'position')
+): Position | undefined => {
+  if (!isDecimalString(pos.position)) {
+    return skipPosition('position', pos.position)
+  }
+  if (!isDecimalString(pos.position_value)) {
+    return skipPosition('position_value', pos.position_value)
+  }
+  const imf = pos.initial_margin_fraction
+  const leverage = isDecimalString(imf) ? leverageFromImf(imf) : undefined
+  if (leverage === undefined) {
+    return skipPosition('initial_margin_fraction', imf)
+  }
   const isIsolated = pos.margin_mode === LT_MARGIN_MODE_ISOLATED
-  const positionValue = toRequiredBig(
-    pos.position_value,
-    'position_value'
-  ).abs()
-  const imf = toPositiveRequiredBig(
-    pos.initial_margin_fraction,
-    'initial_margin_fraction'
+  const size = absDecimalString(pos.position)
+  const positionValue = absDecimalString(pos.position_value)
+  const initialMarginRequirement = divideDecimalString(
+    multiplyDecimalString(positionValue, imf),
+    '100'
   )
-  const initialMarginRequirement = positionValue.times(imf).div(100)
-  const marginUsed = isIsolated
-    ? pos.allocated_margin
-    : initialMarginRequirement.toFixed()
 
   return {
     market,
     side: pos.sign >= 0 ? PositionSide.LONG : PositionSide.SHORT,
-    size: size.abs().toFixed(),
+    size,
     entryPrice: pos.avg_entry_price,
     markPrice:
-      positionValue.eq(0) || size.eq(0)
+      isDecimalStringZero(positionValue) || isDecimalStringZero(size)
         ? '0'
-        : positionValue.div(size.abs()).toFixed(),
+        : divideDecimalString(positionValue, size),
     liquidationPrice: pos.liquidation_price,
     unrealizedPnl: pos.unrealized_pnl,
     accruedFunding: pos.total_funding_paid_out ?? '0',
-    leverage: leverageFromImf(pos.initial_margin_fraction) ?? 1,
-    marginUsed,
-    initialMarginRequirement: initialMarginRequirement.toFixed(),
+    leverage,
+    marginUsed: isIsolated ? pos.allocated_margin : initialMarginRequirement,
+    initialMarginRequirement,
     marginMode: isIsolated ? MarginMode.ISOLATED : MarginMode.CROSS,
   }
 }

package/src/utils/rowTimestamp.ts

@@ -0,0 +1,15 @@
+import { timestampToIsoString } from '@lifi/perps-sdk'
+
+/**
+ * Read a venue row time as an ISO-8601 string, or `undefined` when the time is
+ * not valid. The caller logs the row skip, so this logs nothing.
+ */
+export const rowTimestampToIsoStringOrUndefined = (
+  value: string | number
+): string | undefined => {
+  try {
+    return timestampToIsoString(value)
+  } catch {
+    return undefined
+  }
+}

package/src/utils/settlementPool.ts

@@ -1,11 +1,21 @@
-import type Big from 'big.js'
+import {
+  addDecimalString,
+  isDecimalStringGreaterThan,
+  subtractDecimalString,
+  unknownToDecimalString,
+} from '@lifi/perps-sdk'
+import { LIGHTER_PROVIDER_KEY } from '../constants.js'
 import type { LtAccountAsset } from '../types/account.js'
-import { toRequiredBig } from './decimal.js'
 
 /** Both routes of a unified account's settlement asset, as one holding. */
-export const pooledSettlementUnits = (asset: LtAccountAsset): Big =>
-  toRequiredBig(asset.balance, 'balance').plus(
-    toRequiredBig(asset.margin_balance, 'margin_balance')
+export const pooledSettlementUnits = (asset: LtAccountAsset): string =>
+  addDecimalString(
+    unknownToDecimalString(asset.balance, 'balance', LIGHTER_PROVIDER_KEY),
+    unknownToDecimalString(
+      asset.margin_balance,
+      'margin_balance',
+      LIGHTER_PROVIDER_KEY
+    )
   )
 
 /**
@@ -16,12 +26,26 @@ export const pooledSettlementUnits = (asset: LtAccountAsset): Big =>
  */
 export const pooledSettlementSpendable = (
   asset: LtAccountAsset,
-  availableBalance: Big
-): Big => {
-  const marginBalance = toRequiredBig(asset.margin_balance, 'margin_balance')
-  return toRequiredBig(asset.balance, 'balance')
-    .minus(toRequiredBig(asset.locked_balance, 'locked_balance'))
-    .plus(marginBalance.lt(availableBalance) ? marginBalance : availableBalance)
+  availableBalance: string
+): string => {
+  const marginBalance = unknownToDecimalString(
+    asset.margin_balance,
+    'margin_balance',
+    LIGHTER_PROVIDER_KEY
+  )
+  return addDecimalString(
+    subtractDecimalString(
+      unknownToDecimalString(asset.balance, 'balance', LIGHTER_PROVIDER_KEY),
+      unknownToDecimalString(
+        asset.locked_balance,
+        'locked_balance',
+        LIGHTER_PROVIDER_KEY
+      )
+    ),
+    isDecimalStringGreaterThan(marginBalance, availableBalance)
+      ? availableBalance
+      : marginBalance
+  )
 }
 
 /** Spot-route `balance` of the collateral asset; `'0'` when the account holds none. */
@@ -32,5 +56,5 @@ export const collateralSpotBalance = (
   const asset = assets.find((a) => a.asset_id === settlementAssetIndex)
   return asset === undefined
     ? '0'
-    : toRequiredBig(asset.balance, 'balance').toFixed()
+    : unknownToDecimalString(asset.balance, 'balance', LIGHTER_PROVIDER_KEY)
 }

package/src/utils/spotPrice.ts

@@ -1,6 +1,10 @@
+import {
+  isDecimalStringGreaterThan,
+  multiplyDecimalString,
+  unknownToDecimalString,
+} from '@lifi/perps-sdk'
 import type { Market, MarketContext } from '@lifi/perps-types'
-import Big from 'big.js'
-import { toRequiredBig } from './decimal.js'
+import { LIGHTER_PROVIDER_KEY } from '../constants.js'
 
 /**
  * Unit prices keyed by spot base `Asset.id` (the venue `asset_id`), read from
@@ -17,9 +21,9 @@ export const spotPriceByAssetId = (
   spotCategoryId: string,
   contexts: readonly MarketContext[],
   assetIds: ReadonlySet<string>
-): Map<string, Big> => {
+): Map<string, string> => {
   const markByMarketId = new Map(contexts.map((c) => [c.marketId, c.markPrice]))
-  const priceByAssetId = new Map<string, Big>()
+  const priceByAssetId = new Map<string, string>()
   for (const market of markets) {
     const mark = markByMarketId.get(market.id)
     if (
@@ -30,8 +34,12 @@ export const spotPriceByAssetId = (
     ) {
       continue
     }
-    const price = toRequiredBig(mark, 'markPrice')
-    if (price.gt(0)) {
+    const price = unknownToDecimalString(
+      mark,
+      'markPrice',
+      LIGHTER_PROVIDER_KEY
+    )
+    if (isDecimalStringGreaterThan(price, '0')) {
       priceByAssetId.set(market.baseAsset.id, price)
     }
   }
@@ -47,13 +55,11 @@ export const spotValuation = (
   assetId: number,
   units: string,
   settlementAssetIndex: number,
-  spotPrices: ReadonlyMap<string, Big>
-): { valueUsd: string; price?: Big } => {
+  spotPrices: ReadonlyMap<string, string>
+): { valueUsd: string; price?: string } => {
   const price =
-    assetId === settlementAssetIndex
-      ? new Big(1)
-      : spotPrices.get(String(assetId))
+    assetId === settlementAssetIndex ? '1' : spotPrices.get(String(assetId))
   return price === undefined
     ? { valueUsd: '0' }
-    : { valueUsd: new Big(units).times(price).toFixed(), price }
+    : { valueUsd: multiplyDecimalString(units, price), price }
 }

package/src/utils/time.ts

@@ -1,6 +1,16 @@
-/** Convert seconds since unix epoch to ISO-8601. */
+import { timestampToIsoString } from '@lifi/perps-sdk'
+
+/**
+ * Convert seconds since unix epoch to ISO-8601.
+ *
+ * @throws {PerpsError} `ValidationError` when `seconds` is not a valid time.
+ */
 export const toIsoFromSeconds = (seconds: number): string =>
-  new Date(seconds * 1000).toISOString()
+  timestampToIsoString(seconds * 1000)
 
-/** Convert milliseconds since unix epoch to ISO-8601. */
-export const toIsoFromMs = (ms: number): string => new Date(ms).toISOString()
+/**
+ * Convert milliseconds since unix epoch to ISO-8601.
+ *
+ * @throws {PerpsError} `ValidationError` when `ms` is not a valid time.
+ */
+export const toIsoFromMs = (ms: number): string => timestampToIsoString(ms)