@lifi/perps-sdk-provider-ondo 28.0.0 → 30.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/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,50 +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,
-                snap.market
-              )
-              return []
-            }
-            if (!isDecimalString(size)) {
-              wsLog.skippedRow(
-                this.providerKey,
-                BOOK_LEVEL_ROW,
-                'size',
-                size,
-                snap.market
-              )
-              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) {
@@ -878,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,
       }