@zofai/zo-sdk 0.2.27 → 0.2.29

package/src/implementations/SLPDataAPI.ts

@@ -12,7 +12,7 @@ import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui/utils'
 import { BaseDataAPI } from '../abstract'
 import { Rate, SymbolsValuation, VaultsValuation } from '../bcs'
 import type { Network } from '../consts'
-import { LPToken, SLP_TOKEN_DECIMALS } from '../consts'
+import { getZoOracleConfig, LPToken, SLP_TOKEN_DECIMALS } from '../consts'
 import type {
   IBaseHistoryResponse,
   IBaseOrderType,
@@ -40,7 +40,12 @@ import type {
 } from '../interfaces'
 import type { OracleInputs } from '../oraclePro'
 import type { DynamicFieldInfo, SuiClient } from '../suiClient'
-import { valuateSymbolsV3, valuateVaultsV3 } from '../oraclePro'
+import {
+  buildPythProPriceFeedMap,
+  resolveTokenUsdPriceFromPythPro,
+  valuateSymbolsV3,
+  valuateVaultsV3,
+} from '../oraclePro'
 import { joinSymbol, parseSymbolKey, parseValue, suiSymbolToSymbol } from '../utils'
 
 export interface GetCumulativeAprResponse {
@@ -261,11 +266,29 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     let value = 0
 
     const vaultKeys = Object.keys(this.consts.sudoCore.vaults)
+    const symbolTokenIds = [
+      ...new Set(
+        Object.keys(this.consts.sudoCore.symbols).map(symbol => parseSymbolKey(symbol)[1]),
+      ),
+    ]
+    const valuationTokens = [...new Set([...vaultKeys, ...symbolTokenIds])]
+    const pythProData = await this.getLatestPythProPricesForTokens(valuationTokens)
+    const feedById = buildPythProPriceFeedMap(pythProData)
+    const zoOracle = getZoOracleConfig(this.network)
+    const resolvePrice = (token: string) => resolveTokenUsdPriceFromPythPro({
+      token,
+      feedById,
+      zoOracle,
+      coins: this.consts.coins,
+      network: this.network,
+      legacyFeeders: this.consts.pythFeeder.feeder,
+    })
+
     const vaultData = await Promise.all(vaultKeys.map(async (vault) => {
       const vaultInfo = await this.getVaultInfo(vault)
       const reservingFeeDelta = SLPDataAPI.calculateVaultReservingFee(vaultInfo, vaultInfo.reservingFeeModel, Date.now() / 1000)
       const totalVaultAmount = reservingFeeDelta + vaultInfo.liquidity + vaultInfo.reservedAmount
-      const oraclePrice = (await this.getOraclePrice(vault)).getPriceUnchecked().getPriceAsNumberUnchecked()
+      const oraclePrice = resolvePrice(vault)
       const { decimals } = this.consts.coins[vault]
       const vaultValue = totalVaultAmount * oraclePrice / (10 ** decimals)
       return { vault, oraclePrice, vaultValue }
@@ -276,7 +299,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     const symbolPromises = Object.keys(this.consts.sudoCore.symbols).map(async (symbol) => {
       const [direction, tokenId] = parseSymbolKey(symbol)
       const symbolInfo = await this.getSymbolInfo(tokenId, direction === 'long')
-      const price = (await this.getOraclePrice(tokenId)).getPriceUnchecked().getPriceAsNumberUnchecked()
+      const price = resolvePrice(tokenId)
 
       const oiState = await this.getSymbolOiFundingState(tokenId)
       const pairedInfo = await this.getSymbolInfo(tokenId, direction !== 'long')
@@ -393,13 +416,22 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     const slpPrice = value / marketInfo.lpSupplyWithDecimals
 
     const vaultKeys = Object.keys(this.consts.sudoCore.vaults)
-    const vaultPricesEntries = await Promise.all(
-      vaultKeys.map(async (vault) => {
-        const oraclePrice = (await this.getOraclePrice(vault)).getPriceUnchecked().getPriceAsNumberUnchecked()
-        return [vault, oraclePrice] as const
-      }),
+    const pythProData = await this.getLatestPythProPricesForTokens(vaultKeys)
+    const feedById = buildPythProPriceFeedMap(pythProData)
+    const zoOracle = getZoOracleConfig(this.network)
+    const vaultPrices = Object.fromEntries(
+      vaultKeys.map(vault => [
+        vault,
+        resolveTokenUsdPriceFromPythPro({
+          token: vault,
+          feedById,
+          zoOracle,
+          coins: this.consts.coins,
+          network: this.network,
+          legacyFeeders: this.consts.pythFeeder.feeder,
+        }),
+      ]),
     )
-    const vaultPrices = Object.fromEntries(vaultPricesEntries)
 
     return {
       marketCap: value,

package/src/oracle.ts

@@ -345,10 +345,11 @@ export class OracleAPI {
     tokens: string[],
     options?: Omit<IGetLatestPythProPricesOptions, 'priceFeedIds'>,
   ): Promise<PythProLatestPriceData> {
+    const config = this.getOracleProConfig()
     const priceFeedIds = this.resolveLazerFeedIdsForTokens(tokens)
     return getLatestPythProPrices(this.resolveKronosUrl(options?.kronosUrl), {
       priceFeedIds,
-      channel: options?.channel,
+      channel: options?.channel ?? (config.lazerChannel as PythProChannel),
       includeEmaPrice: options?.includeEmaPrice,
       includeUpdateBytes: options?.includeUpdateBytes,
     })
@@ -375,6 +376,7 @@ export class OracleAPI {
     options?: Omit<IPythProStreamSubscription, 'subscriptionId' | 'priceFeedIds'>,
     subscriptionId = 1,
   ): Promise<() => void> {
+    const config = this.getOracleProConfig()
     const client = this.createPythProStreamClient()
     const priceFeedIds = this.resolveLazerFeedIdsForTokens(tokens)
     await client.connect()
@@ -383,6 +385,7 @@ export class OracleAPI {
         subscriptionId,
         priceFeedIds,
         ...options,
+        channel: options?.channel ?? (config.lazerChannel as PythProChannel),
       },
       onUpdate,
     )

package/src/oraclePro.ts

@@ -13,7 +13,7 @@ import {
   getPythFeederToPriceId,
   getZoOracleConfig,
 } from './consts'
-import type { PythProChannel } from './pythProClient'
+import type { PythProChannel, PythProLatestPriceData, PythProPriceFeed } from './pythProClient'
 import { fetchPythProUpdateBytesFromKronos } from './pythProClient'
 import { hexToBytes } from './storkClient'
 import { parseSymbolKey } from './utils'
@@ -174,6 +174,87 @@ export function resolveLazerFeedIds(
   return [...ids]
 }
 
+/** Parse a Pyth Pro feed's raw price + exponent into a decimal number (matches on-chain normalization). */
+export function parsePythProFeedDecimalPrice(feed: PythProPriceFeed): number {
+  const raw = Number(feed.price)
+  const expo = feed.exponent
+  if (expo < 0) {
+    return raw / 10 ** -expo
+  }
+  return raw * 10 ** expo
+}
+
+export function buildPythProPriceFeedMap(
+  data: PythProLatestPriceData,
+): Map<number, PythProPriceFeed> {
+  const map = new Map<number, PythProPriceFeed>()
+  for (const feed of data.priceFeeds) {
+    map.set(feed.priceFeedId, feed)
+  }
+  return map
+}
+
+export interface IResolveTokenUsdPriceFromPythProParams {
+  token: string
+  feedById: Map<number, PythProPriceFeed>
+  zoOracle: IZoOracleConfig
+  coins: Record<string, { module: string }>
+  network: Network
+  legacyFeeders?: Record<string, string>
+}
+
+/**
+ * Resolve a token's USD price from batched Pyth Pro feeds.
+ * LST SUI vaults (afSui, vSui, haSui, stSui) use RR feed rate × SUI/USD.
+ */
+export function resolveTokenUsdPriceFromPythPro(
+  params: IResolveTokenUsdPriceFromPythProParams,
+): number {
+  const { token, feedById, zoOracle, coins, network, legacyFeeders } = params
+  const coinModuleMap = buildCoinModuleToLazerFeedId(zoOracle.pythLazer, zoOracle, network)
+
+  if (LST_SUI_TOKENS.has(token)) {
+    const rrFeedId = LST_SUI_PYTH_LAZER_RR_FEED_IDS[token]
+    const rrFeed = feedById.get(rrFeedId)
+    if (!rrFeed) {
+      throw new Error(`Missing Pyth Pro RR feed ${rrFeedId} for LST token "${token}"`)
+    }
+    const suiLazerId = lookupLazerFeedIdForToken(
+      'sui',
+      zoOracle,
+      coins,
+      network,
+      coinModuleMap,
+      legacyFeeders,
+    )
+    if (suiLazerId === undefined) {
+      throw new Error(`No Pyth Lazer feed id for SUI (required for LST token "${token}")`)
+    }
+    const suiFeed = feedById.get(suiLazerId)
+    if (!suiFeed) {
+      throw new Error(`Missing Pyth Pro SUI feed ${suiLazerId} for LST token "${token}"`)
+    }
+    return parsePythProFeedDecimalPrice(rrFeed) * parsePythProFeedDecimalPrice(suiFeed)
+  }
+
+  const lazerId = lookupLazerFeedIdForToken(
+    token,
+    zoOracle,
+    coins,
+    network,
+    coinModuleMap,
+    legacyFeeders,
+  )
+  if (lazerId === undefined) {
+    throw new Error(`No Pyth Lazer feed id for token "${token}"`)
+  }
+  const feed = feedById.get(lazerId)
+  if (!feed) {
+    throw new Error(`Missing Pyth Pro feed ${lazerId} for token "${token}"`)
+  }
+  return parsePythProFeedDecimalPrice(feed)
+}
+
 function resolveStorkAssetId(symbolKey: string, config: IZoOracleSymbolConfig): string {
   return config.storkAssetId ?? symbolKey.replace('/', '')
 }

package/src/pythProClient.ts

@@ -6,6 +6,8 @@ export type PythProChannel
     | 'fixed_rate@200ms'
     | 'fixed_rate@1000ms'
 
+export const DEFAULT_PYTH_PRO_CHANNEL: PythProChannel = 'fixed_rate@1000ms'
+
 export interface PythProPriceFeed {
   priceFeedId: number
   price: string
@@ -106,7 +108,8 @@ export async function getLatestPythProPrices(
   baseUrl: string,
   options: IGetLatestPythProPricesOptions,
 ): Promise<PythProLatestPriceData> {
-  const { priceFeedIds, channel, includeEmaPrice, includeUpdateBytes } = options
+  const { priceFeedIds, includeEmaPrice, includeUpdateBytes } = options
+  const channel = options.channel ?? DEFAULT_PYTH_PRO_CHANNEL
   if (priceFeedIds.length === 0) {
     throw new Error('priceFeedIds is required')
   }
@@ -116,9 +119,7 @@ export async function getLatestPythProPrices(
   if (priceFeedIds.length <= 20) {
     const params = new URLSearchParams()
     params.set('priceFeedIds', priceFeedIds.join(','))
-    if (channel) {
-      params.set('channel', channel)
-    }
+    params.set('channel', channel)
     if (includeEmaPrice) {
       params.set('includeEmaPrice', 'true')
     }
@@ -280,7 +281,11 @@ export class PythProStreamClient {
     options: IPythProStreamSubscription,
     onUpdate: StreamUpdateHandler,
   ): () => void {
-    this.subscriptions.set(options.subscriptionId, options)
+    const subscription = {
+      ...options,
+      channel: options.channel ?? DEFAULT_PYTH_PRO_CHANNEL,
+    }
+    this.subscriptions.set(subscription.subscriptionId, subscription)
 
     let handlers = this.updateHandlers.get(options.subscriptionId)
     if (!handlers) {
@@ -290,11 +295,11 @@ export class PythProStreamClient {
     handlers.add(onUpdate)
 
     void this.connect().then(() => {
-      this.send({ type: 'subscribe', ...options })
+      this.send({ type: 'subscribe', ...subscription })
     })
 
     return () => {
-      this.unsubscribe(options.subscriptionId, onUpdate)
+      this.unsubscribe(subscription.subscriptionId, onUpdate)
     }
   }
 

package/tests/pythProClient.test.ts

@@ -41,7 +41,7 @@ describe('pythProClient REST', () => {
 
     expect(data.priceFeeds).toHaveLength(1)
     expect(fetchMock).toHaveBeenCalledWith(
-      'http://localhost:8080/pyth-pro/latest-price?priceFeedIds=1%2C2&includeEmaPrice=true',
+      'http://localhost:8080/pyth-pro/latest-price?priceFeedIds=1%2C2&channel=fixed_rate%401000ms&includeEmaPrice=true',
     )
   })