@lifi/perps-sdk-provider-lighter 0.2.0-alpha.0

package/src/types/submit.ts

@@ -0,0 +1,83 @@
+// Lighter submit/execute-path wire shapes (sendTx, fastwithdraw, changeAccountTier).
+
+/** @public */
+export interface LtSendTxRequest {
+  tx_type: number
+  tx_info: string
+  price_protection?: boolean
+}
+
+/** @public */
+export interface LtSendTxResponse {
+  code: number
+  message: string
+  tx_hash: string
+  predicted_execution_time_ms?: number
+  volume_quota_remaining?: number
+}
+
+/** @public */
+export interface LtSendTxBatchRequest {
+  tx_types: string // JSON-encoded number[]
+  tx_infos: string // JSON-encoded string[]
+}
+
+/** @public */
+export interface LtSendTxBatchResponse {
+  code: number
+  message: string
+  tx_hash: string[] // one hash per submitted tx, indexed by submission order
+  predicted_execution_time_ms?: number
+  volume_quota_remaining?: number
+}
+
+/**
+ * `GET /api/v1/fastwithdraw/info` (Lighter `RespGetFastwithdrawalInfo`).
+ *
+ * Probe response that tells the caller whether the fast-withdraw operator is
+ * accepting transfers from `account_index` and, if so, which operator account
+ * to send the signed L2 transfer to. `withdraw_limit` and
+ * `max_withdrawal_amount` are USDC strings in **L2 6-decimal scale**, matching
+ * the `usdc_amount` units the WASM `SignTransfer` consumes. Lighter signals
+ * "fast path is not available right now" with a non-success `code` AND/OR a
+ * missing `to_account_index` (a `0` is also treated as missing because account
+ * index 0 is reserved by the protocol and never an operator).
+ *
+ * @public
+ */
+export interface LtFastwithdrawInfoResponse {
+  code: number
+  message?: string
+  to_account_index: number
+  withdraw_limit: string
+  max_withdrawal_amount: string
+}
+
+/**
+ * `POST /api/v1/fastwithdraw` (Lighter `ResultCode`).
+ *
+ * Returns only `{code, message}` — no `tx_hash`, unlike `/sendTx`. The Lighter
+ * relayer drains the operator account back to the user's L1 address
+ * out-of-band; success here means the signed L2 transfer was accepted, not
+ * that L1 settlement is complete.
+ *
+ * @public
+ */
+export interface LtFastwithdrawResponse {
+  code: number
+  message?: string
+}
+
+/**
+ * `POST /api/v1/changeAccountTier` (Lighter `RespChangeAccountTier`).
+ *
+ * Code 0 means Lighter accepted the tier change; any other code carries a
+ * Lighter-defined business-rule rejection (open positions, pending orders, 24h
+ * cooldown, etc.) and `message` is the operator-readable reason.
+ *
+ * @public
+ */
+export interface LtChangeAccountTierResponse {
+  code: number
+  message?: string
+}

package/src/types/ws.ts

@@ -0,0 +1,136 @@
+// The Lighter stream server sends JSON messages of shape:
+//   { type: 'subscribed/<channel>' | 'update/<channel>' | 'ping',
+//     channel: '<channel>/<id>',
+//     ...payload }
+//
+// Channels we subscribe to:
+//   - market_stats/all        → public prices across all perp markets
+//   - spot_market_stats/all   → public prices across all spot markets
+//   - order_book/{market_id}  → bids/asks per market (stateful with deltas)
+
+/** @public */
+export type LtWsMessage = {
+  channel?: string
+  type: string
+}
+
+/** @public */
+export type LtWsPingMessage = LtWsMessage & { type: 'ping' }
+
+/** @public */
+export type LtWsMarketStats = {
+  market_id: number
+  index_price: string
+  mark_price: string
+  open_interest: string
+  last_trade_price: string
+  current_funding_rate: string
+  funding_rate: string
+  funding_timestamp: number
+  daily_base_token_volume: string
+  daily_quote_token_volume: string
+  daily_price_change: string
+}
+
+/**
+ * `market_stats/all` pushes one record per known market each tick. We
+ * aggregate them into a Record<assetId, price> before emitting `prices`.
+ * @public
+ */
+export type LtWsMarketStatsAllMessage = LtWsMessage & {
+  type: 'subscribed/market_stats' | 'update/market_stats'
+  market_stats?: Record<string, LtWsMarketStats>
+}
+
+/**
+ * Spot market stats carry no funding/open-interest fields and address
+ * markets by their spot `market_id` (2048+).
+ * @public
+ */
+export type LtWsSpotMarketStats = {
+  market_id: number
+  symbol: string
+  index_price: string
+  mid_price: string
+  best_ask_price: string
+  best_bid_price: string
+  last_trade_price: string
+  daily_base_token_volume: number
+  daily_quote_token_volume: number
+  daily_price_low: number
+  daily_price_high: number
+  daily_price_change: number
+}
+
+/**
+ * `spot_market_stats/all` is the spot-market counterpart to
+ * `market_stats/all`; both feed the same aggregated `prices` emit.
+ * @public
+ */
+export type LtWsSpotMarketStatsAllMessage = LtWsMessage & {
+  type: 'subscribed/spot_market_stats' | 'update/spot_market_stats'
+  spot_market_stats?: Record<string, LtWsSpotMarketStats>
+}
+
+/** @public */
+export type LtWsOrderBookLevel = {
+  price: string
+  size: string
+}
+
+/** @public */
+export type LtWsOrderBook = {
+  asks: LtWsOrderBookLevel[]
+  bids: LtWsOrderBookLevel[]
+  offset?: number
+}
+
+/** @public */
+export type LtWsOrderBookMessage = LtWsMessage & {
+  type: 'subscribed/order_book' | 'update/order_book'
+  order_book: LtWsOrderBook
+}
+
+/**
+ * Auth-channel payloads.
+ *
+ * The response `channel` field uses `:` as separator (e.g.
+ * `account_all_orders:42`) while the subscribe payload uses `/`.
+ *
+ * Per the Lighter WS spec:
+ *   - orders/trades: object indexed by market index, each value an array
+ *     (`{ "0": [Order], "1": [Order] }`)
+ *   - positions: object indexed by market index, each value a single object
+ *     (`{ "0": Position }`)
+ *   - initial `account_all_trades` snapshot may send an empty flat array
+ *
+ * The provider uses `collectAuthChannelItems` to normalise all three shapes
+ * into a flat T[].
+ * @public
+ */
+export type LtWsAccountAllOrdersMessage = LtWsMessage & {
+  type: 'subscribed/account_all_orders' | 'update/account_all_orders'
+  orders?: Record<string, unknown[]> | unknown[]
+  data?: { orders?: Record<string, unknown[]> | unknown[] }
+}
+
+/** @public */
+export type LtWsAccountAllTradesMessage = LtWsMessage & {
+  type: 'subscribed/account_all_trades' | 'update/account_all_trades'
+  trades?: Record<string, unknown[]> | unknown[]
+  total_volume?: number
+  monthly_volume?: number
+  weekly_volume?: number
+  daily_volume?: number
+  data?: { trades?: Record<string, unknown[]> | unknown[] }
+}
+
+/** @public */
+export type LtWsAccountAllPositionsMessage = LtWsMessage & {
+  type: 'subscribed/account_all_positions' | 'update/account_all_positions'
+  positions?: Record<string, unknown>
+  shares?: unknown[]
+  last_funding_round?: Record<string, string>
+  last_funding_discount?: Record<string, string>
+  data?: { positions?: Record<string, unknown> }
+}

package/src/utils/activityCursor.ts

@@ -0,0 +1,150 @@
+import { PerpsError } from '@lifi/perps-sdk'
+import { type ActivityItem, PerpsErrorCode } from '@lifi/perps-types'
+
+/**
+ * Per-endpoint cursor envelope for Lighter activity pagination.
+ *
+ * Each key holds the upstream `cursor` / `next_cursor` returned by that
+ * endpoint on the previous call. When a key is **present** with a non-empty
+ * string the corresponding endpoint will be re-fetched at that cursor on the
+ * next call; when a key is **absent** the endpoint is treated as exhausted
+ * (or never paged because the type filter excluded it) and skipped.
+ *
+ * The envelope is round-tripped through `cursor` as base64url JSON so callers
+ * don't need to know the per-endpoint shape. The encoding mirrors the LI.FI
+ * backend's wire format so cursors created by the backend remain usable.
+ * @public
+ */
+export interface LighterActivityCursor {
+  deposits?: string
+  withdraws?: string
+  fundings?: string
+  liquidations?: string
+  transfers?: string
+  /**
+   * Already-fetched, merged-and-sorted rows that did not fit under the page
+   * `limit`. The upstream cursors above have advanced past these rows, so they
+   * are replayed (prepended) on the next page before any fresh fetch — without
+   * them the tail would be lost forever.
+   */
+  overflow?: ActivityItem[]
+}
+
+const CURSOR_KEYS = [
+  'deposits',
+  'withdraws',
+  'fundings',
+  'liquidations',
+  'transfers',
+] as const
+
+const isNonEmpty = (v: string | undefined): v is string =>
+  typeof v === 'string' && v.length > 0
+
+/**
+ * Encode a `LighterActivityCursor` as the base64url-of-JSON cursor string
+ * Lighter widgets persist between activity pages. Returns `undefined` when
+ * every per-endpoint key is empty and no `overflow` rows remain — the caller
+ * should report `hasMore: false` and omit `cursor` from `Pagination` then.
+ *
+ * Browser-direct: `Buffer` is Node-only. We use `btoa` over a Latin-1
+ * encoding of the UTF-8 bytes and then rewrite `+/=` to base64url. This is
+ * the same byte sequence Node's `Buffer.from(json, 'utf8').toString('base64url')`
+ * produces, so cursors round-trip across environments.
+ * @public
+ */
+export const encodeActivityCursor = (
+  env: LighterActivityCursor
+): string | undefined => {
+  const compact: LighterActivityCursor = {}
+  for (const key of CURSOR_KEYS) {
+    if (isNonEmpty(env[key])) {
+      compact[key] = env[key]
+    }
+  }
+  if (env.overflow !== undefined && env.overflow.length > 0) {
+    compact.overflow = env.overflow
+  }
+  if (Object.keys(compact).length === 0) {
+    return undefined
+  }
+  return toBase64Url(JSON.stringify(compact))
+}
+
+/**
+ * Decode a previously-encoded activity cursor. Returns `undefined` for an
+ * absent cursor (first page) and throws {@link PerpsError} with
+ * `ValidationError` if the string is malformed — we'd rather fail loudly than
+ * silently re-page from page 1 and re-deliver already-paginated rows.
+ * @public
+ */
+export const decodeActivityCursor = (
+  cursor: string | undefined
+): LighterActivityCursor | undefined => {
+  if (cursor === undefined) {
+    return undefined
+  }
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(fromBase64Url(cursor))
+  } catch {
+    throw new PerpsError(
+      PerpsErrorCode.ValidationError,
+      'Invalid Lighter activity cursor: not base64url-encoded JSON'
+    )
+  }
+  if (parsed === null || typeof parsed !== 'object') {
+    throw new PerpsError(
+      PerpsErrorCode.ValidationError,
+      'Invalid Lighter activity cursor: expected JSON object'
+    )
+  }
+  const cursorRecord = parsed as Record<string, unknown>
+  const env: LighterActivityCursor = {}
+  for (const key of CURSOR_KEYS) {
+    const v = cursorRecord[key]
+    if (v === undefined) {
+      continue
+    }
+    if (typeof v !== 'string') {
+      throw new PerpsError(
+        PerpsErrorCode.ValidationError,
+        `Invalid Lighter activity cursor: ${key} must be a string`
+      )
+    }
+    env[key] = v
+  }
+  const overflow = cursorRecord.overflow
+  if (overflow !== undefined) {
+    if (!Array.isArray(overflow)) {
+      throw new PerpsError(
+        PerpsErrorCode.ValidationError,
+        'Invalid Lighter activity cursor: overflow must be an array'
+      )
+    }
+    env.overflow = overflow as ActivityItem[]
+  }
+  return env
+}
+
+const toBase64Url = (s: string): string => {
+  if (typeof Buffer !== 'undefined') {
+    return Buffer.from(s, 'utf8').toString('base64url')
+  }
+  const utf8 = unescape(encodeURIComponent(s))
+  return btoa(utf8).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+}
+
+const fromBase64Url = (s: string): string => {
+  if (typeof Buffer !== 'undefined') {
+    return Buffer.from(s, 'base64url').toString('utf8')
+  }
+  const padded = s.replace(/-/g, '+').replace(/_/g, '/') + padFor(s)
+  const decoded = atob(padded)
+  return decodeURIComponent(escape(decoded))
+}
+
+const padFor = (s: string): string => {
+  const rem = s.length % 4
+  return rem === 0 ? '' : '='.repeat(4 - rem)
+}

package/src/utils/apiClient.ts

@@ -0,0 +1,185 @@
+import {
+  fetchWithRetry,
+  PerpsError,
+  type ResolvedRetryPolicy,
+} from '@lifi/perps-sdk'
+import { PerpsErrorCode } from '@lifi/perps-types'
+import {
+  LIGHTER_INVALID_AUTH_CODE,
+  LIGHTER_SUCCESS_CODES,
+} from '../constants.js'
+
+/** @internal */
+export type ApiParams = Record<string, string | number | boolean>
+
+/**
+ * Lighter signals errors on two channels: a non-2xx HTTP status, or an HTTP 200
+ * carrying an error `code` in the JSON body. Returns the body error `code` when
+ * the body advertises one that is not a success code, else `undefined`.
+ */
+const lighterBodyErrorCode = (data: unknown): number | undefined => {
+  const code = (data as { code?: number } | undefined)?.code
+  if (code === undefined || LIGHTER_SUCCESS_CODES.has(code)) {
+    return undefined
+  }
+  return code
+}
+
+/**
+ * Auth-gated read whose token Lighter rejected. Distinct from a generic
+ * {@link PerpsError} so callers can evict the stored read-only token and retry
+ * with a freshly-created one. Lighter signals this on either channel: an HTTP
+ * 401/403, or an HTTP 200 carrying an error `code` in the body.
+ * @internal
+ */
+export class LighterAuthRejectedError extends PerpsError {}
+
+const isLighterAuthRejection = (status: number, data: unknown): boolean =>
+  status === 401 ||
+  status === 403 ||
+  lighterBodyErrorCode(data) === LIGHTER_INVALID_AUTH_CODE
+
+/** @internal */
+export const LIGHTER_RETRY_DEFAULTS: ResolvedRetryPolicy = {
+  enabled: true,
+  maxAttempts: 2,
+  baseDelayMs: 10_000,
+  maxDelayMs: 60_000,
+  respectRetryAfter: true,
+  classify: ({ response }) => {
+    if (response.status === 429 || response.status === 405) {
+      return 'retry-rate-limit'
+    }
+    if (
+      response.status === 502 ||
+      response.status === 503 ||
+      response.status === 504
+    ) {
+      return 'retry-server'
+    }
+    return 'fail'
+  },
+}
+
+/** @internal */
+export interface LighterApiClientOptions {
+  signal?: AbortSignal
+  policy?: ResolvedRetryPolicy
+  fetchImpl?: typeof fetch
+}
+
+/**
+ * HTTP boundary against Lighter's REST API.
+ *
+ * Browser-direct by design: no LI.FI backend hop, no caching shim — caller
+ * supplies the REST base URL, the path, and any query params, and we return
+ * the parsed JSON body. Lighter advertises CORS headers on every public
+ * endpoint so a vanilla `fetch` from the widget works.
+ *
+ * Auth-gated endpoints (accountLimits, accountActiveOrders, deposit/history,
+ * withdraw/history, positionFunding, liquidations, transfer/history) take the
+ * Lighter read-only token as the `auth` query parameter — NOT as an
+ * `Authorization` header. This matches Lighter's OpenAPI spec and lets the
+ * same call work browser-direct and from server-side proxies.
+ *
+ * Lighter signals rate limiting via 429 OR 405 (documented behaviour) with a
+ * documented 60s firewall cooldown. The default {@link ResolvedRetryPolicy}
+ * waits long enough to avoid hammering through the cooldown.
+ * @public
+ */
+export class LighterApiClient {
+  private readonly baseUrl: string
+  private readonly signal: AbortSignal | undefined
+  private readonly policy: ResolvedRetryPolicy
+  private readonly fetchImpl: typeof fetch | undefined
+
+  constructor(baseUrl: string, options?: LighterApiClientOptions) {
+    this.baseUrl = baseUrl.replace(/\/$/, '')
+    this.signal = options?.signal
+    this.policy = options?.policy ?? LIGHTER_RETRY_DEFAULTS
+    this.fetchImpl = options?.fetchImpl
+  }
+
+  private buildUrl(path: string, params?: ApiParams): string {
+    const url = `${this.baseUrl}${path}`
+    if (!params || Object.keys(params).length === 0) {
+      return url
+    }
+    const qs = Object.entries(params)
+      .map(
+        ([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`
+      )
+      .join('&')
+    return `${url}?${qs}`
+  }
+
+  async get<T>(path: string, params?: ApiParams): Promise<T> {
+    return this.getChecked<T>(path, params)
+  }
+
+  /**
+   * Auth-gated GET. The token is appended as the `auth` query parameter (per
+   * Lighter's OpenAPI spec); the `Authorization` header is intentionally NOT
+   * used — Lighter rejects it.
+   */
+  async getAuthed<T>(
+    path: string,
+    authToken: string,
+    params: ApiParams = {}
+  ): Promise<T> {
+    const { status, data } = await this.getWithStatus<unknown>(path, {
+      ...params,
+      auth: authToken,
+    })
+    if (isLighterAuthRejection(status, data)) {
+      throw new LighterAuthRejectedError(
+        PerpsErrorCode.ThirdPartyError,
+        `Lighter rejected the auth token for ${path}`
+      )
+    }
+    if (status < 200 || status >= 300) {
+      throw new PerpsError(
+        PerpsErrorCode.ThirdPartyError,
+        `Lighter API request failed: ${status} — ${JSON.stringify(data).slice(0, 200)}`
+      )
+    }
+    return data as T
+  }
+
+  /**
+   * GET that surfaces the raw `{status, body}` pair without throwing on
+   * non-2xx — used for endpoints (account lookup by L1 address) where the
+   * caller distinguishes specific Lighter error codes from generic failures.
+   */
+  async getWithStatus<T>(
+    path: string,
+    params?: ApiParams
+  ): Promise<{ status: number; data: T }> {
+    const url = this.buildUrl(path, params)
+    const response = await fetchWithRetry(
+      url,
+      {},
+      { policy: this.policy, fetchImpl: this.fetchImpl, signal: this.signal }
+    )
+    const data = (await response.json().catch(() => undefined)) as T
+    return { status: response.status, data }
+  }
+
+  private async getChecked<T>(path: string, params?: ApiParams): Promise<T> {
+    const { status, data } = await this.getWithStatus<unknown>(path, params)
+    if (status < 200 || status >= 300) {
+      throw new PerpsError(
+        PerpsErrorCode.ThirdPartyError,
+        `Lighter API request failed: ${status} — ${JSON.stringify(data).slice(0, 200)}`
+      )
+    }
+    const errorCode = lighterBodyErrorCode(data)
+    if (errorCode !== undefined) {
+      throw new PerpsError(
+        PerpsErrorCode.ThirdPartyError,
+        `Lighter API error for ${path}: code ${errorCode} — ${JSON.stringify(data).slice(0, 200)}`
+      )
+    }
+    return data as T
+  }
+}

package/src/utils/fetchDetailedAccount.ts

@@ -0,0 +1,46 @@
+import { PerpsError } from '@lifi/perps-sdk'
+import { PerpsErrorCode } from '@lifi/perps-types'
+import type { Address } from 'viem'
+import { LIGHTER_CODE_ACCOUNT_NOT_FOUND } from '../constants.js'
+import type { LtDetailedAccount } from '../types/index.js'
+import type { LighterApiClient } from './apiClient.js'
+
+/**
+ * Look up the Lighter account for an L1 address via `/api/v1/account`,
+ * discriminating Lighter's account-not-found body code from generic failures.
+ *
+ * @public
+ */
+export const fetchDetailedAccount = async (
+  client: LighterApiClient,
+  address: Address
+): Promise<LtDetailedAccount> => {
+  const { status, data } = await client.getWithStatus<{
+    code: number
+    accounts?: LtDetailedAccount[]
+    message?: string
+  }>('/api/v1/account', { by: 'l1_address', value: address })
+
+  if (status === 400 && data?.code === LIGHTER_CODE_ACCOUNT_NOT_FOUND) {
+    throw new PerpsError(
+      PerpsErrorCode.AccountNotFound,
+      `No Lighter account found for address: ${address}`
+    )
+  }
+
+  if (status < 200 || status >= 300) {
+    throw new PerpsError(
+      PerpsErrorCode.ThirdPartyError,
+      `Lighter account request failed: ${status} — ${JSON.stringify(data).slice(0, 200)}`
+    )
+  }
+
+  const accounts = data?.accounts
+  if (accounts === undefined || accounts.length === 0) {
+    throw new PerpsError(
+      PerpsErrorCode.AccountNotFound,
+      `No Lighter account found for address: ${address}`
+    )
+  }
+  return accounts[0]
+}

package/src/utils/index.ts

@@ -0,0 +1,38 @@
+// biome-ignore-all lint/performance/noBarrelFile: single re-export entry point
+// for the package's utility surface. Internal modules import per-file paths
+// (e.g. `./apiClient.js`, `./mapFill.js`) directly.
+
+export type { LighterActivityCursor } from './activityCursor.js'
+export {
+  decodeActivityCursor,
+  encodeActivityCursor,
+} from './activityCursor.js'
+export { LighterApiClient } from './apiClient.js'
+export { fetchDetailedAccount } from './fetchDetailedAccount.js'
+export { lighterAsset } from './lighterAsset.js'
+export { estimateLiquidationPrice } from './liquidation.js'
+export { mapFill } from './mapFill.js'
+export { mapOpenPositions } from './mapOpenPositions.js'
+export {
+  classifyAndMapOrders,
+  isTriggerOrder,
+  isTriggerType,
+  mapOrder,
+  mapOrderDetail,
+  mapStatusReason,
+  mapTriggerOrder,
+} from './mapOrder.js'
+export { mapPosition } from './mapPosition.js'
+export { mapInterval } from './ohlcvInterval.js'
+export { formatOrderPrice, formatOrderSize } from './orderFormatting.js'
+export { toIsoFromMs, toIsoFromSeconds } from './time.js'
+export type { ScaleToIntegerPolicy } from './wireEncoding.js'
+export {
+  leverageToFraction,
+  mapOrderTypeToInt,
+  mapTimeInForceToInt,
+  marginFractionToMaxLeverage,
+  orderExpiryForTif,
+  resolveTimeInForce,
+  scaleToInteger,
+} from './wireEncoding.js'

package/src/utils/lighterAsset.ts

@@ -0,0 +1,10 @@
+import type { Asset } from '@lifi/perps-types'
+import { LIGHTER_PROVIDER_KEY } from '../constants.js'
+
+/** @public */
+export const lighterAsset = (id: string, displaySymbol: string): Asset => ({
+  providerId: LIGHTER_PROVIDER_KEY,
+  id,
+  displaySymbol,
+  logoURI: '',
+})

package/src/utils/liquidation.ts

@@ -0,0 +1,39 @@
+/**
+ * Lighter liquidation price estimation.
+ *
+ * Lighter publishes a flat per-market `maintenance_margin_fraction` on its
+ * order books, surfaced on the generic {@link PerpsMarket} as
+ * `maintenanceMarginRate`. The estimate is the standard isolated-margin
+ * model parameterised by that rate.
+ */
+
+import {
+  estimateIsolatedLiquidationPrice,
+  type LiquidationEstimateParams,
+} from '@lifi/perps-sdk'
+import type { PerpsMarket } from '@lifi/perps-types'
+
+/**
+ * Estimate the liquidation price of a new isolated position on a Lighter
+ * market.
+ *
+ * @returns The estimated liquidation price, or `undefined` when
+ *   `market.maintenanceMarginRate` is absent (the model cannot be evaluated
+ *   without the venue's maintenance margin rate) or the inputs are
+ *   degenerate.
+ * @public
+ */
+export function estimateLiquidationPrice(
+  market: PerpsMarket,
+  params: LiquidationEstimateParams
+): number | undefined {
+  if (market.maintenanceMarginRate === undefined) {
+    return undefined
+  }
+  return estimateIsolatedLiquidationPrice({
+    entryPrice: params.entryPrice,
+    leverage: params.leverage,
+    isLong: params.isLong,
+    maintenanceMarginRate: market.maintenanceMarginRate,
+  })
+}