@lifi/perps-sdk-provider-ondo 27.0.0 → 29.0.0

package/src/auth/signActions.ts

@@ -1,13 +1,23 @@
-import { PerpsError, type SignActionsContext } from '@lifi/perps-sdk'
+import {
+  PerpsError,
+  rethrowWithKnownResults,
+  type SignActionsContext,
+  type SignActionsResult,
+} from '@lifi/perps-sdk'
 import type {
+  ActionResult,
   ActionStep,
   HmacActionStep,
   HmacSignedActionStep,
   SessionActionStep,
-  SignedActionStep,
   SiweActionStep,
 } from '@lifi/perps-types'
-import { ActionType, PerpsErrorCode, SigningMethod } from '@lifi/perps-types'
+import {
+  ActionType,
+  PerpsErrorCode,
+  SigningMethod,
+  UserActionStatus,
+} from '@lifi/perps-types'
 import { type Address, getAddress } from 'viem'
 import {
   ONDO_API_KEY_NAME,
@@ -249,12 +259,17 @@ async function executeSessionRequest(
  * `SIWE` signs the backend-built ERC-4361 challenge with the user's wallet and
  * completes the login directly against Ondo. The session JWT is persisted in
  * the token store and no signed step is returned, so neither the JWT nor the
- * wallet signature transits the LI.FI backend.
+ * wallet signature transits the LI.FI backend. Each completed login is an
+ * `Accepted` executed result.
  *
  * `SESSION` executes client-only setup steps directly against the venue with
  * the stored session token. A backend-authored request-bearing step is
- * dispatched as-is; a bare marker step is keyed on its action. Returns no
- * signed steps, so `executeAction` is skipped.
+ * dispatched as-is; a bare marker step is keyed on its action. Each step the
+ * venue answered is an `Accepted` executed result, and no signed step is
+ * returned, so `executeAction` is skipped.
+ *
+ * A step that throws after an earlier step executed throws a
+ * `PerpsExecutionError` that holds the earlier results.
  *
  * `HMAC` computes a per-request HMAC-SHA256 signature over each request step
  * from the client-held API key (creating one on first use), attaching the
@@ -269,29 +284,35 @@ export async function ondoSignActions(
   steps: ActionStep[],
   address: Address,
   ctx?: SignActionsContext
-): Promise<SignedActionStep[]> {
+): Promise<SignActionsResult> {
   switch (method) {
     case SigningMethod.SIWE: {
       const userWallet = requireUserWallet(ctx)
-      for (const step of steps) {
-        if (!isSiweStep(step)) {
-          throw new PerpsError(
-            PerpsErrorCode.SDKError,
-            `Ondo received a non-SIWE step ('${step.action}') under the SIWE signing method.`
-          )
+      const executed: ActionResult[] = []
+      try {
+        for (const step of steps) {
+          if (!isSiweStep(step)) {
+            throw new PerpsError(
+              PerpsErrorCode.SDKError,
+              `Ondo received a non-SIWE step ('${step.action}') under the SIWE signing method.`
+            )
+          }
+          const token = await completeSiweLogin(deps.client, userWallet, {
+            id: step.siwe.challengeId,
+            message: step.siwe.message,
+          })
+          executed.push(acceptedResult(step))
+          await deps.tokenStore.set(address, token)
         }
-        const token = await completeSiweLogin(deps.client, userWallet, {
-          id: step.siwe.challengeId,
-          message: step.siwe.message,
-        })
-        await deps.tokenStore.set(address, token)
+      } catch (error) {
+        rethrowWithKnownResults(executed, error)
       }
-      return []
+      return { signed: [], executed }
     }
 
     case SigningMethod.HMAC: {
       const apiKey = await ensureApiKey(deps, address)
-      return Promise.all(
+      const signed = await Promise.all(
         steps.map(async (step): Promise<HmacSignedActionStep> => {
           if (!hasRequest(step)) {
             throw new PerpsError(
@@ -318,72 +339,20 @@ export async function ondoSignActions(
           }
         })
       )
+      return { signed, executed: [] }
     }
 
     case SigningMethod.SESSION: {
-      for (const step of steps) {
-        if (hasRequest(step)) {
-          await executeSessionRequest(deps, address, step.request)
-          continue
-        }
-        if (!isSessionStep(step)) {
-          throw new PerpsError(
-            PerpsErrorCode.SDKError,
-            `Ondo received a non-session step ('${step.action}') under the session signing method.`
-          )
-        }
-        switch (step.action) {
-          case ActionType.CREATE_DEPOSIT_ADDRESS: {
-            const token = await requireOndoSessionToken(
-              deps.tokenStore,
-              address
-            )
-            const account = await deps.client.get<{ accountID?: unknown }>(
-              '/v1/account',
-              { authToken: token.token }
-            )
-            const payload = buildOndoProvisionPayload(
-              step.session,
-              typeof account.accountID === 'string' ? account.accountID : ''
-            )
-            await deps.client.post('/v1/provision_address', payload, {
-              authToken: token.token,
-            })
-            // Re-query to validate that Ondo can read the provisioned address;
-            // getAccount performs the authoritative state refresh afterward.
-            await listOndoDepositAddress(deps.client, token.token)
-            break
-          }
-
-          case ActionType.ACCEPT_PROVIDER_TERMS: {
-            const token = await requireOndoSessionToken(
-              deps.tokenStore,
-              address
-            )
-            await deps.client.post(
-              '/v1/agreement',
-              {
-                termsVersion: ONDO_TERMS_VERSION,
-                privacyVersion: ONDO_PRIVACY_VERSION,
-              },
-              { authToken: token.token }
-            )
-            break
-          }
-          case ActionType.REGISTER_API_KEY:
-            await ensureApiKey(deps, address)
-            break
-          case ActionType.ADD_WITHDRAWAL_ADDRESS:
-            await addWithdrawalAddress(deps, address, ctx)
-            break
-          default:
-            throw new PerpsError(
-              PerpsErrorCode.SDKError,
-              `Ondo has no session-step executor for action '${step.action}'.`
-            )
+      const executed: ActionResult[] = []
+      try {
+        for (const step of steps) {
+          await executeSessionStep(deps, address, step, ctx)
+          executed.push(acceptedResult(step))
         }
+      } catch (error) {
+        rethrowWithKnownResults(executed, error)
       }
-      return []
+      return { signed: [], executed }
     }
 
     default:
@@ -393,3 +362,69 @@ export async function ondoSignActions(
       )
   }
 }
+
+function acceptedResult(step: ActionStep): ActionResult {
+  return { action: step.action, status: UserActionStatus.Accepted }
+}
+
+async function executeSessionStep(
+  deps: OndoSignActionsDeps,
+  address: Address,
+  step: ActionStep,
+  ctx: SignActionsContext | undefined
+): Promise<void> {
+  if (hasRequest(step)) {
+    await executeSessionRequest(deps, address, step.request)
+    return
+  }
+  if (!isSessionStep(step)) {
+    throw new PerpsError(
+      PerpsErrorCode.SDKError,
+      `Ondo received a non-session step ('${step.action}') under the session signing method.`
+    )
+  }
+  switch (step.action) {
+    case ActionType.CREATE_DEPOSIT_ADDRESS: {
+      const token = await requireOndoSessionToken(deps.tokenStore, address)
+      const account = await deps.client.get<{ accountID?: unknown }>(
+        '/v1/account',
+        { authToken: token.token }
+      )
+      const payload = buildOndoProvisionPayload(
+        step.session,
+        typeof account.accountID === 'string' ? account.accountID : ''
+      )
+      await deps.client.post('/v1/provision_address', payload, {
+        authToken: token.token,
+      })
+      // Re-query to validate that Ondo can read the provisioned address;
+      // getAccount performs the authoritative state refresh afterward.
+      await listOndoDepositAddress(deps.client, token.token)
+      break
+    }
+
+    case ActionType.ACCEPT_PROVIDER_TERMS: {
+      const token = await requireOndoSessionToken(deps.tokenStore, address)
+      await deps.client.post(
+        '/v1/agreement',
+        {
+          termsVersion: ONDO_TERMS_VERSION,
+          privacyVersion: ONDO_PRIVACY_VERSION,
+        },
+        { authToken: token.token }
+      )
+      break
+    }
+    case ActionType.REGISTER_API_KEY:
+      await ensureApiKey(deps, address)
+      break
+    case ActionType.ADD_WITHDRAWAL_ADDRESS:
+      await addWithdrawalAddress(deps, address, ctx)
+      break
+    default:
+      throw new PerpsError(
+        PerpsErrorCode.SDKError,
+        `Ondo has no session-step executor for action '${step.action}'.`
+      )
+  }
+}

package/src/types/ws.ts

@@ -65,6 +65,7 @@ export interface OndoFundingRate {
 /** Server frame envelope. Non-`update` types are acks or errors. @public */
 export type OndoWsMessage =
   | { type: 'update'; channel: 'depthBooksPerps'; data: OndoBookSnapshot[] }
+  | { type: 'update'; channel: 'topOfBooksPerps'; data: OndoBookSnapshot[] }
   | { type: 'update'; channel: 'tradesPerps'; data: OndoWsTrade[] }
   | { type: 'update'; channel: 'kLinePerps'; data: OndoKline }
   | { type: 'update'; channel: 'markPricesPerps'; data: OndoMarkPrice[] }

package/src/utils/mapFill.ts

@@ -31,7 +31,12 @@ export const mapFill = (
   fill: OndoFill,
   market: MarketDisplay
 ): Fill | undefined => {
-  const createdAt = rowTimestampToIsoStringOrWarn('fill', 'time', fill.time)
+  const createdAt = rowTimestampToIsoStringOrWarn(
+    'fill',
+    'time',
+    fill.time,
+    market.id
+  )
   if (createdAt === undefined) {
     return undefined
   }

package/src/utils/mapOrder.ts

@@ -24,19 +24,23 @@ import type { OndoOrder, OndoTwapOrder } from '../types/wire.js'
 import { rowTimestampToIsoStringOrWarn } from './venueValues.js'
 
 const skipOrder = (
+  marketId: string,
   field: string,
-  value: unknown,
-  expected?: string
+  value: unknown
 ): undefined => {
-  warnSkippedVenueRow(ONDO_PROVIDER_KEY, 'order', field, value, expected)
+  warnSkippedVenueRow(ONDO_PROVIDER_KEY, 'order', field, value, { marketId })
   return undefined
 }
 
-const orderSizeOrSkip = (field: string, value: unknown): string | undefined => {
+const orderSizeOrSkip = (
+  marketId: string,
+  field: string,
+  value: unknown
+): string | undefined => {
   try {
     return unknownToDecimalString(value, field, ONDO_PROVIDER_KEY)
   } catch {
-    return skipOrder(field, value)
+    return skipOrder(marketId, field, value)
   }
 }
 
@@ -101,13 +105,13 @@ export const mapOrder = (
   parentOrderId?: string
 ): Order | undefined => {
   const twap = 'twapId' in order
-  const filledSize = orderSizeOrSkip('filledSize', order.filledSize)
+  const filledSize = orderSizeOrSkip(market.id, 'filledSize', order.filledSize)
   if (filledSize === undefined) {
     return undefined
   }
   const sizeValue = twap
-    ? orderSizeOrSkip('totalSize', order.totalSize)
-    : orderSizeOrSkip('size', order.size)
+    ? orderSizeOrSkip(market.id, 'totalSize', order.totalSize)
+    : orderSizeOrSkip(market.id, 'size', order.size)
   if (sizeValue === undefined) {
     return undefined
   }
@@ -121,7 +125,8 @@ export const mapOrder = (
   const createdAt = rowTimestampToIsoStringOrWarn(
     'order',
     createdField,
-    createdValue
+    createdValue,
+    market.id
   )
   if (createdAt === undefined) {
     return undefined
@@ -132,7 +137,8 @@ export const mapOrder = (
   const updatedAt = rowTimestampToIsoStringOrWarn(
     'order',
     'updatedAt',
-    updatedValue
+    updatedValue,
+    market.id
   )
   if (updatedAt === undefined) {
     return undefined

package/src/utils/mapPortfolioHistory.ts

@@ -33,13 +33,9 @@ const mapPoint = (
 ): PortfolioHistoryPoint | undefined => {
   const timestamp = Date.parse(point.time)
   if (Number.isNaN(timestamp)) {
-    warnSkippedVenueRow(
-      ONDO_PROVIDER_KEY,
-      POINT_ROW,
-      'time',
-      point.time,
-      'timestamp'
-    )
+    warnSkippedVenueRow(ONDO_PROVIDER_KEY, POINT_ROW, 'time', point.time, {
+      expected: 'timestamp',
+    })
     return undefined
   }
   return { timestamp, accountValue: point.marginBalance, pnl: point.totalPnL }

package/src/utils/mapPosition.ts

@@ -31,7 +31,8 @@ export const mapPosition = (
       ONDO_PROVIDER_KEY,
       'position',
       'netQuantity',
-      pos.netQuantity
+      pos.netQuantity,
+      { marketId: market.id }
     )
     return undefined
   }

package/src/utils/venueValues.ts

@@ -8,12 +8,16 @@ import { ONDO_PROVIDER_KEY } from '../constants.js'
 export const rowTimestampToIsoStringOrWarn = (
   row: string,
   field: string,
-  value: string
+  value: string,
+  marketId?: string
 ): string | undefined => {
   try {
     return timestampToIsoString(value)
   } catch {
-    warnSkippedVenueRow(ONDO_PROVIDER_KEY, row, field, value, 'timestamp')
+    warnSkippedVenueRow(ONDO_PROVIDER_KEY, row, field, value, {
+      marketId,
+      expected: 'timestamp',
+    })
     return undefined
   }
 }

package/src/websocket/OndoWsProvider.ts

@@ -1,5 +1,7 @@
 import {
+  addDecimalString,
   DecodeChain,
+  divideDecimalString,
   getMarketRegistry,
   isDecimalString,
   localStorageAdapter,
@@ -40,6 +42,7 @@ import {
 import type {
   OndoAuthToken,
   OndoBalanceSummary,
+  OndoBookLevel,
   OndoBookSnapshot,
   OndoFill,
   OndoFundingRate,
@@ -62,9 +65,10 @@ import { intervalFromBarSpan, mapInterval } from '../utils/ohlcvInterval.js'
 
 // Public channels (per market, demuxed from the frame's `market` field):
 //   orderbook → depthBooksPerps, trades → tradesPerps, candle → kLinePerps.
-// `marketsContext`/`marketContext` merge two wire channels — markPricesPerps
-// and fundingRatesPerps — into the aggregated context emit; Ondo publishes no
-// mid price on either, so `markPrice` stands in for `midPrice`.
+// `marketsContext`/`marketContext` merge three wire channels — markPricesPerps,
+// fundingRatesPerps and topOfBooksPerps — into the aggregated context emit.
+// `midPrice` is the top-of-book mid; the mark price stands in until a
+// two-sided book arrives for the market.
 // Authenticated channels (account-wide, no market filter):
 //   orderUpdates → ordersPerps, fills → fillsPerps, positions → positionsPerps.
 //
@@ -166,6 +170,8 @@ export class OndoWsProvider extends WsProviderBase<SubState> {
     string,
     { rate: string; nextFundingTime: number }
   >()
+  /** Latest two-sided top-of-book mid, keyed by venue market symbol. */
+  private bookMids = new Map<string, string>()
 
   /** The single address this connection's login is bound to. */
   private accountAddress: string | undefined
@@ -472,6 +478,7 @@ export class OndoWsProvider extends WsProviderBase<SubState> {
   protected override onClose(): void {
     this.contexts = {}
     this.pendingFunding.clear()
+    this.bookMids.clear()
     this.loginPromise = undefined
     this.accountAddress = undefined
     this.authGeneration += 1
@@ -494,6 +501,10 @@ export class OndoWsProvider extends WsProviderBase<SubState> {
             'fundingRatesPerps',
             { frame: { channel: 'fundingRatesPerps' }, needsAuth: false },
           ],
+          [
+            'topOfBooksPerps',
+            { frame: { channel: 'topOfBooksPerps' }, needsAuth: false },
+          ],
         ]
       case 'marketContext':
         return [
@@ -511,6 +522,13 @@ export class OndoWsProvider extends WsProviderBase<SubState> {
               needsAuth: false,
             },
           ],
+          [
+            `topOfBooksPerps:${sub.marketId}`,
+            {
+              frame: { channel: 'topOfBooksPerps', markets: [sub.marketId] },
+              needsAuth: false,
+            },
+          ],
         ]
       case 'orderbook':
         return [
@@ -758,6 +776,9 @@ export class OndoWsProvider extends WsProviderBase<SubState> {
         case 'depthBooksPerps':
           this.handleBooks(msg.data as OndoBookSnapshot[])
           break
+        case 'topOfBooksPerps':
+          this.handleTopOfBooks(msg.data as OndoBookSnapshot[])
+          break
         case 'tradesPerps':
           this.handleTrades(msg.data as OndoWsTrade[])
           break
@@ -785,38 +806,86 @@ export class OndoWsProvider extends WsProviderBase<SubState> {
     }
   }
 
+  /** Valid levels of one book side, best first (`-1` bids, `1` asks). */
+  private toBookLevels(
+    market: string,
+    levels: OndoBookLevel[],
+    direction: 1 | -1
+  ) {
+    return levels
+      .flatMap(([price, size]) => {
+        if (!isDecimalString(price)) {
+          wsLog.skippedRow(
+            this.providerKey,
+            BOOK_LEVEL_ROW,
+            'price',
+            price,
+            market
+          )
+          return []
+        }
+        if (!isDecimalString(size)) {
+          wsLog.skippedRow(
+            this.providerKey,
+            BOOK_LEVEL_ROW,
+            'size',
+            size,
+            market
+          )
+          return []
+        }
+        return [{ price, size }]
+      })
+      .sort(
+        (a, b) => direction * (safeCompareDecimalStrings(a.price, b.price) ?? 0)
+      )
+  }
+
   private handleBooks(snapshots: OndoBookSnapshot[]): void {
     for (const snap of snapshots) {
-      const toLevels = (levels: OndoBookSnapshot['bids'], direction: 1 | -1) =>
-        levels
-          .flatMap(([price, size]) => {
-            if (!isDecimalString(price)) {
-              wsLog.skippedRow(this.providerKey, BOOK_LEVEL_ROW, 'price', price)
-              return []
-            }
-            if (!isDecimalString(size)) {
-              wsLog.skippedRow(this.providerKey, BOOK_LEVEL_ROW, 'size', size)
-              return []
-            }
-            return [{ price, size }]
-          })
-          .sort(
-            (a, b) =>
-              direction * (safeCompareDecimalStrings(a.price, b.price) ?? 0)
-          )
       this.emit(`orderbook:${snap.market}`, {
         channel: 'orderbook',
         data: {
           provider: this.providerKey,
           marketId: snap.market,
-          bids: toLevels(snap.bids, -1),
-          asks: toLevels(snap.asks, 1),
+          bids: this.toBookLevels(snap.market, snap.bids, -1),
+          asks: this.toBookLevels(snap.market, snap.asks, 1),
           timestamp: Date.parse(snap.time),
         },
       })
     }
   }
 
+  private handleTopOfBooks(snapshots: OndoBookSnapshot[]): void {
+    const touched: string[] = []
+    for (const { market, bids, asks } of snapshots) {
+      const bestBid = this.toBookLevels(market, bids, -1)[0]
+      const bestAsk = this.toBookLevels(market, asks, 1)[0]
+      if (bestBid === undefined || bestAsk === undefined) {
+        this.bookMids.delete(market)
+      } else {
+        this.bookMids.set(
+          market,
+          divideDecimalString(
+            addDecimalString(bestBid.price, bestAsk.price),
+            '2'
+          )
+        )
+      }
+      const context = this.contexts[market]
+      if (context !== undefined) {
+        this.contexts[market] = {
+          ...context,
+          midPrice: this.bookMids.get(market) ?? context.markPrice,
+        }
+        touched.push(market)
+      }
+    }
+    if (touched.length > 0) {
+      this.emitContexts(touched)
+    }
+  }
+
   private handleTrades(trades: OndoWsTrade[]): void {
     const byMarket = new Map<string, OndoWsTrade[]>()
     for (const trade of trades) {
@@ -866,8 +935,8 @@ export class OndoWsProvider extends WsProviderBase<SubState> {
       const context: MarketContext = {
         ...this.contexts[market],
         marketId: market,
-        // Ondo streams no mid price; the mark price stands in.
-        midPrice: markPrice,
+        // The mark price stands in until a two-sided top-of-book arrives.
+        midPrice: this.bookMids.get(market) ?? markPrice,
         markPrice,
         oraclePrice,
       }