@lifi/perps-types 0.1.1-alpha.2 → 0.1.1-alpha.22

package/src/providers/hyperliquid/mappers/activity.ts

@@ -0,0 +1,94 @@
+import { ActivityType } from '../../../enums.js'
+import type {
+  ActivityItem,
+  DepositActivity,
+  WithdrawalActivity,
+  LiquidationActivity,
+  FundingActivity,
+} from '../../../account.js'
+import type { HlLedgerUpdate, HlFundingUpdate } from '../types.js'
+
+/**
+ * Map a Hyperliquid non-funding ledger entry to an ActivityItem.
+ * Returns null for unsupported delta types (accountClassTransfer,
+ * internalTransfer, subAccountTransfer, spotTransfer).
+ */
+export const mapLedgerEntry = (
+  entry: HlLedgerUpdate,
+  providerKey: string
+): ActivityItem | null => {
+  const { delta } = entry
+  const base = {
+    id: entry.hash,
+    provider: providerKey,
+    timestamp: new Date(entry.time).toISOString(),
+  }
+
+  switch (delta.type) {
+    case 'deposit':
+      return {
+        ...base,
+        type: ActivityType.DEPOSIT,
+        amount: delta.usdc ?? '0',
+      } satisfies DepositActivity
+
+    case 'withdraw':
+      return {
+        ...base,
+        type: ActivityType.WITHDRAWAL,
+        amount: delta.usdc ?? '0',
+        fee: (delta as { fee?: string }).fee ?? '0',
+      } satisfies WithdrawalActivity
+
+    case 'liquidation': {
+      const d = delta as unknown as {
+        type: string
+        liquidatedNtlPos: string
+        accountValue: string
+        leverageType: string
+        liquidatedPositions?: { coin: string; szi: string }[]
+      }
+      return {
+        ...base,
+        type: ActivityType.LIQUIDATION,
+        liquidatedNotionalPosition: d.liquidatedNtlPos,
+        accountValue: d.accountValue,
+        leverageType: d.leverageType,
+        liquidatedPositions: (d.liquidatedPositions ?? []).map((p) => ({
+          asset: {
+            assetId: p.coin,
+            market: '',
+            displaySymbol: p.coin,
+            displayQuote: null,
+          },
+          size: p.szi,
+        })),
+      } satisfies LiquidationActivity
+    }
+
+    default:
+      return null
+  }
+}
+
+/**
+ * Map a Hyperliquid funding entry to a FundingActivity.
+ */
+export const mapFundingActivity = (
+  entry: HlFundingUpdate,
+  providerKey: string
+): FundingActivity => ({
+  id: entry.hash,
+  provider: providerKey,
+  timestamp: new Date(entry.time).toISOString(),
+  type: ActivityType.FUNDING,
+  asset: {
+    assetId: entry.delta.coin,
+    market: '',
+    displaySymbol: entry.delta.coin,
+    displayQuote: null,
+  },
+  amount: entry.delta.usdc,
+  positionSize: entry.delta.szi,
+  fundingRate: entry.delta.fundingRate,
+})

package/src/providers/hyperliquid/mappers/{market.ts → asset.ts}

@@ -1,26 +1,22 @@
-import type { Market } from '../../../market.js'
-import { calculateAssetId } from '../assetId.js'
+import type { Asset } from '../../../asset.js'
 import type { HlAssetCtx, HlUniverseItem } from '../types.js'
 
 const NEXT_FUNDING_INTERVAL_MS = 60 * 60 * 1000 // 1 hour
 
-export const mapMarket = (
+export const mapAsset = (
   universe: HlUniverseItem,
-  assetCtx: HlAssetCtx,
-  dexIndex: number,
-  indexInDex: number,
-  dexKey: string
-): Market => {
+  assetCtx: HlAssetCtx
+): Asset => {
   const now = Date.now()
   const nextFundingTime =
     Math.ceil(now / NEXT_FUNDING_INTERVAL_MS) * NEXT_FUNDING_INTERVAL_MS
 
   return {
-    symbol: universe.name,
-    name: universe.name,
+    assetId: universe.name,
+    market: '',
+    displaySymbol: universe.name,
+    displayQuote: null,
     logoURI: `https://app.hyperliquid.xyz/coins/${universe.name}.svg`,
-    assetId: calculateAssetId(dexIndex, indexInDex),
-    dex: dexKey,
     szDecimals: universe.szDecimals,
     maxLeverage: universe.maxLeverage,
     onlyIsolated: universe.onlyIsolated === true,
@@ -30,6 +26,7 @@ export const mapMarket = (
     },
     openInterest: assetCtx.openInterest,
     volume24h: assetCtx.dayNtlVlm,
+    prevDayPrice: assetCtx.prevDayPx,
     markPrice: assetCtx.markPx,
   }
 }

package/src/providers/hyperliquid/mappers/fill.ts

@@ -0,0 +1,77 @@
+import {
+  FillClassification,
+  FillStatus,
+  OrderSide,
+  OrderType,
+} from '../../../enums.js'
+import type { Fill } from '../../../account.js'
+import type { HlUserFill } from '../types.js'
+import { assetIsSpot } from '../assetId.js'
+
+export function classifyFillFromPosition(
+  startPosition: string,
+  side: string,
+  sz: string
+): FillClassification {
+  const start = parseFloat(startPosition)
+  const delta = side === 'B' ? parseFloat(sz) : -parseFloat(sz)
+  const end = start + delta
+
+  // Position was flat → opening
+  if (start === 0) {
+    return end > 0
+      ? FillClassification.OPENED_LONG
+      : FillClassification.OPENED_SHORT
+  }
+
+  // Position was long
+  if (start > 0) {
+    if (end === 0) {
+      return FillClassification.CLOSED_LONG
+    }
+    if (end < 0) {
+      return FillClassification.SWITCHED_SHORT
+    }
+    if (end > start) {
+      return FillClassification.INCREASED_LONG
+    }
+    return FillClassification.REDUCED_LONG
+  }
+
+  // Position was short (start < 0)
+  if (end === 0) {
+    return FillClassification.CLOSED_SHORT
+  }
+  if (end > 0) {
+    return FillClassification.SWITCHED_LONG
+  }
+  if (end < start) {
+    return FillClassification.INCREASED_SHORT
+  }
+  return FillClassification.REDUCED_SHORT
+}
+
+export const mapFill = (fill: HlUserFill): Fill => ({
+  id: String(fill.tid),
+  asset: {
+    assetId: fill.coin,
+    market: '',
+    displaySymbol: fill.coin,
+    displayQuote: null,
+  },
+  side: fill.side === 'B' ? OrderSide.BUY : OrderSide.SELL,
+  type: fill.dir?.includes('Limit') ? OrderType.LIMIT : OrderType.MARKET,
+  size: fill.sz,
+  price: fill.px,
+  status: FillStatus.FILLED,
+  filledSize: fill.sz,
+  fee: fill.fee,
+  realizedPnl: fill.closedPnl === '0' ? null : fill.closedPnl,
+  startPosition: fill.startPosition,
+  classification: assetIsSpot(fill.coin)
+    ? fill.side === 'B'
+      ? FillClassification.SPOT_BUY
+      : FillClassification.SPOT_SELL
+    : classifyFillFromPosition(fill.startPosition, fill.side, fill.sz),
+  createdAt: new Date(fill.time).toISOString(),
+})

package/src/providers/hyperliquid/mappers/index.ts

@@ -1,5 +1,11 @@
-export { resolveAssetIdFromLookup } from './shared.js'
-export { mapMarket } from './market.js'
-export { mapOpenOrder, mapOrder } from './order.js'
+export { mapAsset } from './asset.js'
+export {
+  isTriggerType,
+  mapOpenOrder,
+  mapOrder,
+  mapOrderType,
+  mapTriggerOrder,
+} from './order.js'
 export { mapPosition } from './position.js'
-export { mapHistoryItem } from './history.js'
+export { classifyFillFromPosition, mapFill } from './fill.js'
+export { mapLedgerEntry, mapFundingActivity } from './activity.js'

package/src/providers/hyperliquid/mappers/order.ts

@@ -4,32 +4,75 @@ import {
   OrderType,
   TimeInForce,
 } from '../../../enums.js'
-import type { OpenOrder } from '../../../account.js'
-import type { Order } from '../../../trading.js'
+import type { OpenOrder, TriggerOrder } from '../../../account.js'
+import type { Order } from '../../../action.js'
 import type { HlFrontendOpenOrder, HlOrderDetail } from '../types.js'
 
-import { resolveAssetIdFromLookup } from './shared.js'
+/** Map a Hyperliquid orderType string to the OrderType enum. */
+export const mapOrderType = (orderType: string): OrderType => {
+  switch (orderType) {
+    case 'Take Profit Market':
+      return OrderType.TAKE_PROFIT_MARKET
+    case 'Take Profit Limit':
+      return OrderType.TAKE_PROFIT_LIMIT
+    case 'Stop Market':
+      return OrderType.STOP_MARKET
+    case 'Stop Limit':
+      return OrderType.STOP_LIMIT
+    case 'Market':
+      return OrderType.MARKET
+    default:
+      return OrderType.LIMIT
+  }
+}
 
-export const mapOpenOrder = (
-  o: HlFrontendOpenOrder,
-  dexKey: string,
-  assetIdLookup: Map<string, number>
-): OpenOrder => ({
+export const isTriggerType = (type: OrderType): boolean =>
+  type === OrderType.TAKE_PROFIT_MARKET ||
+  type === OrderType.TAKE_PROFIT_LIMIT ||
+  type === OrderType.STOP_MARKET ||
+  type === OrderType.STOP_LIMIT
+
+export const mapOpenOrder = (o: HlFrontendOpenOrder): OpenOrder => ({
   id: String(o.oid),
-  symbol: o.coin,
-  assetId: resolveAssetIdFromLookup(assetIdLookup, o.coin),
-  dex: dexKey,
+  asset: {
+    assetId: o.coin,
+    market: '',
+    displaySymbol: o.coin,
+    displayQuote: null,
+  },
   side: o.side === 'B' ? OrderSide.BUY : OrderSide.SELL,
-  type: o.orderType === 'Limit' ? OrderType.LIMIT : OrderType.MARKET,
+  type: mapOrderType(o.orderType),
   size: o.sz,
   price: o.limitPx,
   filledSize: o.origSz
     ? (parseFloat(o.origSz) - parseFloat(o.sz)).toString()
     : '0',
   reduceOnly: o.reduceOnly ?? false,
+  label: o.isTrigger ? o.triggerCondition : undefined,
   createdAt: new Date(o.timestamp).toISOString(),
 })
 
+export const mapTriggerOrder = (o: HlFrontendOpenOrder): TriggerOrder => {
+  const type = mapOrderType(o.orderType)
+  const isLimit =
+    type === OrderType.TAKE_PROFIT_LIMIT || type === OrderType.STOP_LIMIT
+  return {
+    id: String(o.oid),
+    asset: {
+      assetId: o.coin,
+      market: '',
+      displaySymbol: o.coin,
+      displayQuote: null,
+    },
+    type,
+    size: o.sz,
+    triggerPrice: o.triggerPx,
+    ...(isLimit ? { limitPrice: o.limitPx } : {}),
+    label: o.triggerCondition,
+    createdAt: new Date(o.timestamp).toISOString(),
+  }
+}
+
 const mapOrderStatus = (status: string): OrderStatus => {
   switch (status) {
     case 'open':
@@ -70,10 +113,14 @@ export const mapOrder = (detail: HlOrderDetail): Order => {
 
   return {
     orderId: String(o.oid),
-    clientOrderId: o.cloid ?? undefined,
-    symbol: o.coin,
+    asset: {
+      assetId: o.coin,
+      market: '',
+      displaySymbol: o.coin,
+      displayQuote: null,
+    },
     side: o.side === 'B' ? OrderSide.BUY : OrderSide.SELL,
-    type: o.orderType === 'Limit' ? OrderType.LIMIT : OrderType.MARKET,
+    type: mapOrderType(o.orderType),
     price: o.limitPx,
     originalSize: o.origSz,
     remainingSize: o.sz,

package/src/providers/hyperliquid/mappers/position.ts

@@ -2,20 +2,17 @@ import { MarginMode, PositionSide } from '../../../enums.js'
 import type { Position } from '../../../account.js'
 import type { HlAssetPosition } from '../types.js'
 
-import { resolveAssetIdFromLookup } from './shared.js'
-
-export const mapPosition = (
-  ap: HlAssetPosition,
-  dexKey: string,
-  assetIdLookup: Map<string, number>
-): Position => {
+export const mapPosition = (ap: HlAssetPosition): Position => {
   const pos = ap.position
   const szi = parseFloat(pos.szi)
 
   return {
-    symbol: pos.coin,
-    assetId: resolveAssetIdFromLookup(assetIdLookup, pos.coin),
-    dex: dexKey,
+    asset: {
+      assetId: pos.coin,
+      market: '',
+      displaySymbol: pos.coin,
+      displayQuote: null,
+    },
     side: szi >= 0 ? PositionSide.LONG : PositionSide.SHORT,
     size: Math.abs(szi).toString(),
     entryPrice: pos.entryPx ?? '0',

package/src/providers/hyperliquid/mappers/shared.ts

@@ -1,15 +0,0 @@
-/**
- * Look up an asset ID by symbol, throwing if the symbol is unknown.
- * Asset ID 0 is a valid Hyperliquid asset (BTC-PERP), so a fallback
- * to 0 would silently corrupt data.
- */
-export const resolveAssetIdFromLookup = (
-  lookup: Map<string, number>,
-  symbol: string
-): number => {
-  const id = lookup.get(symbol)
-  if (id === undefined) {
-    throw new Error(`Unknown asset symbol: ${symbol}`)
-  }
-  return id
-}

package/src/providers/hyperliquid/types.ts

@@ -1,5 +1,5 @@
 // ---------------------------------------------------------------------------
-// Hand-written Hyperliquid /info response types
+// Hyperliquid /info response types
 // ---------------------------------------------------------------------------
 
 // -- metaAndAssetCtxs -------------------------------------------------------
@@ -8,16 +8,19 @@ export type HlUniverseItem = {
   name: string
   szDecimals: number
   maxLeverage: number
-  onlyIsolated: boolean
-  isDelisted: boolean
+  onlyIsolated?: boolean
+  isDelisted?: boolean
 }
 
-export type HlMeta = { universe: HlUniverseItem[] }
+export type HlMeta = {
+  universe: HlUniverseItem[]
+}
 
 export type HlAssetCtx = {
   funding: string
   openInterest: string
   dayNtlVlm: string
+  prevDayPx: string
   markPx: string
 }
 
@@ -44,7 +47,11 @@ export type HlCandleSnapshot = HlCandle[]
 
 // -- l2Book -----------------------------------------------------------------
 
-export type HlLevel = { px: string; sz: string; n: number }
+export type HlLevel = {
+  px: string
+  sz: string
+  n: number
+}
 
 export type HlL2Book = {
   levels: [HlLevel[], HlLevel[]]
@@ -61,15 +68,26 @@ export type HlPosition = {
   liquidationPx: string
   unrealizedPnl: string
   marginUsed: string
-  leverage: { type: string; value: number }
+  leverage: {
+    type: string
+    value: number
+  }
 }
 
-export type HlAssetPosition = { position: HlPosition }
+export type HlAssetPosition = {
+  position: HlPosition
+}
 
 export type HlClearinghouseState = {
   assetPositions: HlAssetPosition[]
-  marginSummary: { accountValue: string; totalMarginUsed: string }
-  crossMarginSummary: { accountValue: string; totalMarginUsed: string }
+  marginSummary: {
+    accountValue: string
+    totalMarginUsed: string
+  }
+  crossMarginSummary: {
+    accountValue: string
+    totalMarginUsed: string
+  }
 }
 
 // -- spotClearinghouseState -------------------------------------------------
@@ -106,13 +124,20 @@ export type HlFrontendOpenOrder = {
   origSz: string
   reduceOnly: boolean
   timestamp: number
+  isTrigger: boolean
+  isPositionTpsl: boolean
+  triggerCondition: string
+  triggerPx: string
+  children: HlFrontendOpenOrder[]
+  tif: string | null
+  cloid: string | null
 }
 
 export type HlFrontendOpenOrders = HlFrontendOpenOrder[]
 
 // -- extraAgents ------------------------------------------------------------
 
-export type HlExtraAgents = Array<Record<string, unknown>>
+export type HlExtraAgents = Record<string, unknown>[]
 
 // -- userFills / userFillsByTime --------------------------------------------
 
@@ -126,6 +151,7 @@ export type HlUserFill = {
   fee: string
   closedPnl: string
   time: number
+  startPosition: string
 }
 
 export type HlUserFills = HlUserFill[]
@@ -134,11 +160,6 @@ export type HlUserFillsByTime = HlUserFill[]
 
 // -- orderStatus ------------------------------------------------------------
 
-export type HlOrderStatusFound = {
-  status: 'order'
-  order: HlOrderDetail
-}
-
 export type HlOrderDetail = {
   order: {
     oid: number
@@ -159,21 +180,80 @@ export type HlOrderDetail = {
   statusTimestamp: number
 }
 
+export type HlOrderStatusFound = {
+  status: 'order'
+  order: HlOrderDetail
+}
+
 export type HlOrderStatusResponse =
   | HlOrderStatusFound
   | { status: 'unknownOid' }
 
+// -- userNonFundingLedgerUpdates --------------------------------------------
+
+export type HlLedgerDelta = {
+  type: string
+  usdc?: string
+  [key: string]: unknown
+}
+
+export type HlLedgerUpdate = {
+  time: number
+  hash: string
+  delta: HlLedgerDelta
+}
+
+export type HlUserNonFundingLedgerUpdates = HlLedgerUpdate[]
+
+// -- userFunding ------------------------------------------------------------
+
+export type HlFundingDelta = {
+  type: 'funding'
+  coin: string
+  usdc: string
+  szi: string
+  fundingRate: string
+}
+
+export type HlFundingUpdate = {
+  time: number
+  hash: string
+  delta: HlFundingDelta
+}
+
+export type HlUserFunding = HlFundingUpdate[]
+
+// -- abstraction mode -------------------------------------------------------
+
+/**
+ * Possible values returned by the `userAbstraction` info endpoint.
+ * `null` means abstraction has never been set (standard mode).
+ */
+export const HlAbstractionMode = {
+  DISABLED: 'disabled',
+  UNIFIED_ACCOUNT: 'unifiedAccount',
+  PORTFOLIO_MARGIN: 'portfolioMargin',
+  DEX_ABSTRACTION: 'dexAbstraction',
+} as const
+
+export type HlAbstractionMode =
+  (typeof HlAbstractionMode)[keyof typeof HlAbstractionMode]
+
 // -- perpDexs ---------------------------------------------------------------
 
-export type HlPerpDexs = Array<null | { name: string }>
+export type HlPerpDexs = (null | { name: string })[]
 
 // ---------------------------------------------------------------------------
-// Exchange request types
+// Exchange request / response types
 // ---------------------------------------------------------------------------
 
 export type HlExchangeRequest = {
   action: Record<string, unknown>
-  signature: { r: string; s: string; v: number }
+  signature: {
+    r: string
+    s: string
+    v: number
+  }
   nonce: number
   vaultAddress?: string | null
 }
@@ -185,7 +265,7 @@ export type HlExchangeResponse = {
     | {
         type: string
         data?: {
-          statuses?: Array<
+          statuses?: (
             | string
             | { filled: { totalSz: string; avgPx: string; oid: number } }
             | { resting: { oid: number } }
@@ -193,8 +273,35 @@ export type HlExchangeResponse = {
             | { waitingForTrigger: { oid: number } }
             | { success: true }
             | { error: string }
-          >
+          )[]
           status?: unknown
         }
       }
 }
+
+// ---------------------------------------------------------------------------
+// Hyperliquid EIP-712 primary type constants
+// ---------------------------------------------------------------------------
+
+export const HL_PRIMARY_TYPE_APPROVE_AGENT =
+  'HyperliquidTransaction:ApproveAgent' as const
+export const HL_PRIMARY_TYPE_APPROVE_BUILDER_FEE =
+  'HyperliquidTransaction:ApproveBuilderFee' as const
+export const HL_PRIMARY_TYPE_USER_SET_ABSTRACTION =
+  'HyperliquidTransaction:UserSetAbstraction' as const
+export const HL_PRIMARY_TYPE_AGENT_SET_ABSTRACTION =
+  'HyperliquidTransaction:AgentSetAbstraction' as const
+export const HL_PRIMARY_TYPE_WITHDRAW =
+  'HyperliquidTransaction:Withdraw' as const
+export const HL_PRIMARY_TYPE_SEND_ASSET =
+  'HyperliquidTransaction:SendAsset' as const
+export const HL_PRIMARY_TYPE_AGENT = 'Agent' as const
+
+export type HlPrimaryType =
+  | typeof HL_PRIMARY_TYPE_APPROVE_AGENT
+  | typeof HL_PRIMARY_TYPE_APPROVE_BUILDER_FEE
+  | typeof HL_PRIMARY_TYPE_USER_SET_ABSTRACTION
+  | typeof HL_PRIMARY_TYPE_AGENT_SET_ABSTRACTION
+  | typeof HL_PRIMARY_TYPE_WITHDRAW
+  | typeof HL_PRIMARY_TYPE_SEND_ASSET
+  | typeof HL_PRIMARY_TYPE_AGENT