@lifi/perps-sdk-provider-ondo 19.0.0 → 20.0.0

package/src/OndoProvider.ts

@@ -13,6 +13,7 @@ import {
   type ProviderAccountExistsParams,
   type ProviderGetAccountParams,
   type ProviderGetActivityParams,
+  type ProviderGetAvailableToTradeParams,
   type ProviderGetDepositFlowParams,
   type ProviderGetFillsParams,
   type ProviderGetOrderParams,
@@ -28,6 +29,7 @@ import {
   type SDKRequestOptions,
   type SignActionsContext,
   type StorageAdapter,
+  toAssetDisplay,
   toMarketDisplay,
   toPerpsMarketDisplay,
 } from '@lifi/perps-sdk'
@@ -40,6 +42,7 @@ import type {
   ActionStep,
   ActivitiesResponse,
   ActivityItem,
+  AvailableToTrade,
   Fill,
   FillsResponse,
   FundingActivity,
@@ -80,11 +83,14 @@ import type {
   OndoBalanceSummary,
   OndoFill,
   OndoFundingFeeTransfer,
+  OndoLeverage,
   OndoLiquidationEvent,
+  OndoMaxOrderSizesRes,
   OndoOrder,
   OndoPortfolioGraphPoint,
   OndoPortfolioSummary,
   OndoPosition,
+  OndoRestMarkPrice,
   OndoTwapOrder,
   OndoWalletDeposit,
   OndoWalletWithdrawal,
@@ -113,6 +119,7 @@ import {
   mapOpenPositions,
   mapOrder,
   mapWithdrawalActivity,
+  ondoAvailableToTrade,
   ondoWithdrawableBalances,
   positionRemovableMargin,
   requireOndoCollateralAsset,
@@ -406,6 +413,88 @@ export const ondoProvider = (
       )
     },
 
+    async getAvailableToTrade(
+      params: ProviderGetAvailableToTradeParams,
+      opts?: SDKRequestOptions
+    ): Promise<AvailableToTrade | undefined> {
+      return withSession(
+        params.address,
+        () => undefined,
+        async (token) => {
+          const registry = marketRegistry()
+          await registry.sync()
+          const market = registry.require(params.marketId)
+          const client = apiClient(opts)
+          const [maxOrderSizes, leveragesRead, markPricesRead] =
+            await Promise.allSettled([
+              client
+                .get<OndoMaxOrderSizesRes>('/v1/perps/max_order_size', {
+                  params: { market: market.id, buffer: '1' },
+                  authToken: token.token,
+                })
+                .catch((error: unknown) => {
+                  if (
+                    error instanceof OndoApiError &&
+                    error.errorCode === 'insufficient_margin'
+                  ) {
+                    return null
+                  }
+                  throw error
+                }),
+              client.get<OndoLeverage[]>('/v1/perps/leverage', {
+                params: { market: market.id },
+                authToken: token.token,
+              }),
+              client.get<Record<string, OndoRestMarkPrice>>(
+                '/v1/perps/mark_prices'
+              ),
+            ])
+          if (maxOrderSizes.status === 'rejected') {
+            throw maxOrderSizes.reason
+          }
+          const asset = toAssetDisplay(market.quoteAsset)
+          // The zero result reads neither companion, so their failures do not apply.
+          if (maxOrderSizes.value === null) {
+            return {
+              providerId: market.providerId,
+              marketId: market.id,
+              asset,
+              buy: '0',
+              sell: '0',
+            }
+          }
+          if (leveragesRead.status === 'rejected') {
+            throw leveragesRead.reason
+          }
+          if (markPricesRead.status === 'rejected') {
+            throw markPricesRead.reason
+          }
+          const leverage = leveragesRead.value.find(
+            (row) => row.market === market.id
+          )
+          const markPrice = markPricesRead.value[market.id]
+          if (leverage === undefined || markPrice === undefined) {
+            const error = new PerpsError(
+              PerpsErrorCode.SDKError,
+              `Ondo returned no ${leverage === undefined ? 'leverage' : 'mark price'} for market '${market.id}'`
+            )
+            error.tool = ONDO_PROVIDER_KEY
+            throw error
+          }
+          return {
+            providerId: market.providerId,
+            marketId: market.id,
+            asset,
+            ...ondoAvailableToTrade(
+              maxOrderSizes.value.percent100,
+              leverage.leverage,
+              markPrice.markPrice
+            ),
+          }
+        }
+      )
+    },
+
     async accountExists(
       params: ProviderAccountExistsParams,
       opts?: SDKRequestOptions

package/src/types/wire.ts

@@ -378,3 +378,37 @@ export interface OndoPortfolioSummary {
   volume30d: string
   volumeAllTime: string
 }
+
+/** Mirrors Ondo's `OrderSizes`: one `MaxOrderSizesRes` tier, in base-asset units. @public */
+export interface OndoOrderSizes {
+  maxBidBaseSize: string
+  maxAskBaseSize: string
+}
+
+/**
+ * Mirrors Ondo's `MaxOrderSizesRes` (the `/v1/perps/max_order_size` result).
+ * The request `buffer` scales every tier. @public
+ */
+export interface OndoMaxOrderSizesRes {
+  percent100: OndoOrderSizes
+  percent75: OndoOrderSizes
+  percent50: OndoOrderSizes
+  percent25: OndoOrderSizes
+}
+
+/** Mirrors Ondo's `ApiLeverage` (a `/v1/perps/leverage` result row). @public */
+export interface OndoLeverage {
+  market: string
+  leverage: string
+}
+
+/** Mirrors Ondo's `MarkPrice` (a `/v1/perps/mark_prices` result value). @public */
+export interface OndoRestMarkPrice {
+  market: string
+  pair: { base: string; quote: string }
+  price: string
+  markPrice: string
+  oraclePrice: string
+  lastExternalPrice: string
+  lastUpdatedTime: string
+}

package/src/utils/availableToTrade.ts

@@ -0,0 +1,68 @@
+import { PerpsError } from '@lifi/perps-sdk'
+import type { AvailableToTrade } from '@lifi/perps-types'
+import { PerpsErrorCode } from '@lifi/perps-types'
+import Big from 'big.js'
+import { ONDO_PROVIDER_KEY } from '../constants.js'
+import type { OndoOrderSizes } from '../types/wire.js'
+import { toWireBig } from './decimal.js'
+
+// A max amount must never exceed the exact cap, so the division truncates.
+const TruncatingBig = Big()
+TruncatingBig.RM = Big.roundDown
+
+const outOfRange = (
+  field: string,
+  value: string,
+  bound: string
+): PerpsError => {
+  const error = new PerpsError(
+    PerpsErrorCode.SDKError,
+    `Ondo field \`${field}\` must be ${bound}: '${value}'`
+  )
+  error.tool = ONDO_PROVIDER_KEY
+  return error
+}
+
+const toPositiveBig = (value: string, field: string): Big => {
+  const parsed = toWireBig(value, field)
+  if (parsed.lte(0)) {
+    throw outOfRange(field, value, 'positive')
+  }
+  return parsed
+}
+
+const toNonNegativeBig = (value: string, field: string): Big => {
+  const parsed = toWireBig(value, field)
+  if (parsed.lt(0)) {
+    throw outOfRange(field, value, 'non-negative')
+  }
+  return parsed
+}
+
+/**
+ * Convert one Ondo max-order-size tier from base-asset units into the margin
+ * the order would lock: `baseSize × markPrice ÷ leverage`, truncated toward
+ * zero at 20 decimal places. The bid side maps to `buy` and the ask side to
+ * `sell`.
+ *
+ * @throws {PerpsError} `SDKError` when a venue field is not a decimal, a size
+ *   is negative, or the leverage or mark price is not positive.
+ * @public
+ */
+export const ondoAvailableToTrade = (
+  sizes: OndoOrderSizes,
+  leverage: string,
+  markPrice: string
+): Pick<AvailableToTrade, 'buy' | 'sell'> => {
+  const lev = toPositiveBig(leverage, 'leverage.leverage')
+  const mark = toPositiveBig(markPrice, 'markPrice.markPrice')
+  const toMargin = (baseSize: string, field: string): string =>
+    new TruncatingBig(toNonNegativeBig(baseSize, field))
+      .times(mark)
+      .div(lev)
+      .toFixed()
+  return {
+    buy: toMargin(sizes.maxBidBaseSize, 'maxOrderSize.maxBidBaseSize'),
+    sell: toMargin(sizes.maxAskBaseSize, 'maxOrderSize.maxAskBaseSize'),
+  }
+}

package/src/utils/index.ts

@@ -16,6 +16,7 @@ export {
   type OndoRequestOptions,
   OndoSessionExpiredError,
 } from './apiClient.js'
+export { ondoAvailableToTrade } from './availableToTrade.js'
 export { requireOndoCollateralAsset } from './collateralAsset.js'
 export {
   buildOndoProvisionPayload,

package/src/websocket/OndoWsProvider.ts

@@ -853,5 +853,5 @@ export const ondoWsProvider = (
   Object.assign(
     ({ provider, wsUrl, client }: WsProviderFactoryParams) =>
       new OndoWsProvider(wsUrl, provider, options, client),
-    { streamsCandles: true }
+    { streamsCandles: true, streamsAvailableToTrade: false }
   )