@zofai/zo-sdk 0.2.26 → 0.2.28

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,
@@ -38,7 +38,14 @@ import type {
   ISLPVaultInfo,
   ISwapFeeBreakdown,
 } from '../interfaces'
+import type { OracleInputs } from '../oraclePro'
 import type { DynamicFieldInfo, SuiClient } from '../suiClient'
+import {
+  buildPythProPriceFeedMap,
+  resolveTokenUsdPriceFromPythPro,
+  valuateSymbolsV3,
+  valuateVaultsV3,
+} from '../oraclePro'
 import { joinSymbol, parseSymbolKey, parseValue, suiSymbolToSymbol } from '../utils'
 
 export interface GetCumulativeAprResponse {
@@ -210,6 +217,46 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     return { vaultsValuation, symbolsValuation }
   }
 
+  /** Creates vaults valuation using valuate_vault_v3 (Pyth Pro + Stork, sudo-core). */
+  public valuateVaultsV3(tx: Transaction, oracle: OracleInputs) {
+    if (!this.consts.sudoCore) {
+      throw new Error('Sudo Core configuration not found. Make sure you are using LPToken.SLP')
+    }
+    return valuateVaultsV3({
+      tx,
+      upgradedPackage: this.consts.sudoCore.upgradedPackage,
+      lpType: `${this.consts.sudoCore.package}::slp::SLP`,
+      market: this.consts.sudoCore.market,
+      vaults: this.consts.sudoCore.vaults,
+      coinModules: this.consts.coins,
+      oracle,
+    })
+  }
+
+  /** Creates symbols valuation using valuate_symbol_v3 (Pyth Pro + Stork, sudo-core). */
+  public valuateSymbolsV3(tx: Transaction, oracle: OracleInputs) {
+    if (!this.consts.sudoCore) {
+      throw new Error('Sudo Core configuration not found. Make sure you are using LPToken.SLP')
+    }
+    return valuateSymbolsV3({
+      tx,
+      upgradedPackage: this.consts.sudoCore.upgradedPackage,
+      marketPackage: this.consts.sudoCore.package,
+      lpType: `${this.consts.sudoCore.package}::slp::SLP`,
+      market: this.consts.sudoCore.market,
+      symbols: this.consts.sudoCore.symbols,
+      coinModules: this.consts.coins,
+      oracle,
+    })
+  }
+
+  /** Creates both vaults and symbols valuation (Pyth Pro + Stork, sudo-core). */
+  public valuateV3(tx: Transaction, oracle: OracleInputs) {
+    const vaultsValuation = this.valuateVaultsV3(tx, oracle)
+    const symbolsValuation = this.valuateSymbolsV3(tx, oracle)
+    return { vaultsValuation, symbolsValuation }
+  }
+
   /**
    * Valuates the SLP market using Sudo SDK's approach
    */
@@ -219,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 }
@@ -234,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')
@@ -351,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/interfaces/slp.ts

@@ -6,6 +6,7 @@
 import type { KioskClient, KioskOwnerCap } from '@mysten/kiosk'
 import type { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions'
 
+import type { OracleInputs } from '../oraclePro'
 import type {
   IBaseAPI,
   IBaseCredential,
@@ -217,6 +218,12 @@ export interface ISLPDataAPI extends IBaseDataAPI {
   getSymbolConfig: (indexToken: string, long: boolean) => Promise<ISLPSymbolConfig | null>
   getPriceImpactConfig: (indexToken: string) => Promise<ISLPPriceImpactConfig | null>
   calculateSwapFeeBreakdown: (fromToken: string, toToken: string, fromAmount: number) => Promise<ISwapFeeBreakdown>
+  valuateVaultsV3: (tx: Transaction, oracle: OracleInputs) => TransactionObjectArgument
+  valuateSymbolsV3: (tx: Transaction, oracle: OracleInputs) => TransactionObjectArgument
+  valuateV3: (tx: Transaction, oracle: OracleInputs) => {
+    vaultsValuation: TransactionObjectArgument
+    symbolsValuation: TransactionObjectArgument
+  }
 }
 
 // SLP-specific API interface
@@ -286,4 +293,167 @@ export interface ISLPAPI extends IBaseAPI {
     minAmountOut?: number,
     tx?: Transaction,
   ) => Promise<TransactionObjectArgument>
+
+  swapV4: (
+    fromToken: string,
+    toToken: string,
+    fromAmount: bigint,
+    fromCoinObjects: string[],
+    pythProUpdateBytes: Uint8Array | number[],
+    minAmountOut?: number,
+    tx?: Transaction,
+  ) => Promise<Transaction>
+
+  swapV4Ptb: (
+    fromToken: string,
+    toToken: string,
+    fromAmount: bigint,
+    fromCoinObjects: string[],
+    pythProUpdateBytes: Uint8Array | number[],
+    minAmountOut?: number,
+    tx?: Transaction,
+  ) => Promise<TransactionObjectArgument>
+
+  openPositionV3: (
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    collateralAmount: bigint,
+    coinObjects: string[],
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    pythProUpdateBytes: Uint8Array | number[],
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    referralAddress?: string,
+    sender?: string,
+    sponsoredTx?: boolean,
+  ) => Promise<Transaction>
+
+  openPositionWithSCardV3: (
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    collateralAmount: bigint,
+    coinObjects: string[],
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    pythProUpdateBytes: Uint8Array | number[],
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    referralAddress?: string,
+    sender?: string,
+    sponsoredTx?: boolean,
+  ) => Promise<Transaction>
+
+  openPositionWithCoinV3: (
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    coinObj: TransactionObjectArgument,
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    pythProUpdateBytes: Uint8Array | number[],
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    referralAddress?: string,
+    sender?: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+  ) => Promise<Transaction>
+
+  openPositionWithCoinAndSCardV3: (
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    coinObj: TransactionObjectArgument,
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    pythProUpdateBytes: Uint8Array | number[],
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    referralAddress?: string,
+    sender?: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+  ) => Promise<Transaction>
+
+  decreasePositionV3: (
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: bigint,
+    long: boolean,
+    indexPrice: number,
+    collateralPrice: number,
+    pythProUpdateBytes: Uint8Array | number[],
+    isTriggerOrder?: boolean,
+    isTakeProfitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    coinObjects?: string[],
+    sponsoredTx?: boolean,
+    sender?: string,
+  ) => Promise<Transaction>
+
+  decreasePositionWithSCardV3: (
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: bigint,
+    long: boolean,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    pythProUpdateBytes: Uint8Array | number[],
+    isTriggerOrder?: boolean,
+    isTakeProfitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    coinObjects?: string[],
+    sponsoredTx?: boolean,
+    sender?: string,
+  ) => Promise<Transaction>
+
+  redeemFromPositionV3: (
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: number,
+    long: boolean,
+    pythProUpdateBytes: Uint8Array | number[],
+    tx?: Transaction,
+  ) => Promise<Transaction>
 }

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'
@@ -60,6 +60,44 @@ export function requireOracleProConfig(network: Network): IOracleProConfig {
   return buildOracleProConfig(getZoOracleConfig(network))
 }
 
+/**
+ * LST SUI vault tokens priced on-chain via Pyth Lazer RR feed × SUI/USD.
+ * Numeric ids are Pyth Lazer `priceFeedIds` (not Hermes price ids).
+ */
+export const LST_SUI_PYTH_LAZER_RR_FEED_IDS: Record<string, number> = {
+  afSui: 3245,
+  stSui: 736,
+  vSui: 2349,
+  haSui: 3244,
+}
+
+const LST_SUI_TOKENS = new Set(Object.keys(LST_SUI_PYTH_LAZER_RR_FEED_IDS))
+
+function lookupLazerFeedIdForToken(
+  token: string,
+  zoOracle: IZoOracleConfig,
+  coins: Record<string, { module: string }>,
+  network: Network,
+  coinModuleMap: Map<string, number>,
+  legacyFeeders?: Record<string, string>,
+): number | undefined {
+  const module = coins[token]?.module
+  if (!module) {
+    return undefined
+  }
+
+  let lazerId = coinModuleMap.get(normalizeCoinType(module))
+
+  if (lazerId === undefined && legacyFeeders?.[token]) {
+    const priceId = getPythFeederToPriceId(network)[legacyFeeders[token]]
+    if (priceId) {
+      lazerId = zoOracle.pythLazer.feedIds[priceId]
+    }
+  }
+
+  return lazerId
+}
+
 /**
  * Build coin module -> Lazer feed id using zo_oracle symbol configs + Hermes price id map.
  */
@@ -93,9 +131,7 @@ export function resolveLazerFeedIds(
   network: Network,
   legacyFeeders?: Record<string, string>,
 ): number[] {
-  const { pythLazer } = zoOracle
-  const coinModuleMap = buildCoinModuleToLazerFeedId(pythLazer, zoOracle, network)
-  const feederToPriceId = getPythFeederToPriceId(network)
+  const coinModuleMap = buildCoinModuleToLazerFeedId(zoOracle.pythLazer, zoOracle, network)
 
   const ids = new Set<number>()
   for (const token of tokens) {
@@ -104,15 +140,32 @@ export function resolveLazerFeedIds(
       throw new Error(`Unknown token: ${token}`)
     }
 
-    let lazerId = coinModuleMap.get(normalizeCoinType(module))
-
-    if (lazerId === undefined && legacyFeeders?.[token]) {
-      const priceId = feederToPriceId[legacyFeeders[token]]
-      if (priceId) {
-        lazerId = pythLazer.feedIds[priceId]
+    if (LST_SUI_TOKENS.has(token)) {
+      ids.add(LST_SUI_PYTH_LAZER_RR_FEED_IDS[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}")`)
       }
+      ids.add(suiLazerId)
+      continue
     }
 
+    const lazerId = lookupLazerFeedIdForToken(
+      token,
+      zoOracle,
+      coins,
+      network,
+      coinModuleMap,
+      legacyFeeders,
+    )
+
     if (lazerId === undefined) {
       throw new Error(`No Pyth Lazer feed id for token "${token}" (${module})`)
     }
@@ -121,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('/', '')
 }
@@ -212,6 +346,11 @@ export function oracleArgsAlt(oracle: OracleInputsAlt): TransactionObjectArgumen
   return [oracle.oracleRegistry, oracle.storkState, oracle.pythProUpdate]
 }
 
+/** Sudo-core valuation/swap order: `[oracleRegistry, pythProUpdate, storkState, clock]`. */
+export function oracleArgsRegistryFirst(oracle: OracleInputs): TransactionObjectArgument[] {
+  return [oracle.oracleRegistry, oracle.pythProUpdate, oracle.storkState, oracle.clock]
+}
+
 export function buildOracleInputsAlt(oracle: OracleInputs): OracleInputsAlt {
   return {
     oracleRegistry: oracle.oracleRegistry,
@@ -312,3 +451,83 @@ export function valuateSymbolsV2(params: IValuateSymbolsV2Params): TransactionOb
 
   return symbolsValuation
 }
+
+export interface IValuateVaultsV3Params {
+  tx: Transaction
+  upgradedPackage: string
+  lpType: string
+  market: string
+  vaults: Record<string, { reservingFeeModel: string }>
+  coinModules: Record<string, { module: string }>
+  oracle: OracleInputs
+}
+
+/** create_vaults_valuation + valuate_vault_v3 for each vault (sudo-core). */
+export function valuateVaultsV3(params: IValuateVaultsV3Params): TransactionObjectArgument {
+  const { tx, upgradedPackage, lpType, market, vaults, coinModules, oracle } = params
+
+  const vaultsValuation = tx.moveCall({
+    target: `${upgradedPackage}::market::create_vaults_valuation`,
+    typeArguments: [lpType],
+    arguments: [oracle.clock, tx.object(market)],
+  })
+
+  for (const key of Object.keys(vaults)) {
+    const vault = vaults[key]
+    tx.moveCall({
+      target: `${upgradedPackage}::market::valuate_vault_v3`,
+      typeArguments: [lpType, coinModules[key].module],
+      arguments: [
+        tx.object(market),
+        tx.object(vault.reservingFeeModel),
+        ...oracleArgsRegistryFirst(oracle),
+        vaultsValuation,
+      ],
+    })
+  }
+
+  return vaultsValuation
+}
+
+export interface IValuateSymbolsV3Params {
+  tx: Transaction
+  upgradedPackage: string
+  marketPackage: string
+  lpType: string
+  market: string
+  symbols: Record<string, { fundingFeeModel: string }>
+  coinModules: Record<string, { module: string }>
+  oracle: OracleInputs
+}
+
+/** create_symbols_valuation + valuate_symbol_v3 for each symbol (sudo-core). */
+export function valuateSymbolsV3(params: IValuateSymbolsV3Params): TransactionObjectArgument {
+  const { tx, upgradedPackage, marketPackage, lpType, market, symbols, coinModules, oracle } = params
+
+  const symbolsValuation = tx.moveCall({
+    target: `${upgradedPackage}::market::create_symbols_valuation`,
+    typeArguments: [lpType],
+    arguments: [oracle.clock, tx.object(market)],
+  })
+
+  for (const key of Object.keys(symbols)) {
+    const [direction, token] = parseSymbolKey(key)
+    const symbol = symbols[key]
+    tx.moveCall({
+      target: `${upgradedPackage}::market::valuate_symbol_v3`,
+      typeArguments: [
+        lpType,
+        coinModules[token].module,
+        `${marketPackage}::market::${direction.toUpperCase()}`,
+      ],
+      arguments: [
+        tx.object(market),
+        tx.object(symbol.fundingFeeModel),
+        ...oracleArgsRegistryFirst(oracle),
+        symbolsValuation,
+      ],
+    })
+  }
+
+  return symbolsValuation
+}

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)
     }
   }