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

package/src/providers/hyperliquid/types.ts

@@ -1,200 +1,290 @@
+import { Type, type Static } from '@sinclair/typebox'
+
 // ---------------------------------------------------------------------------
-// Hand-written Hyperliquid /info response types
+// Hyperliquid /info response schemas (TypeBox)
+//
+// Each schema produces both a JSON Schema object (for AJV validation) and a
+// TypeScript type via Static<>. The derived types are structurally identical
+// to the hand-written ones they replace.
+//
+// All schemas use additionalProperties: true (TypeBox default) so that new
+// fields added by Hyperliquid pass through without breaking validation.
 // ---------------------------------------------------------------------------
 
 // -- metaAndAssetCtxs -------------------------------------------------------
 
-export type HlUniverseItem = {
-  name: string
-  szDecimals: number
-  maxLeverage: number
-  onlyIsolated: boolean
-  isDelisted: boolean
-}
-
-export type HlMeta = { universe: HlUniverseItem[] }
-
-export type HlAssetCtx = {
-  funding: string
-  openInterest: string
-  dayNtlVlm: string
-  markPx: string
-}
-
-export type HlMetaAndAssetCtxs = [HlMeta, HlAssetCtx[]]
+export const HlUniverseItemSchema = Type.Object({
+  name: Type.String(),
+  szDecimals: Type.Number(),
+  maxLeverage: Type.Number(),
+  onlyIsolated: Type.Boolean(),
+  isDelisted: Type.Boolean(),
+})
+export type HlUniverseItem = Static<typeof HlUniverseItemSchema>
+
+export const HlMetaSchema = Type.Object({
+  universe: Type.Array(HlUniverseItemSchema),
+})
+export type HlMeta = Static<typeof HlMetaSchema>
+
+export const HlAssetCtxSchema = Type.Object({
+  funding: Type.String(),
+  openInterest: Type.String(),
+  dayNtlVlm: Type.String(),
+  markPx: Type.String(),
+})
+export type HlAssetCtx = Static<typeof HlAssetCtxSchema>
+
+export const HlMetaAndAssetCtxsSchema = Type.Tuple([
+  HlMetaSchema,
+  Type.Array(HlAssetCtxSchema),
+])
+export type HlMetaAndAssetCtxs = Static<typeof HlMetaAndAssetCtxsSchema>
 
 export type HlUniverse = HlMeta['universe']
 
 // -- allMids ----------------------------------------------------------------
 
-export type HlAllMids = Record<string, string>
+export const HlAllMidsSchema = Type.Record(Type.String(), Type.String())
+export type HlAllMids = Static<typeof HlAllMidsSchema>
 
 // -- candleSnapshot ---------------------------------------------------------
 
-export type HlCandle = {
-  t: number
-  o: string
-  h: string
-  l: string
-  c: string
-  v: string
-}
+export const HlCandleSchema = Type.Object({
+  t: Type.Number(),
+  o: Type.String(),
+  h: Type.String(),
+  l: Type.String(),
+  c: Type.String(),
+  v: Type.String(),
+})
+export type HlCandle = Static<typeof HlCandleSchema>
 
-export type HlCandleSnapshot = HlCandle[]
+export const HlCandleSnapshotSchema = Type.Array(HlCandleSchema)
+export type HlCandleSnapshot = Static<typeof HlCandleSnapshotSchema>
 
 // -- l2Book -----------------------------------------------------------------
 
-export type HlLevel = { px: string; sz: string; n: number }
+export const HlLevelSchema = Type.Object({
+  px: Type.String(),
+  sz: Type.String(),
+  n: Type.Number(),
+})
+export type HlLevel = Static<typeof HlLevelSchema>
 
-export type HlL2Book = {
-  levels: [HlLevel[], HlLevel[]]
-  time: number
-}
+export const HlL2BookSchema = Type.Object({
+  levels: Type.Tuple([Type.Array(HlLevelSchema), Type.Array(HlLevelSchema)]),
+  time: Type.Number(),
+})
+export type HlL2Book = Static<typeof HlL2BookSchema>
 
 // -- clearinghouseState -----------------------------------------------------
 
-export type HlPosition = {
-  coin: string
-  szi: string
-  entryPx: string
-  positionValue: string
-  liquidationPx: string
-  unrealizedPnl: string
-  marginUsed: string
-  leverage: { type: string; value: number }
-}
-
-export type HlAssetPosition = { position: HlPosition }
-
-export type HlClearinghouseState = {
-  assetPositions: HlAssetPosition[]
-  marginSummary: { accountValue: string; totalMarginUsed: string }
-  crossMarginSummary: { accountValue: string; totalMarginUsed: string }
-}
+export const HlPositionSchema = Type.Object({
+  coin: Type.String(),
+  szi: Type.String(),
+  entryPx: Type.String(),
+  positionValue: Type.String(),
+  liquidationPx: Type.String(),
+  unrealizedPnl: Type.String(),
+  marginUsed: Type.String(),
+  leverage: Type.Object({
+    type: Type.String(),
+    value: Type.Number(),
+  }),
+})
+export type HlPosition = Static<typeof HlPositionSchema>
+
+export const HlAssetPositionSchema = Type.Object({
+  position: HlPositionSchema,
+})
+export type HlAssetPosition = Static<typeof HlAssetPositionSchema>
+
+export const HlClearinghouseStateSchema = Type.Object({
+  assetPositions: Type.Array(HlAssetPositionSchema),
+  marginSummary: Type.Object({
+    accountValue: Type.String(),
+    totalMarginUsed: Type.String(),
+  }),
+  crossMarginSummary: Type.Object({
+    accountValue: Type.String(),
+    totalMarginUsed: Type.String(),
+  }),
+})
+export type HlClearinghouseState = Static<typeof HlClearinghouseStateSchema>
 
 // -- spotClearinghouseState -------------------------------------------------
 
-export type HlSpotBalance = {
-  coin: string
-  token: number
-  total: string
-  hold: string
-  entryNtl: string
-}
-
-export type HlSpotClearinghouseState = {
-  balances: HlSpotBalance[]
-}
+export const HlSpotBalanceSchema = Type.Object({
+  coin: Type.String(),
+  token: Type.Number(),
+  total: Type.String(),
+  hold: Type.String(),
+  entryNtl: Type.String(),
+})
+export type HlSpotBalance = Static<typeof HlSpotBalanceSchema>
+
+export const HlSpotClearinghouseStateSchema = Type.Object({
+  balances: Type.Array(HlSpotBalanceSchema),
+})
+export type HlSpotClearinghouseState = Static<
+  typeof HlSpotClearinghouseStateSchema
+>
 
 // -- userFees ---------------------------------------------------------------
 
-export type HlUserFees = {
-  userAddRate: string
-  userCrossRate: string
-  activeReferralDiscount: string
-}
+export const HlUserFeesSchema = Type.Object({
+  userAddRate: Type.String(),
+  userCrossRate: Type.String(),
+  activeReferralDiscount: Type.String(),
+})
+export type HlUserFees = Static<typeof HlUserFeesSchema>
 
 // -- frontendOpenOrders -----------------------------------------------------
 
-export type HlFrontendOpenOrder = {
-  oid: number
-  coin: string
-  side: string
-  sz: string
-  limitPx: string
-  orderType: string
-  origSz: string
-  reduceOnly: boolean
-  timestamp: number
-}
-
-export type HlFrontendOpenOrders = HlFrontendOpenOrder[]
+export const HlFrontendOpenOrderSchema = Type.Object({
+  oid: Type.Number(),
+  coin: Type.String(),
+  side: Type.String(),
+  sz: Type.String(),
+  limitPx: Type.String(),
+  orderType: Type.String(),
+  origSz: Type.String(),
+  reduceOnly: Type.Boolean(),
+  timestamp: Type.Number(),
+})
+export type HlFrontendOpenOrder = Static<typeof HlFrontendOpenOrderSchema>
+
+export const HlFrontendOpenOrdersSchema = Type.Array(
+  HlFrontendOpenOrderSchema
+)
+export type HlFrontendOpenOrders = Static<typeof HlFrontendOpenOrdersSchema>
 
 // -- extraAgents ------------------------------------------------------------
 
-export type HlExtraAgents = Array<Record<string, unknown>>
+export const HlExtraAgentsSchema = Type.Array(
+  Type.Record(Type.String(), Type.Unknown())
+)
+export type HlExtraAgents = Static<typeof HlExtraAgentsSchema>
 
 // -- userFills / userFillsByTime --------------------------------------------
 
-export type HlUserFill = {
-  tid: number
-  coin: string
-  side: string
-  sz: string
-  px: string
-  dir: string
-  fee: string
-  closedPnl: string
-  time: number
-}
-
-export type HlUserFills = HlUserFill[]
-
-export type HlUserFillsByTime = HlUserFill[]
+export const HlUserFillSchema = Type.Object({
+  tid: Type.Number(),
+  coin: Type.String(),
+  side: Type.String(),
+  sz: Type.String(),
+  px: Type.String(),
+  dir: Type.String(),
+  fee: Type.String(),
+  closedPnl: Type.String(),
+  time: Type.Number(),
+})
+export type HlUserFill = Static<typeof HlUserFillSchema>
+
+export const HlUserFillsSchema = Type.Array(HlUserFillSchema)
+export type HlUserFills = Static<typeof HlUserFillsSchema>
+
+export const HlUserFillsByTimeSchema = Type.Array(HlUserFillSchema)
+export type HlUserFillsByTime = Static<typeof HlUserFillsByTimeSchema>
 
 // -- orderStatus ------------------------------------------------------------
 
-export type HlOrderStatusFound = {
-  status: 'order'
-  order: HlOrderDetail
-}
-
-export type HlOrderDetail = {
-  order: {
-    oid: number
-    coin: string
-    side: string
-    sz: string
-    limitPx: string
-    orderType: string
-    origSz: string
-    reduceOnly: boolean
-    timestamp: number
-    tif: string | null
-    cloid: string | null
-    triggerCondition: string
-    triggerPx: string | null
-  }
-  status: string
-  statusTimestamp: number
-}
-
-export type HlOrderStatusResponse =
-  | HlOrderStatusFound
-  | { status: 'unknownOid' }
+export const HlOrderDetailSchema = Type.Object({
+  order: Type.Object({
+    oid: Type.Number(),
+    coin: Type.String(),
+    side: Type.String(),
+    sz: Type.String(),
+    limitPx: Type.String(),
+    orderType: Type.String(),
+    origSz: Type.String(),
+    reduceOnly: Type.Boolean(),
+    timestamp: Type.Number(),
+    tif: Type.Union([Type.String(), Type.Null()]),
+    cloid: Type.Union([Type.String(), Type.Null()]),
+    triggerCondition: Type.String(),
+    triggerPx: Type.Union([Type.String(), Type.Null()]),
+  }),
+  status: Type.String(),
+  statusTimestamp: Type.Number(),
+})
+export type HlOrderDetail = Static<typeof HlOrderDetailSchema>
+
+export const HlOrderStatusFoundSchema = Type.Object({
+  status: Type.Literal('order'),
+  order: HlOrderDetailSchema,
+})
+export type HlOrderStatusFound = Static<typeof HlOrderStatusFoundSchema>
+
+export const HlOrderStatusResponseSchema = Type.Union([
+  HlOrderStatusFoundSchema,
+  Type.Object({ status: Type.Literal('unknownOid') }),
+])
+export type HlOrderStatusResponse = Static<
+  typeof HlOrderStatusResponseSchema
+>
 
 // -- perpDexs ---------------------------------------------------------------
 
-export type HlPerpDexs = Array<null | { name: string }>
+export const HlPerpDexsSchema = Type.Array(
+  Type.Union([Type.Null(), Type.Object({ name: Type.String() })])
+)
+export type HlPerpDexs = Static<typeof HlPerpDexsSchema>
 
 // ---------------------------------------------------------------------------
-// Exchange request types
+// Exchange request / response schemas
 // ---------------------------------------------------------------------------
 
-export type HlExchangeRequest = {
-  action: Record<string, unknown>
-  signature: { r: string; s: string; v: number }
-  nonce: number
-  vaultAddress?: string | null
-}
-
-export type HlExchangeResponse = {
-  status: string
-  response?:
-    | string
-    | {
-        type: string
-        data?: {
-          statuses?: Array<
-            | string
-            | { filled: { totalSz: string; avgPx: string; oid: number } }
-            | { resting: { oid: number } }
-            | { waitingForFill: { oid: number } }
-            | { waitingForTrigger: { oid: number } }
-            | { success: true }
-            | { error: string }
-          >
-          status?: unknown
-        }
-      }
-}
+export const HlExchangeRequestSchema = Type.Object({
+  action: Type.Record(Type.String(), Type.Unknown()),
+  signature: Type.Object({
+    r: Type.String(),
+    s: Type.String(),
+    v: Type.Number(),
+  }),
+  nonce: Type.Number(),
+  vaultAddress: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+})
+export type HlExchangeRequest = Static<typeof HlExchangeRequestSchema>
+
+export const HlExchangeResponseSchema = Type.Object({
+  status: Type.String(),
+  response: Type.Optional(
+    Type.Union([
+      Type.String(),
+      Type.Object({
+        type: Type.String(),
+        data: Type.Optional(
+          Type.Object({
+            statuses: Type.Optional(
+              Type.Array(
+                Type.Union([
+                  Type.String(),
+                  Type.Object({
+                    filled: Type.Object({
+                      totalSz: Type.String(),
+                      avgPx: Type.String(),
+                      oid: Type.Number(),
+                    }),
+                  }),
+                  Type.Object({ resting: Type.Object({ oid: Type.Number() }) }),
+                  Type.Object({
+                    waitingForFill: Type.Object({ oid: Type.Number() }),
+                  }),
+                  Type.Object({
+                    waitingForTrigger: Type.Object({ oid: Type.Number() }),
+                  }),
+                  Type.Object({ success: Type.Literal(true) }),
+                  Type.Object({ error: Type.String() }),
+                ])
+              )
+            ),
+            status: Type.Optional(Type.Unknown()),
+          })
+        ),
+      }),
+    ])
+  ),
+})
+export type HlExchangeResponse = Static<typeof HlExchangeResponseSchema>