@lifi/perps-types 0.2.0-alpha.0 → 1.0.1

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

@@ -1,57 +0,0 @@
-import {
-  FillStatus,
-  LiquidityRole,
-  OrderSide,
-  OrderType,
-} from '../../../enums.js'
-import type { Fill } from '../../../account.js'
-import type { LtTrade } from '../apiTypes.js'
-import { classifyFillFromPosition } from '../../_shared/fillClassification.js'
-
-/**
- * Map a raw Lighter trade to the generic Fill type.
- * @param accountIndex - The viewer's Lighter account index (selects buy/sell side and maker/taker role).
- * @param symbol - Resolved symbol (market_id → symbol lookup).
- */
-export const mapFill = (
-  trade: LtTrade,
-  accountIndex: number,
-  symbol: string
-): Fill => {
-  const isBuyer = trade.bid_account_id === accountIndex
-  const isMaker =
-    (trade.is_maker_ask && !isBuyer) || (!trade.is_maker_ask && isBuyer)
-
-  // Lighter publishes both counterparties' position-before snapshots on every
-  // trade row; reading the wrong one mis-classifies when they differ.
-  const startPosition = isMaker
-    ? trade.maker_position_size_before
-    : trade.taker_position_size_before
-
-  return {
-    id: trade.trade_id.toString(),
-    orderId: String(isBuyer ? trade.bid_id : trade.ask_id),
-    asset: {
-      assetId: symbol,
-      market: 'lighter',
-      displaySymbol: symbol,
-      displayQuote: 'USDC',
-    },
-    side: isBuyer ? OrderSide.BUY : OrderSide.SELL,
-    type: OrderType.LIMIT,
-    size: trade.size,
-    price: trade.price,
-    status: FillStatus.FILLED,
-    liquidity: isMaker ? LiquidityRole.MAKER : LiquidityRole.TAKER,
-    fee: isMaker ? trade.maker_fee?.toString() : trade.taker_fee?.toString(),
-    startPosition,
-    // `classifyFillFromPosition` takes an HL-encoded side: `'B'` for buy,
-    // anything else for sell.
-    classification: classifyFillFromPosition(
-      startPosition,
-      isBuyer ? 'B' : 'A',
-      trade.size
-    ),
-    createdAt: new Date(trade.timestamp).toISOString(),
-  }
-}

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

@@ -1,8 +0,0 @@
-export { mapPosition } from './position.js'
-export { mapFill } from './fill.js'
-export {
-  isTriggerType,
-  mapOrder,
-  mapOrderDetail,
-  mapTriggerOrder,
-} from './order.js'

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

@@ -1,184 +0,0 @@
-import {
-  OrderSide,
-  OrderStatus,
-  OrderType,
-  TimeInForce,
-} from '../../../enums.js'
-import type { OpenOrder, TriggerOrder } from '../../../account.js'
-import type { Order } from '../../../action.js'
-import type { LtOrder } from '../apiTypes.js'
-
-// Lighter's `type` enum uses hyphens in the OpenAPI spec but earlier API
-// versions emitted underscores. Tolerate both so we don't silently fall
-// through to LIMIT for stop/take-profit orders.
-const mapOrderType = (ltType: string): OrderType => {
-  const normalized = ltType.replace(/-/g, '_')
-  const map: Record<string, OrderType> = {
-    limit: OrderType.LIMIT,
-    market: OrderType.MARKET,
-    stop_loss: OrderType.STOP_MARKET,
-    stop_loss_limit: OrderType.STOP_LIMIT,
-    take_profit: OrderType.TAKE_PROFIT_MARKET,
-    take_profit_limit: OrderType.TAKE_PROFIT_LIMIT,
-  }
-  return map[normalized] ?? OrderType.LIMIT
-}
-
-const mapTimeInForce = (tif: string): TimeInForce | undefined => {
-  switch (tif.replace(/-/g, '_')) {
-    case 'good_till_time':
-      return TimeInForce.GTT
-    case 'immediate_or_cancel':
-      return TimeInForce.IOC
-    case 'post_only':
-      return TimeInForce.POST_ONLY
-    default:
-      return undefined
-  }
-}
-
-const mapOrderStatus = (status: string): OrderStatus => {
-  if (
-    status === 'open' ||
-    status === 'in-progress' ||
-    status === 'in_progress'
-  ) {
-    return OrderStatus.OPEN
-  }
-  if (status === 'pending') {
-    return OrderStatus.PENDING
-  }
-  if (status === 'filled') {
-    return OrderStatus.FILLED
-  }
-  if (status.startsWith('canceled')) {
-    return OrderStatus.CANCELLED
-  }
-  return OrderStatus.OPEN
-}
-
-/**
- * Map a raw Lighter order status to a short English sentence describing
- * *why* the order ended in a terminal non-FILLED state. Non-terminal
- * statuses, plain `filled`, and unknown values return `undefined`.
- */
-export const mapStatusReason = (status: string): string | undefined => {
-  switch (status) {
-    case 'canceled':
-      return 'Order cancelled.'
-    case 'canceled-post-only':
-      return 'Order cancelled: post-only order would have crossed the book.'
-    case 'canceled-reduce-only':
-      return 'Order cancelled: would not reduce your position.'
-    case 'canceled-position-not-allowed':
-      return 'Order cancelled: position not allowed.'
-    case 'canceled-margin-not-allowed':
-      return 'Order cancelled: insufficient margin.'
-    case 'canceled-too-much-slippage':
-      return 'Order cancelled: slippage exceeded tolerance.'
-    case 'canceled-not-enough-liquidity':
-      return 'Order cancelled: not enough liquidity to fill.'
-    case 'canceled-self-trade':
-      return 'Order cancelled: would self-trade against your own resting order.'
-    case 'canceled-expired':
-      return 'Order expired.'
-    case 'canceled-oco':
-      return 'Order cancelled: sibling OCO order filled or cancelled first.'
-    case 'canceled-child':
-      return 'Order cancelled: parent order was cancelled.'
-    case 'canceled-liquidation':
-      return 'Order cancelled: account was liquidated.'
-    case 'canceled-invalid-balance':
-      return 'Order cancelled: invalid balance.'
-    default:
-      return undefined
-  }
-}
-
-/**
- * True for order types Lighter exposes as TP/SL legs. Mirrors the
- * Hyperliquid helper of the same name so the backend can split a raw
- * Lighter order list into the same `openOrders` / `triggerOrders`
- * buckets the SDK declares on `OrdersResponse`.
- */
-export const isTriggerType = (type: OrderType): boolean =>
-  type === OrderType.TAKE_PROFIT_MARKET ||
-  type === OrderType.TAKE_PROFIT_LIMIT ||
-  type === OrderType.STOP_MARKET ||
-  type === OrderType.STOP_LIMIT
-
-/**
- * Map a raw Lighter trigger order (stop/take-profit, market or limit) to
- * the generic `TriggerOrder` shape. For market variants the `limitPrice`
- * field is omitted; for limit variants `order.price` is the limit and
- * `order.trigger_price` is the activation level.
- */
-export const mapTriggerOrder = (
-  order: LtOrder,
-  symbol: string
-): TriggerOrder => {
-  const type = mapOrderType(order.type)
-  const isLimit =
-    type === OrderType.TAKE_PROFIT_LIMIT || type === OrderType.STOP_LIMIT
-  return {
-    id: order.order_id,
-    asset: {
-      assetId: symbol,
-      market: 'lighter',
-      displaySymbol: symbol,
-      displayQuote: 'USDC',
-    },
-    type,
-    size: order.initial_base_amount,
-    triggerPrice: order.trigger_price,
-    ...(isLimit ? { limitPrice: order.price } : {}),
-    createdAt: new Date(order.created_at * 1000).toISOString(),
-  }
-}
-
-/**
- * Map a raw Lighter order to the generic OpenOrder type.
- * @param symbol - Resolved symbol (market_index → symbol lookup)
- */
-export const mapOrder = (order: LtOrder, symbol: string): OpenOrder => ({
-  id: order.order_id,
-  asset: {
-    assetId: symbol,
-    market: 'lighter',
-    displaySymbol: symbol,
-    displayQuote: 'USDC',
-  },
-  side: order.is_ask ? OrderSide.SELL : OrderSide.BUY,
-  type: mapOrderType(order.type),
-  size: order.initial_base_amount,
-  price: order.price,
-  filledSize: order.filled_base_amount,
-  reduceOnly: order.reduce_only,
-  createdAt: new Date(order.created_at * 1000).toISOString(),
-})
-
-/**
- * Map a raw Lighter order to the rich Order type — adds status, time-in-force
- * and remaining/filled sizes on top of the OpenOrder fields.
- */
-export const mapOrderDetail = (order: LtOrder, symbol: string): Order => ({
-  orderId: order.order_id,
-  asset: {
-    assetId: symbol,
-    market: 'lighter',
-    displaySymbol: symbol,
-    displayQuote: 'USDC',
-  },
-  side: order.is_ask ? OrderSide.SELL : OrderSide.BUY,
-  type: mapOrderType(order.type),
-  price: order.price,
-  originalSize: order.initial_base_amount,
-  remainingSize: order.remaining_base_amount,
-  filledSize: order.filled_base_amount,
-  timeInForce: mapTimeInForce(order.time_in_force),
-  reduceOnly: order.reduce_only,
-  status: mapOrderStatus(order.status),
-  statusReason: mapStatusReason(order.status),
-  createdAt: new Date(order.created_at * 1000).toISOString(),
-  updatedAt: new Date(order.updated_at * 1000).toISOString(),
-})

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

@@ -1,46 +0,0 @@
-import { MarginMode, PositionSide } from '../../../enums.js'
-import type { Position } from '../../../account.js'
-import type { LtAccountPosition } from '../apiTypes.js'
-import { LT_MARGIN_MODE_ISOLATED } from '../types.js'
-
-/**
- * Map a raw Lighter account position to the generic Position type.
- * @param symbol Resolved symbol (market_id → symbol lookup, or `pos.symbol`).
- */
-export const mapPosition = (
-  pos: LtAccountPosition,
-  symbol: string
-): Position => {
-  const size = parseFloat(pos.position)
-  const isIsolated = pos.margin_mode === LT_MARGIN_MODE_ISOLATED
-
-  // `allocated_margin` is only populated for isolated positions (always "0"
-  // on cross accounts). For cross, derive margin as
-  // `position_value × initial_margin_fraction / 100` (IMF is in percent).
-  const positionValue = Math.abs(parseFloat(pos.position_value))
-  const imf = parseFloat(pos.initial_margin_fraction)
-  const marginUsed = isIsolated
-    ? pos.allocated_margin
-    : ((positionValue * imf) / 100).toString()
-
-  return {
-    asset: {
-      assetId: symbol,
-      market: 'lighter',
-      displaySymbol: symbol,
-      displayQuote: 'USDC',
-    },
-    side: pos.sign >= 0 ? PositionSide.LONG : PositionSide.SHORT,
-    size: Math.abs(size).toString(),
-    entryPrice: pos.avg_entry_price,
-    markPrice:
-      pos.position_value === '0' || size === 0
-        ? '0'
-        : (parseFloat(pos.position_value) / Math.abs(size)).toString(),
-    liquidationPrice: pos.liquidation_price,
-    unrealizedPnl: pos.unrealized_pnl,
-    leverage: imf > 0 ? Math.round(100 / imf) : 1,
-    marginUsed,
-    marginMode: isIsolated ? MarginMode.ISOLATED : MarginMode.CROSS,
-  }
-}

package/src/providers/lighter/types.ts

@@ -1,111 +0,0 @@
-// Lighter WASM signer parameter types — shapes of `wasmSignParams` per
-// action. The backend populates these and the SDK passes them to the WASM
-// signer alongside SDK-managed fields (nonce, account_index, api_key_index).
-
-/** Backend-provided params for SignCreateOrder. */
-export type LtCreateOrderWasmParams = {
-  market_index: number
-  client_order_index: number
-  base_amount: number
-  price: number
-  is_ask: number
-  order_type: number
-  time_in_force: number
-  reduce_only: boolean
-  trigger_price: number
-  order_expiry: number
-  integrator_account_index: number
-  integrator_taker_fee: number
-  integrator_maker_fee: number
-}
-
-/** Backend-provided params for SignCancelOrder. */
-export type LtCancelOrderWasmParams = {
-  market_index: number
-  order_index: number
-}
-
-/** Backend-provided params for SignModifyOrder. */
-export type LtModifyOrderWasmParams = {
-  market_index: number
-  order_index: number
-  base_amount: number
-  price: number
-  trigger_price: number
-  integrator_account_index: number
-  integrator_taker_fee: number
-  integrator_maker_fee: number
-}
-
-/** Backend-provided params for SignUpdateLeverage. */
-export type LtUpdateLeverageWasmParams = {
-  market_index: number
-  fraction: number
-  margin_mode: number
-}
-
-/** Backend-provided params for SignUpdateMargin. */
-export type LtUpdateMarginWasmParams = {
-  market_index: number
-  usdc_amount: number
-  direction: number
-}
-
-/** Backend-provided params for SignWithdraw. */
-export type LtWithdrawWasmParams = {
-  asset_index: number
-  route_type: number
-  amount: number
-}
-
-/** Backend-provided params for SignCancelAllOrders. */
-export type LtCancelAllOrdersWasmParams = {
-  /** 0=immediate (cancel GTC), 1=scheduled, 2=abort scheduled */
-  time_in_force: number
-  /** Unix timestamp in milliseconds. Use Date.now() for immediate cancels. */
-  timestamp_ms: number
-}
-
-/**
- * Backend-provided params for SignChangePubKey (REGISTER_API_KEY).
- *
- * Hybrid signing: this action requires both a WASM blob and an L1 Ethereum
- * signature (the user's wallet signs the ChangePubKey message). The SDK
- * generates the keypair via the WASM signer and fills in `new_public_key`
- * before invoking SignChangePubKey.
- */
-export type LtChangePubKeyWasmParams = {
-  /** API key slot index to register (0-255). SDK fills in the generated public key. */
-  api_key_index: number
-  nonce: number
-}
-
-// ---------------------------------------------------------------------------
-// Lighter WASM signer constants
-// ---------------------------------------------------------------------------
-
-export const LT_ORDER_TYPE_LIMIT = 0
-export const LT_ORDER_TYPE_MARKET = 1
-export const LT_ORDER_TYPE_STOP_LOSS = 2
-export const LT_ORDER_TYPE_STOP_LOSS_LIMIT = 3
-export const LT_ORDER_TYPE_TAKE_PROFIT = 4
-export const LT_ORDER_TYPE_TAKE_PROFIT_LIMIT = 5
-export const LT_ORDER_TYPE_TWAP = 6
-
-export const LT_TIME_IN_FORCE_IOC = 0
-export const LT_TIME_IN_FORCE_GTC = 1
-export const LT_TIME_IN_FORCE_POST_ONLY = 2
-
-export const LT_MARGIN_MODE_CROSS = 0
-export const LT_MARGIN_MODE_ISOLATED = 1
-
-export const LT_MARGIN_DIRECTION_REMOVE = 0
-export const LT_MARGIN_DIRECTION_ADD = 1
-
-export const LT_ROUTE_PERP = 0
-export const LT_ROUTE_SPOT = 1
-
-export const LT_ASSET_ID_USDC = 3
-
-export const LT_NIL_TRIGGER_PRICE = 0
-export const LT_DEFAULT_ORDER_EXPIRY = -1