@lifi/perps-sdk-provider-lighter 27.0.0 → 28.0.0

package/dist/types/utils/transferMargin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transferMargin.d.ts","sourceRoot":"","sources":["../../../src/utils/transferMargin.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,yBAAyB,EAE/B,MAAM,mBAAmB,CAAA;AAK1B;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,QAAQ,GACjB,yBAAyB,GAAG,SAAS,CAWvC"}
+{"version":3,"file":"transferMargin.d.ts","sourceRoot":"","sources":["../../../src/utils/transferMargin.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,QAAQ,EAGd,MAAM,mBAAmB,CAAA;AA2B1B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,QAAQ,GACjB,MAAM,GAAG,SAAS,CAmBpB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifi/perps-sdk-provider-lighter",
-  "version": "27.0.0",
+  "version": "28.0.0",
   "description": "Lighter provider plugin for @lifi/perps-sdk",
   "homepage": "https://github.com/lifinance/perps-sdk",
   "bugs": {
@@ -44,10 +44,10 @@
   "dependencies": {
     "big.js": "^7.0.1",
     "viem": "^2.55.18",
-    "@lifi/perps-types": "^15.0.0"
+    "@lifi/perps-types": "^16.0.0"
   },
   "peerDependencies": {
-    "@lifi/perps-sdk": "^16.0.0"
+    "@lifi/perps-sdk": "^17.0.0"
   },
   "publishConfig": {
     "access": "public"

package/src/LighterProvider.ts

@@ -5,6 +5,7 @@ import {
   explorerTxUrlFromBase,
   getAssetRegistry,
   getMarketRegistry,
+  getMarketsContext,
   getProviders,
   isActiveOrderStatus,
   localStorageAdapter,
@@ -63,6 +64,7 @@ import {
   MarginMode,
   PerpsErrorCode,
 } from '@lifi/perps-types'
+import Big from 'big.js'
 import type { Address } from 'viem'
 import { projectLighterConfigSettings } from './accountConfig.js'
 import { getAccountSummary } from './accountSummary.js'
@@ -138,7 +140,7 @@ import {
   mapOpenPositions,
   mapOrder,
   mapPortfolioHistory,
-  positionMarginConstraints,
+  positionRemovableMargin,
   toBigOrNull,
   toIsoFromMs,
   toIsoFromSeconds,
@@ -148,6 +150,7 @@ import {
   fetchRegisteredApiKey,
   normalizeLighterPublicKey,
 } from './utils/registeredApiKey.js'
+import { spotPriceByAssetId } from './utils/spotPrice.js'
 import { isPlaceholderTxHash } from './utils/txHash.js'
 import { wireList } from './utils/wireList.js'
 
@@ -825,11 +828,12 @@ export const createLighterProvider = (
 
       const registry = getMarketRegistry(requireClient(), providerKey)
       const assetRegistry = getAssetRegistry(requireClient(), providerKey)
-      const [{ providers }, , , limitsResult, storedReadOnlyToken] =
+      const [{ providers }, , , { prices }, limitsResult, storedReadOnlyToken] =
         await Promise.all([
           getProviders(requireClient()),
           registry.sync(),
           assetRegistry.sync(),
+          getMarketsContext(requireClient(), { provider: providerKey }, opts),
           token === undefined
             ? Promise.resolve(undefined)
             : retryOnRevoked(opts, params.address, token, (resolvedToken) =>
@@ -883,23 +887,39 @@ export const createLighterProvider = (
           ]
         : []
       // Spot token holdings — non-collateral. The instance's settlement asset
-      // is valued 1:1; other tokens have no price source at this boundary, so
-      // their price and USD value are unknown.
-      const balances: Balance[] = account.assets
-        .filter((asset) => toRequiredBig(asset.balance, 'balance').gt(0))
-        .map((a) => {
-          const assetId = String(a.asset_id)
-          const settlement = a.asset_id === collateral.assetIndex
-          return {
-            categoryId: spotCategoryId,
-            asset:
-              assetRegistry.get(assetId) ??
-              lighterAsset(assetId, a.symbol, providerKey),
-            units: a.balance,
-            valueUsd: settlement ? a.balance : '0',
-            ...(settlement ? { price: '1' } : {}),
-          }
-        })
+      // is valued 1:1; an asset no spot market prices keeps a zero USD value.
+      const heldAssets = account.assets.filter((asset) =>
+        toRequiredBig(asset.balance, 'balance').gt(0)
+      )
+      const spotPrices = spotPriceByAssetId(
+        registry.markets,
+        spotCategoryId,
+        prices,
+        new Set(
+          heldAssets
+            .filter((a) => a.asset_id !== collateral.assetIndex)
+            .map((a) => String(a.asset_id))
+        )
+      )
+      const balances: Balance[] = heldAssets.map((a) => {
+        const assetId = String(a.asset_id)
+        const price =
+          a.asset_id === collateral.assetIndex
+            ? new Big(1)
+            : spotPrices.get(assetId)
+        return {
+          categoryId: spotCategoryId,
+          asset:
+            assetRegistry.get(assetId) ??
+            lighterAsset(assetId, a.symbol, providerKey),
+          units: a.balance,
+          valueUsd:
+            price === undefined
+              ? '0'
+              : toRequiredBig(a.balance, 'balance').times(price).toFixed(),
+          ...(price === undefined ? {} : { price: price.toFixed() }),
+        }
+      })
 
       const assetCollateral = account.assets.flatMap((a) =>
         a.margin_mode === undefined
@@ -1603,7 +1623,7 @@ export const createLighterProvider = (
 
     estimateLiquidationPrice,
 
-    positionMarginConstraints,
+    positionRemovableMargin,
 
     projectConfig(
       config: AccountConfig,

package/src/accountSummary.ts

@@ -20,10 +20,11 @@ const lighterConfig = (account: AccountResponse): LighterAccountConfig => {
 }
 
 /**
- * Roll a Lighter account up into an {@link AccountSummary}, from the venue
- * figures the response carries. `totalAssetValue` is total equity and
- * `availableBalance` is buying power, so neither needs reconciling against the
- * positions; the positions supply only the margin and PnL breakdown.
+ * Roll a Lighter account up into an {@link AccountSummary}. `totalAssetValue`
+ * is perps-route equity and excludes the spot route, so `portfolioValue` adds
+ * every spot `balances` row, settlement included; the `collateralBalances` row
+ * is buying power already inside `totalAssetValue`. The positions supply only
+ * the margin and PnL breakdown.
  *
  * @throws {PerpsError} `SDKError` when the account is not a Lighter one.
  * @public
@@ -41,18 +42,20 @@ export function getAccountSummary(
     unrealizedPnl = unrealizedPnl.plus(position.unrealizedPnl)
   }
 
+  let portfolioValue = toRequiredBig(config.totalAssetValue, 'totalAssetValue')
+  for (const balance of account.balances) {
+    portfolioValue = portfolioValue.plus(
+      toRequiredBig(balance.valueUsd, 'valueUsd')
+    )
+  }
+
   return {
-    // `total_asset_value` already covers every asset the venue prices, so the
-    // spot `balances` rows must not be added on top of it.
-    portfolioValue: toRequiredBig(
-      config.totalAssetValue,
-      'totalAssetValue'
-    ).toString(),
+    portfolioValue: portfolioValue.toFixed(),
     availableMargin: toRequiredBig(
       config.availableBalance,
       'availableBalance'
-    ).toString(),
-    marginUsed: marginUsed.toString(),
-    unrealizedPnl: unrealizedPnl.toString(),
+    ).toFixed(),
+    marginUsed: marginUsed.toFixed(),
+    unrealizedPnl: unrealizedPnl.toFixed(),
   }
 }

package/src/utils/index.ts

@@ -23,7 +23,7 @@ export { mapMarketOrderLimits } from './marketLimits.js'
 export { mapInterval } from './ohlcvInterval.js'
 export { formatOrderPrice, formatOrderSize } from './orderFormatting.js'
 export { toIsoFromMs, toIsoFromSeconds } from './time.js'
-export { positionMarginConstraints } from './transferMargin.js'
+export { positionRemovableMargin } from './transferMargin.js'
 export {
   leverageToFraction,
   mapOrderTypeToInt,

package/src/utils/mapOrder.ts

@@ -61,9 +61,10 @@ const mapOrderStatus = (
   filledSize = new Big(order.filled_base_amount)
 ): OrderStatus => {
   switch (order.status) {
-    case 'pending':
     case 'in-progress':
       return OrderStatus.ACCEPTED
+    case 'pending':
+      return OrderStatus.OPEN
     case 'open':
       if (order.trigger_status === 'parent-order') {
         return OrderStatus.PENDING

package/src/utils/spotPrice.ts

@@ -0,0 +1,39 @@
+import type { Market, MarketContext } from '@lifi/perps-types'
+import type Big from 'big.js'
+import { toRequiredBig } from './decimal.js'
+
+/**
+ * Unit prices keyed by spot base `Asset.id` (the venue `asset_id`), read from
+ * each spot market's `markPrice` for the base assets in `assetIds` only. A
+ * market without a context row or with a non-positive mark adds no entry; when
+ * several spot markets share a base asset, the first priced one in `markets`
+ * order wins. The mark is read as a USD price; `quoteAsset` is not checked.
+ *
+ * @throws {PerpsError} `SDKError` when a context row for a requested asset
+ * carries a non-decimal mark.
+ */
+export const spotPriceByAssetId = (
+  markets: readonly Market[],
+  spotCategoryId: string,
+  contexts: readonly MarketContext[],
+  assetIds: ReadonlySet<string>
+): Map<string, Big> => {
+  const markByMarketId = new Map(contexts.map((c) => [c.marketId, c.markPrice]))
+  const priceByAssetId = new Map<string, Big>()
+  for (const market of markets) {
+    const mark = markByMarketId.get(market.id)
+    if (
+      market.categoryId !== spotCategoryId ||
+      mark === undefined ||
+      !assetIds.has(market.baseAsset.id) ||
+      priceByAssetId.has(market.baseAsset.id)
+    ) {
+      continue
+    }
+    const price = toRequiredBig(mark, 'markPrice')
+    if (price.gt(0)) {
+      priceByAssetId.set(market.baseAsset.id, price)
+    }
+  }
+  return priceByAssetId
+}

package/src/utils/transferMargin.ts

@@ -1,31 +1,69 @@
+import { PerpsError } from '@lifi/perps-sdk'
 import {
+  PerpsErrorCode,
   type Position,
-  type PositionMarginConstraints,
   positionSupportsMarginAdjustment,
+  positionSupportsMarginRemoval,
 } from '@lifi/perps-types'
-import { toPositiveRequiredBig } from './decimal.js'
+import Big from 'big.js'
 
-const AMOUNT_INCREMENT = '0.000001'
+const AMOUNT_DECIMALS = 6
+
+function positionAmount(value: string, field: string): Big {
+  try {
+    return new Big(value)
+  } catch {
+    throw new PerpsError(
+      PerpsErrorCode.ValidationError,
+      `Invalid decimal string on Position.${field}: '${value}'`
+    )
+  }
+}
+
+function positivePositionAmount(value: string, field: string): Big {
+  const amount = positionAmount(value, field)
+  if (amount.lte(0)) {
+    throw new PerpsError(
+      PerpsErrorCode.ValidationError,
+      `Position.${field} must be greater than zero.`
+    )
+  }
+  return amount
+}
 
 /**
- * Lighter's exact isolated-margin requirement. Lighter publishes no separate
- * notional floor, so the provider-normalized initial-margin requirement is
- * the retained amount.
+ * Lighter removable isolated margin:
+ * `allocated_margin + unrealized PnL − initial margin requirement`. Lighter
+ * `allocated_margin` (`Position.marginUsed`) excludes the unrealized PnL, and
+ * Lighter publishes no separate notional floor.
  *
+ * @returns `undefined` for cross positions and markets without individual
+ *   margin adjustment; `'0'` for add-only markets and when nothing is
+ *   removable.
+ * @throws {PerpsError} `ValidationError` when a required `Position` decimal
+ *   is malformed or not positive.
  * @see https://docs.lighter.xyz/trading/liquidations-and-llp-insurance-fund
  * @public
  */
-export function positionMarginConstraints(
+export function positionRemovableMargin(
   position: Position
-): PositionMarginConstraints | undefined {
+): string | undefined {
   if (!positionSupportsMarginAdjustment(position)) {
     return undefined
   }
-  return {
-    minimumMarginRequirement: toPositiveRequiredBig(
-      position.initialMarginRequirement,
-      'initialMarginRequirement'
-    ).toFixed(),
-    amountIncrement: AMOUNT_INCREMENT,
+  if (!positionSupportsMarginRemoval(position)) {
+    return '0'
+  }
+  const removable = positivePositionAmount(position.marginUsed, 'marginUsed')
+    .plus(positionAmount(position.unrealizedPnl, 'unrealizedPnl'))
+    .minus(
+      positivePositionAmount(
+        position.initialMarginRequirement,
+        'initialMarginRequirement'
+      )
+    )
+  if (removable.lte(0)) {
+    return '0'
   }
+  return removable.round(AMOUNT_DECIMALS, Big.roundDown).toFixed()
 }