@lifi/perps-types 0.1.1-alpha.9 → 0.2.0-alpha.0

package/src/enums.ts

@@ -5,6 +5,7 @@ export enum PerpsErrorCode {
   ValidationError = 2002,
   TimeoutError = 2003,
   ThirdPartyError = 2004,
+  SDKError = 2005,
 
   // Auth errors (2010-2019)
   SignatureInvalid = 2010,
@@ -17,6 +18,7 @@ export enum PerpsErrorCode {
   MarketNotFound = 2023,
   OrderNotFound = 2024,
   PositionNotFound = 2025,
+  AccountNotFound = 2026,
 
   // Nonce errors (2040-2049)
   InvalidNonce = 2040,
@@ -38,6 +40,11 @@ export enum OrderSide {
 export enum OrderType {
   MARKET = 'MARKET',
   LIMIT = 'LIMIT',
+  STOP_MARKET = 'STOP_MARKET',
+  STOP_LIMIT = 'STOP_LIMIT',
+  TAKE_PROFIT_MARKET = 'TAKE_PROFIT_MARKET',
+  TAKE_PROFIT_LIMIT = 'TAKE_PROFIT_LIMIT',
+  TRIGGER_ONLY = 'TRIGGER_ONLY',
 }
 
 export enum PositionSide {
@@ -68,18 +75,46 @@ export enum OrderStatus {
   TRIGGERED = 'TRIGGERED',
 }
 
-export enum HistoryItemStatus {
+export enum FillStatus {
   FILLED = 'FILLED',
   PARTIALLY_FILLED = 'PARTIALLY_FILLED',
   CANCELLED = 'CANCELLED',
   REJECTED = 'REJECTED',
 }
 
-export enum OrderActionType {
-  UPDATE_LEVERAGE = 'updateLeverage',
+export enum LiquidityRole {
+  MAKER = 'maker',
+  TAKER = 'taker',
+}
+
+export enum ActionType {
+  APPROVE_AGENT = 'approveAgent',
+  APPROVE_BUILDER_FEE = 'approveBuilderFee',
+  /**
+   * Generic account-level operating mode (e.g. Hyperliquid abstraction
+   * variants, Lighter UTA / Simple). HL maps it to the appropriate
+   * EIP-712 typed-data builder internally.
+   */
+  ACCOUNT_MODE = 'accountMode',
+  /**
+   * Generic account-level fee/latency tier (e.g. Lighter standard /
+   * premium). Providers that have no tiering (Hyperliquid) omit this
+   * action from their descriptor list.
+   */
+  ACCOUNT_TYPE = 'accountType',
+  SEND_ASSET = 'sendAsset',
+  WITHDRAWAL = 'withdrawal',
+  TRANSFER = 'transfer',
   PLACE_ORDER = 'placeOrder',
   PLACE_TRIGGER_ORDER = 'placeTriggerOrder',
   CANCEL_ORDER = 'cancelOrder',
+  CANCEL_ALL_ORDERS = 'cancelAllOrders',
+  MODIFY_ORDER = 'modifyOrder',
+  UPDATE_LEVERAGE = 'updateLeverage',
+  UPDATE_POSITION_MARGIN = 'updatePositionMargin',
+  REGISTER_API_KEY = 'registerApiKey',
+  APPROVE_READ_ONLY_TOKEN = 'approveReadOnlyToken',
+  DEPOSIT = 'deposit',
 }
 
 export enum TriggerCondition {
@@ -103,4 +138,51 @@ export enum ActivityType {
   WITHDRAWAL = 'WITHDRAWAL',
   LIQUIDATION = 'LIQUIDATION',
   FUNDING = 'FUNDING',
+  TRANSFER = 'TRANSFER',
+}
+
+export enum FillClassification {
+  OPENED_LONG = 'Opened Long',
+  OPENED_SHORT = 'Opened Short',
+  INCREASED_LONG = 'Increased Long',
+  INCREASED_SHORT = 'Increased Short',
+  REDUCED_LONG = 'Reduced Long',
+  REDUCED_SHORT = 'Reduced Short',
+  CLOSED_LONG = 'Closed Long',
+  CLOSED_SHORT = 'Closed Short',
+  SWITCHED_LONG = 'Switched Long',
+  SWITCHED_SHORT = 'Switched Short',
+  SPOT_BUY = 'Spot Buy',
+  SPOT_SELL = 'Spot Sell',
+}
+
+export enum LiquidationClassification {
+  LIQUIDATED = 'Liquidated',
+}
+
+export enum FundingClassification {
+  FUNDING = 'Funding',
+}
+
+export enum TransferClassification {
+  DEPOSIT = 'Deposit',
+  WITHDRAWAL = 'Withdrawal',
+}
+
+export type ActivityClassification =
+  | FillClassification
+  | LiquidationClassification
+  | FundingClassification
+  | TransferClassification
+
+export enum PerpsSigner {
+  USER = 'USER',
+  AGENT = 'AGENT',
+  API_KEY = 'API_KEY',
+}
+
+export enum SigningMethod {
+  EIP712 = 'eip712',
+  WASM_BLOB = 'wasmBlob',
+  EVM_TX = 'evmTx',
 }

package/src/index.ts

@@ -1,9 +1,8 @@
 export * from './typedData.js'
 export * from './enums.js'
-export * from './market.js'
-export * from './authorization.js'
+export * from './providers.js'
+export * from './asset.js'
+export * from './action.js'
 export * from './account.js'
-export * from './trading.js'
-export * from './withdrawal.js'
 export * from './errors.js'
 export * from './subscriptions.js'

package/src/providers/_shared/fillClassification.ts

@@ -0,0 +1,50 @@
+import { FillClassification } from '../../enums.js'
+
+/**
+ * Classify a perpetual fill into the Open/Close/Increase/Reduce/Switch
+ * taxonomy from `FillClassification`.
+ *
+ * @param startPosition Signed position held BEFORE this fill (`> 0` long,
+ *   `< 0` short, `0` flat).
+ * @param side Hyperliquid-style: `'B'` for buy, anything else for sell.
+ * @param sz Unsigned fill size, parsed with `parseFloat`.
+ */
+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
+
+  if (start === 0) {
+    return end > 0
+      ? FillClassification.OPENED_LONG
+      : FillClassification.OPENED_SHORT
+  }
+
+  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
+  }
+
+  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
+}

package/src/providers/hyperliquid/assetId.ts

@@ -1,26 +1,32 @@
+/** Spot asset IDs use the @pairIndex format (e.g. "@230"). */
+export const assetIsSpot = (assetId: string): boolean => assetId.startsWith('@')
+
 /**
- * Calculate the asset ID for a given DEX index and asset index.
+ * Calculate the asset ID for a given provider index and asset index.
  *
- * Main DEX (dex = ''): assetId = indexInDex
- * HIP-3 DEXes (dex = 'xyz'): assetId = 100_000 + perpDexIndex * 10_000 + indexInDex
+ * Main provider (provider = ''): assetId = indexInProvider
+ * HIP-3 providers (provider = 'xyz'): assetId = 100_000 + perpDexIndex * 10_000 + indexInProvider
  */
 export const calculateAssetId = (
-  dexIndex: number,
-  indexInDex: number
+  providerIndex: number,
+  indexInProvider: number
 ): number => {
-  if (dexIndex === 0) {
-    return indexInDex
+  if (providerIndex === 0) {
+    return indexInProvider
   }
-  return 100_000 + dexIndex * 10_000 + indexInDex
+  return 100_000 + providerIndex * 10_000 + indexInProvider
 }
 
 /**
- * Get the DEX index from the given list of dex names.
+ * Get the provider index from the given list of provider names.
  */
-export const getDexIndex = (dex: string, dexNames: string[]): number => {
-  const index = dexNames.indexOf(dex)
+export const getProviderIndex = (
+  provider: string,
+  providerNames: string[]
+): number => {
+  const index = providerNames.indexOf(provider)
   if (index === -1) {
-    throw new Error(`Unknown sub-dex: ${dex}`)
+    throw new Error(`Unknown sub-provider: ${provider}`)
   }
   return index
 }

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

@@ -0,0 +1,21 @@
+/**
+ * Derive the `AssetIdentity.market` value (a `/providers.markets[].id`) from
+ * a Hyperliquid `assetId`:
+ * - `"BTC"`      → main USDC perp dex → `"hyperliquid"`
+ * - `"xyz:PURR"` → HIP-3 sub-dex      → `"xyz"`
+ * - `"@142"`     → spot pair          → `"spot"`
+ *
+ * Must stay in lockstep with `lifi-perps-backend`'s `toProviderMarketId` /
+ * `buildAssetMarketLookup` — they define the same `/providers.markets[].id`
+ * taxonomy on the wire.
+ */
+export const deriveMarket = (assetId: string): string => {
+  if (assetId.startsWith('@')) {
+    return 'spot'
+  }
+  const colon = assetId.indexOf(':')
+  if (colon > 0) {
+    return assetId.slice(0, colon)
+  }
+  return 'hyperliquid'
+}

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

@@ -5,38 +5,116 @@ import type {
   WithdrawalActivity,
   LiquidationActivity,
   FundingActivity,
+  TransferActivity,
 } from '../../../account.js'
+import { isSendAssetDelta, isSpotTransferDelta } from '../types.js'
 import type { HlLedgerUpdate, HlFundingUpdate } from '../types.js'
+import { deriveMarket } from './_market.js'
 
 /**
  * Map a Hyperliquid non-funding ledger entry to an ActivityItem.
- * Returns null for unsupported delta types (accountClassTransfer,
- * internalTransfer, subAccountTransfer, spotTransfer).
+ *
+ * Direction for `spotTransfer` and `sendAsset` is derived from
+ * `queriedAddress` matching the delta's `user` (OUT) or `destination` (IN).
+ * Returns null for unsupported delta types and for same-user `sendAsset`
+ * dex moves (where `user === destination === queriedAddress`).
  */
 export const mapLedgerEntry = (
   entry: HlLedgerUpdate,
-  dexKey: string
+  providerKey: string,
+  queriedAddress: string
 ): ActivityItem | null => {
   const { delta } = entry
   const base = {
     id: entry.hash,
-    dex: dexKey,
+    provider: providerKey,
     timestamp: new Date(entry.time).toISOString(),
   }
 
+  // Handled before the switch: the catch-all arm of `HlLedgerDelta` is a
+  // structural supertype of the concrete delta, so a `switch (delta.type)`
+  // cannot narrow off the discriminant. The user-defined type guard does.
+  if (isSpotTransferDelta(delta)) {
+    const queried = queriedAddress.toLowerCase()
+    const sender = delta.user.toLowerCase()
+    const recipient = delta.destination.toLowerCase()
+    const direction: 'IN' | 'OUT' = queried === sender ? 'OUT' : 'IN'
+    const counterpartyAddress = direction === 'OUT' ? recipient : sender
+    const meta: Record<string, unknown> = {
+      transferType: 'spotTransfer',
+    }
+    if (delta.usdcValue !== undefined) {
+      meta.usdcValue = delta.usdcValue
+    }
+    if (delta.fee !== undefined) {
+      meta.fee = delta.fee
+    }
+    if (delta.nativeTokenFee !== undefined) {
+      meta.nativeTokenFee = delta.nativeTokenFee
+    }
+    if (delta.nonce !== undefined) {
+      meta.nonce = delta.nonce
+    }
+    return {
+      ...base,
+      type: ActivityType.TRANSFER,
+      direction,
+      counterpartyAddress,
+      asset: delta.token,
+      amount: delta.amount,
+      meta,
+    } satisfies TransferActivity
+  }
+
+  // `sendAsset` (wire `type === 'send'`) covers cross-user transfers
+  // (modelled as TRANSFER) and same-user dex moves (returned as null —
+  // overloading TRANSFER for those would lie about direction). Pre-switch
+  // narrowing for the same reason as spotTransfer.
+  if (isSendAssetDelta(delta)) {
+    const queried = queriedAddress.toLowerCase()
+    const sender = delta.user.toLowerCase()
+    const recipient = delta.destination.toLowerCase()
+
+    if (sender === recipient && sender === queried) {
+      return null
+    }
+
+    const direction: 'IN' | 'OUT' = queried === sender ? 'OUT' : 'IN'
+    const counterpartyAddress = direction === 'OUT' ? recipient : sender
+    const meta: Record<string, unknown> = {
+      transferType: 'sendAsset',
+      sourceDex: delta.sourceDex,
+      destinationDex: delta.destinationDex,
+      usdcValue: delta.usdcValue,
+      fee: delta.fee,
+      nativeTokenFee: delta.nativeTokenFee,
+      feeToken: delta.feeToken,
+      nonce: delta.nonce,
+    }
+    return {
+      ...base,
+      type: ActivityType.TRANSFER,
+      direction,
+      counterpartyAddress,
+      asset: delta.token,
+      amount: delta.amount,
+      meta,
+    } satisfies TransferActivity
+  }
+
   switch (delta.type) {
     case 'deposit':
       return {
         ...base,
         type: ActivityType.DEPOSIT,
-        amount: delta.usdc,
+        amount: delta.usdc ?? '0',
       } satisfies DepositActivity
 
     case 'withdraw':
       return {
         ...base,
         type: ActivityType.WITHDRAWAL,
-        amount: delta.usdc,
+        amount: delta.usdc ?? '0',
         fee: (delta as { fee?: string }).fee ?? '0',
       } satisfies WithdrawalActivity
 
@@ -55,7 +133,12 @@ export const mapLedgerEntry = (
         accountValue: d.accountValue,
         leverageType: d.leverageType,
         liquidatedPositions: (d.liquidatedPositions ?? []).map((p) => ({
-          symbol: p.coin,
+          asset: {
+            assetId: p.coin,
+            market: deriveMarket(p.coin),
+            displaySymbol: p.coin,
+            displayQuote: null,
+          },
           size: p.szi,
         })),
       } satisfies LiquidationActivity
@@ -66,18 +149,20 @@ export const mapLedgerEntry = (
   }
 }
 
-/**
- * Map a Hyperliquid funding entry to a FundingActivity.
- */
 export const mapFundingActivity = (
   entry: HlFundingUpdate,
-  dexKey: string
+  providerKey: string
 ): FundingActivity => ({
   id: entry.hash,
-  dex: dexKey,
+  provider: providerKey,
   timestamp: new Date(entry.time).toISOString(),
   type: ActivityType.FUNDING,
-  symbol: entry.delta.coin,
+  asset: {
+    assetId: entry.delta.coin,
+    market: deriveMarket(entry.delta.coin),
+    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,23 @@
-import type { Market } from '../../../market.js'
-import { calculateAssetId } from '../assetId.js'
+import type { Asset } from '../../../asset.js'
 import type { HlAssetCtx, HlUniverseItem } from '../types.js'
+import { deriveMarket } from './_market.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: deriveMarket(universe.name),
+    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 +27,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,41 @@
+import {
+  FillClassification,
+  FillStatus,
+  LiquidityRole,
+  OrderSide,
+  OrderType,
+} from '../../../enums.js'
+import type { Fill } from '../../../account.js'
+import type { HlUserFill } from '../types.js'
+import { assetIsSpot } from '../assetId.js'
+import { classifyFillFromPosition } from '../../_shared/fillClassification.js'
+import { deriveMarket } from './_market.js'
+
+export { classifyFillFromPosition }
+
+export const mapFill = (fill: HlUserFill): Fill => ({
+  id: String(fill.tid),
+  orderId: String(fill.oid),
+  asset: {
+    assetId: fill.coin,
+    market: deriveMarket(fill.coin),
+    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,
+  liquidity: fill.crossed ? LiquidityRole.TAKER : LiquidityRole.MAKER,
+  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,6 +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,76 @@ 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 { deriveMarket } from './_market.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 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,
-  dexKey: string,
-  assetIdLookup: Map<string, number>
-): OpenOrder => ({
+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: deriveMarket(o.coin),
+    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: deriveMarket(o.coin),
+      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':
@@ -51,6 +95,37 @@ const mapOrderStatus = (status: string): OrderStatus => {
   }
 }
 
+/**
+ * Map a raw Hyperliquid order status to a short English sentence
+ * describing *why* the order ended in a terminal non-FILLED state. Bare
+ * `canceled`/`cancelled`/`rejected` carry no actionable detail and
+ * return `undefined`; so do non-terminal and unknown values.
+ */
+export const mapStatusReason = (status: string): string | undefined => {
+  switch (status) {
+    case 'iocCanceled':
+      return 'Order cancelled: not enough liquidity to fill immediately.'
+    case 'reduceOnlyCanceled':
+      return 'Order cancelled: would not reduce your position.'
+    case 'marginCanceled':
+      return 'Order cancelled: insufficient margin.'
+    case 'liquidatedCanceled':
+      return 'Order cancelled: account was liquidated.'
+    case 'siblingFilledCanceled':
+      return 'Order cancelled: sibling OCO order filled first.'
+    case 'selfTradeCanceled':
+      return 'Order cancelled: would self-trade against your own resting order.'
+    case 'tickRejected':
+      return 'Order rejected: price did not match the tick size.'
+    case 'minTradeNtlRejected':
+      return 'Order rejected: notional value below the minimum trade size.'
+    case 'delistedRejected':
+      return 'Order rejected: market has been delisted.'
+    default:
+      return undefined
+  }
+}
+
 const mapTimeInForce = (tif: string | undefined): TimeInForce | undefined => {
   switch (tif) {
     case 'Gtc':
@@ -70,9 +145,14 @@ export const mapOrder = (detail: HlOrderDetail): Order => {
 
   return {
     orderId: String(o.oid),
-    symbol: o.coin,
+    asset: {
+      assetId: o.coin,
+      market: deriveMarket(o.coin),
+      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,
@@ -82,6 +162,7 @@ export const mapOrder = (detail: HlOrderDetail): Order => {
     isTrigger: o.triggerCondition !== undefined && o.triggerCondition !== 'N/A',
     triggerPrice: o.triggerPx ?? undefined,
     status: mapOrderStatus(detail.status),
+    statusReason: mapStatusReason(detail.status),
     createdAt: new Date(o.timestamp).toISOString(),
     updatedAt: new Date(detail.statusTimestamp).toISOString(),
   }