@zofai/zo-sdk 0.2.13 → 0.2.15

package/src/implementations/USDZDataAPI.ts

@@ -10,6 +10,8 @@ import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui/utils'
 
 import { BaseDataAPI } from '../abstract'
 import type { Network } from '../consts'
+import type { OracleInputs } from '../oraclePro'
+import { valuateSymbolsV2, valuateVaultsV2 } from '../oraclePro'
 import { LPToken, SECONDS_PER_EIGHT_HOUR, USDZ_TOKEN_DECIMALS } from '../consts'
 import type {
   IBaseHistoryResponse,
@@ -203,6 +205,46 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     return { vaultsValuation, symbolsValuation }
   }
 
+  /**
+   * Creates vaults valuation using valuate_vault_v2 (Pyth Pro + Stork).
+   */
+  public valuateVaultsV2(tx: Transaction, oracle: OracleInputs) {
+    return valuateVaultsV2({
+      tx,
+      upgradedPackage: this.consts.zoCore.upgradedPackage,
+      lpType: `${this.consts.zoCore.package}::usdz::USDZ`,
+      market: this.consts.zoCore.market,
+      vaults: this.consts.zoCore.vaults,
+      coinModules: this.consts.coins,
+      oracle,
+    })
+  }
+
+  /**
+   * Creates symbols valuation using valuate_symbol_v2 (Pyth Pro + Stork).
+   */
+  public valuateSymbolsV2(tx: Transaction, oracle: OracleInputs) {
+    return valuateSymbolsV2({
+      tx,
+      upgradedPackage: this.consts.zoCore.upgradedPackage,
+      marketPackage: this.consts.zoCore.package,
+      lpType: `${this.consts.zoCore.package}::usdz::USDZ`,
+      market: this.consts.zoCore.market,
+      symbols: this.consts.zoCore.symbols,
+      coinModules: this.consts.coins,
+      oracle,
+    })
+  }
+
+  /**
+   * Creates both vaults and symbols valuation (Pyth Pro + Stork).
+   */
+  public valuateV2(tx: Transaction, oracle: OracleInputs) {
+    const vaultsValuation = this.valuateVaultsV2(tx, oracle)
+    const symbolsValuation = this.valuateSymbolsV2(tx, oracle)
+    return { vaultsValuation, symbolsValuation }
+  }
+
   /**
    * Valuates the USDZ market
    */

package/src/index.ts

@@ -29,6 +29,9 @@ export * from './coins'
 export * from './consts'
 export * from './data'
 export * from './oracle'
+export * from './oraclePro'
+export * from './storkClient'
+export * from './storkOracle'
 export * from './utils'
 
 // Re-export commonly used types from Sui SDK

package/src/interfaces/base.ts

@@ -8,7 +8,15 @@ import type { Transaction, TransactionObjectArgument } from '@mysten/sui/transac
 import type { PriceFeed } from '@pythnetwork/pyth-sui-js'
 
 import type { IConsts, LPToken, Network } from '../consts'
-import type { IInitOracleTxbResult } from '../oracle'
+import type { IInitOracleTxbResult, IInitPythProOracleOptions } from '../oracle'
+import type { IInitPythProOracleTxbResult } from '../oraclePro'
+import type {
+  IGetLatestPythProPricesOptions,
+  IPythProStreamSubscription,
+  PythProLatestPriceData,
+  PythProStreamClient,
+  PythProStreamUpdate,
+} from '../pythProClient'
 import type { SuiClient } from '../suiClient'
 
 // Common data interfaces
@@ -301,6 +309,51 @@ export interface IBaseDataAPI {
     sponsorOptions?: { sender: string, additionalSuiAmount?: bigint },
   ) => Promise<IInitOracleTxbResult>
 
+  /** Pyth Pro + Stork: Stork updates + parse_and_verify_le_ecdsa_update_v2 PTB prelude. */
+  initV3OracleTxb: (
+    tokens: string[],
+    tx?: Transaction,
+    options?: IInitPythProOracleOptions,
+  ) => Promise<IInitPythProOracleTxbResult>
+
+  /** @deprecated Alias for {@link initV3OracleTxb}. */
+  initPythProOracleTxb: (
+    tokens: string[],
+    tx?: Transaction,
+    options?: IInitPythProOracleOptions,
+  ) => Promise<IInitPythProOracleTxbResult>
+
+  resolveStorkAssetsForTokens: (tokens: string[]) => string[]
+
+  fetchStorkUpdateDataForTokens: (tokens: string[]) => Promise<import('../storkClient').IStorkUpdateData[]>
+
+  estimateStorkUpdateFeeForTokens: (tokens: string[]) => bigint
+
+  fetchPythProUpdateBytesForTokens: (
+    tokens: string[],
+    options?: IInitPythProOracleOptions,
+  ) => Promise<Uint8Array>
+
+  /** Resolve SDK token ids to Pyth Lazer numeric feed ids. */
+  resolveLazerFeedIdsForTokens: (tokens: string[]) => number[]
+
+  /** Latest Pyth Pro snapshot via kronos REST. Requires apiEndpoint. */
+  getLatestPythProPricesForTokens: (
+    tokens: string[],
+    options?: Omit<IGetLatestPythProPricesOptions, 'priceFeedIds'>,
+  ) => Promise<PythProLatestPriceData>
+
+  /** kronos WebSocket client for `/pyth-pro/stream`. Requires apiEndpoint. */
+  createPythProStreamClient: () => PythProStreamClient
+
+  /** Live Pyth Pro prices via kronos WebSocket. Requires apiEndpoint. */
+  subPythProPricesForTokens: (
+    tokens: string[],
+    onUpdate: (update: PythProStreamUpdate) => void,
+    options?: Omit<IPythProStreamSubscription, 'subscriptionId' | 'priceFeedIds'>,
+    subscriptionId?: number,
+  ) => Promise<() => void>
+
   // Utility methods
   validateCache: () => void
 }

package/src/interfaces/usdz.ts

@@ -5,6 +5,7 @@
 
 import type { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions'
 
+import type { OracleInputs } from '../oraclePro'
 import type {
   IBaseAPI,
   IBaseCredential,
@@ -139,6 +140,9 @@ export interface IUSDZDataAPI extends IBaseDataAPI {
   getSymbolConfig: (indexToken: string, long: boolean) => Promise<IUSDZSymbolConfig | null>
   getPriceImpactConfig: (indexToken: string) => Promise<IUSDZPriceImpactConfig | null>
   calculateSwapFeeBreakdown: (fromToken: string, toToken: string, fromAmount: number) => Promise<ISwapFeeBreakdown>
+  valuateVaultsV2: (tx: Transaction, oracle: OracleInputs) => TransactionObjectArgument
+  valuateSymbolsV2: (tx: Transaction, oracle: OracleInputs) => TransactionObjectArgument
+  valuateV2: (tx: Transaction, oracle: OracleInputs) => { vaultsValuation: TransactionObjectArgument, symbolsValuation: TransactionObjectArgument }
 }
 
 // USDZ-specific API interface
@@ -199,4 +203,125 @@ export interface IUSDZAPI extends IBaseAPI {
     minAmountOut?: number,
     tx?: Transaction,
   ) => Promise<TransactionObjectArgument>
+
+  /** Pyth Pro + Stork swap (transfers output). */
+  swapV3: (
+    fromToken: string,
+    toToken: string,
+    fromAmount: bigint,
+    fromCoinObjects: string[],
+    pythProUpdateBytes: Uint8Array | number[],
+    minAmountOut?: number,
+    tx?: Transaction,
+  ) => Promise<Transaction>
+
+  /** Pyth Pro + Stork swap PTB (returns output coin). */
+  swapV3Ptb: (
+    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: import('@mysten/kiosk').KioskClient,
+    kioskCap: import('@mysten/kiosk').KioskOwnerCap,
+    scard: string,
+    pythProUpdateBytes: Uint8Array | number[],
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    referralAddress?: string,
+    sender?: string,
+    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: import('@mysten/kiosk').KioskClient,
+    kioskCap: import('@mysten/kiosk').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>
+
+  /** Pyth Pro path (not legacy feeder v2). */
+  redeemFromPositionV2: (
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: number,
+    long: boolean,
+    pythProUpdateBytes: Uint8Array | number[],
+    tx?: Transaction,
+  ) => Promise<Transaction>
 }

package/src/oracle.ts

@@ -5,7 +5,47 @@ import { SuiPriceServiceConnection, SuiPythClient } from '@pythnetwork/pyth-sui-
 
 import { resolveSpendableSuiCoin } from './coins'
 import type { IConsts, Network } from './consts'
-import { getConsts, getPriceIdToPythFeeder, getPythFeederToId, getPythFeederToPriceId, getSharedConfig, LPToken } from './consts'
+import {
+  buildOracleProConfig,
+  DEFAULT_API_ENDPOINT,
+  getConsts,
+  getPriceIdToPythFeeder,
+  getPythFeederToId,
+  getPythFeederToPriceId,
+  getSharedConfig,
+  getZoOracleConfig,
+  LPToken,
+} from './consts'
+import type {
+  IFetchPythProUpdateOptions,
+  IInitPythProOracleTxbResult,
+  OracleInputs,
+} from './oraclePro'
+import {
+  buildOracleInputs,
+  buildStorkAssetIdMap,
+  fetchPythProUpdateBytes,
+  parseAndVerifyPythProUpdate,
+  resolveLazerFeedIds,
+  resolveStorkAssetsForTokens,
+} from './oraclePro'
+import type {
+  IGetLatestPythProPricesOptions,
+  IPythProStreamSubscription,
+  PythProChannel,
+  PythProLatestPriceData,
+  PythProStreamUpdate,
+} from './pythProClient'
+import {
+  getLatestPythProPrices,
+  PythProStreamClient,
+} from './pythProClient'
+import type { IStorkUpdateData } from './storkClient'
+import { fetchStorkUpdateDataFromKronos } from './storkClient'
+import {
+  appendStorkUpdatesToTransaction,
+  estimateStorkUpdateFeeMist,
+} from './storkOracle'
 import type { SuiClient } from './suiClient'
 import { createJsonRpcProvider } from './utils'
 
@@ -15,6 +55,17 @@ export interface IInitOracleSponsorOptions {
   additionalSuiAmount?: bigint
 }
 
+export interface IInitPythProOracleOptions extends IFetchPythProUpdateOptions {
+  /** Pre-fetched leEcdsa update bytes. When omitted, bytes are fetched via kronos REST. */
+  rawUpdateBytes?: Uint8Array | number[]
+  /** Pre-fetched Stork update payloads. When omitted, fetched via kronos REST when needed. */
+  storkUpdateData?: IStorkUpdateData[]
+  /** Skip Stork on-chain updates even when assets are configured. */
+  skipStork?: boolean
+  /** Coin to split Stork update fees from (defaults to gas coin). */
+  storkFeeSource?: TransactionObjectArgument
+}
+
 export interface IInitOracleTxbResult {
   tx: Transaction
   /** Remaining SUI coin after Pyth fee splits; present when sponsored and SUI was resolved. */
@@ -26,6 +77,8 @@ export class OracleAPI {
   consts: IConsts
   sharedConfig: IConsts
   connectionURL: string
+  /** Kronos REST base URL for Pyth Pro proxy. Defaults to `DEFAULT_API_ENDPOINT`. */
+  apiEndpoint: string
   PythFeederToPriceId: Record<string, string>
   PythFeederToId: Record<string, string>
   provider: SuiClient
@@ -39,11 +92,13 @@ export class OracleAPI {
     // todo 需要从配置文件中获取
     connectionURL: string,
     lpToken: LPToken = LPToken.ZLP,
+    apiEndpoint: string = DEFAULT_API_ENDPOINT,
   ) {
     this.network = network
     this.consts = getConsts(network, lpToken)
     this.sharedConfig = getSharedConfig(network)
     this.connectionURL = connectionURL
+    this.apiEndpoint = apiEndpoint
     this.PythFeederToPriceId = getPythFeederToPriceId(network)
     this.PythFeederToId = getPythFeederToId(network)
     this.provider = provider || createJsonRpcProvider(network)
@@ -190,4 +245,170 @@ export class OracleAPI {
   async getBaseUpdateFee(): Promise<number> {
     return await this.client.getBaseUpdateFee()
   }
+
+  /**
+   * Resolve SDK token ids (e.g. `sui`, `btc`) to Pyth Lazer numeric feed ids.
+   */
+  resolveLazerFeedIdsForTokens(tokens: string[]): number[] {
+    const zoOracle = getZoOracleConfig(this.network)
+    return resolveLazerFeedIds(
+      zoOracle,
+      this.consts.coins,
+      tokens,
+      this.network,
+      this.consts.pythFeeder.feeder,
+    )
+  }
+
+  /** Map SDK token ids to kronos Stork asset ids (e.g. `BTCUSD`). */
+  resolveStorkAssetsForTokens(tokens: string[]): string[] {
+    const zoOracle = getZoOracleConfig(this.network)
+    return resolveStorkAssetsForTokens(zoOracle, this.consts.coins, tokens)
+  }
+
+  /** Fetch Stork on-chain update payloads via kronos REST. */
+  async fetchStorkUpdateDataForTokens(tokens: string[]): Promise<IStorkUpdateData[]> {
+    const zoOracle = getZoOracleConfig(this.network)
+    const assets = this.resolveStorkAssetsForTokens(tokens)
+    if (assets.length === 0) {
+      return []
+    }
+    return await fetchStorkUpdateDataFromKronos(
+      this.resolveKronosUrl(),
+      assets,
+      buildStorkAssetIdMap(zoOracle),
+    )
+  }
+
+  /** Estimated Stork update fee in MIST for the given SDK tokens. */
+  estimateStorkUpdateFeeForTokens(tokens: string[]): bigint {
+    return estimateStorkUpdateFeeMist(this.resolveStorkAssetsForTokens(tokens).length)
+  }
+
+  /** Kronos REST base URL used for Pyth Pro / Stork (`options.kronosUrl` overrides per call). */
+  protected resolveKronosUrl(kronosUrl?: string): string {
+    return kronosUrl ?? this.apiEndpoint
+  }
+
+  /**
+   * V3 oracle PTB prelude: Stork on-chain updates → Pyth Pro verify → OracleInputs.
+   * Order: (1) Stork update, (2) parse_and_verify_le_ecdsa_update_v2, (3) ready for market op.
+   */
+  async initV3OracleTxb(
+    tokens: string[],
+    tx?: Transaction,
+    options?: IInitPythProOracleOptions,
+  ): Promise<IInitPythProOracleTxbResult> {
+    const tx_ = tx ?? new Transaction()
+    const config = this.getOracleProConfig()
+
+    if (!options?.skipStork) {
+      const storkAssets = this.resolveStorkAssetsForTokens(tokens)
+      if (storkAssets.length > 0) {
+        let storkUpdates = options?.storkUpdateData
+        if (!storkUpdates) {
+          const zoOracle = getZoOracleConfig(this.network)
+          storkUpdates = await fetchStorkUpdateDataFromKronos(
+            this.resolveKronosUrl(options?.kronosUrl),
+            storkAssets,
+            buildStorkAssetIdMap(zoOracle),
+          )
+        }
+        appendStorkUpdatesToTransaction(tx_, config, storkUpdates, {
+          feeSource: options?.storkFeeSource,
+        })
+      }
+    }
+
+    let rawBytes = options?.rawUpdateBytes
+    if (!rawBytes) {
+      rawBytes = await this.fetchPythProUpdateBytesForTokens(tokens, options)
+    }
+
+    const pythProUpdate = parseAndVerifyPythProUpdate(tx_, config, rawBytes)
+    const oracle = buildOracleInputs(tx_, config, pythProUpdate)
+
+    return { tx: tx_, oracle }
+  }
+
+  /**
+   * Latest Pyth Pro prices via kronos REST (`/pyth-pro/latest-price`).
+   */
+  async getLatestPythProPricesForTokens(
+    tokens: string[],
+    options?: Omit<IGetLatestPythProPricesOptions, 'priceFeedIds'>,
+  ): Promise<PythProLatestPriceData> {
+    const priceFeedIds = this.resolveLazerFeedIdsForTokens(tokens)
+    return getLatestPythProPrices(this.resolveKronosUrl(options?.kronosUrl), {
+      priceFeedIds,
+      channel: options?.channel,
+      includeEmaPrice: options?.includeEmaPrice,
+      includeUpdateBytes: options?.includeUpdateBytes,
+    })
+  }
+
+  /** WebSocket client for kronos `/pyth-pro/stream`. */
+  createPythProStreamClient(kronosUrl?: string): PythProStreamClient {
+    return new PythProStreamClient(this.resolveKronosUrl(kronosUrl))
+  }
+
+  /**
+   * Subscribe to live Pyth Pro prices for SDK tokens via kronos WebSocket.
+   * Returns unsubscribe (closes subscription; disconnect the client separately if unused).
+   */
+  async subPythProPricesForTokens(
+    tokens: string[],
+    onUpdate: (update: PythProStreamUpdate) => void,
+    options?: Omit<IPythProStreamSubscription, 'subscriptionId' | 'priceFeedIds'>,
+    subscriptionId = 1,
+  ): Promise<() => void> {
+    const client = this.createPythProStreamClient()
+    const priceFeedIds = this.resolveLazerFeedIdsForTokens(tokens)
+    await client.connect()
+    return client.subscribe(
+      {
+        subscriptionId,
+        priceFeedIds,
+        ...options,
+      },
+      onUpdate,
+    )
+  }
+
+  /**
+   * Fetch leEcdsa update bytes covering all tokens' Pyth Lazer feed ids via kronos REST.
+   */
+  async fetchPythProUpdateBytesForTokens(
+    tokens: string[],
+    options?: IFetchPythProUpdateOptions,
+  ): Promise<Uint8Array> {
+    const config = this.getOracleProConfig()
+    const feedIds = this.resolveLazerFeedIdsForTokens(tokens)
+    return await fetchPythProUpdateBytes(this.resolveKronosUrl(options?.kronosUrl), feedIds, {
+      channel: options?.channel ?? (config.lazerChannel as PythProChannel),
+      includeEmaPrice: options?.includeEmaPrice,
+    })
+  }
+
+  protected getOracleProConfig() {
+    return buildOracleProConfig(getZoOracleConfig(this.network))
+  }
+
+  /**
+   * PTB step for Pyth Pro paths: Stork updates (when configured) + parse_and_verify_le_ecdsa_update_v2.
+   * @deprecated Alias for {@link initV3OracleTxb}.
+   */
+  async initPythProOracleTxb(
+    tokens: string[],
+    tx?: Transaction,
+    options?: IInitPythProOracleOptions,
+  ): Promise<IInitPythProOracleTxbResult> {
+    return this.initV3OracleTxb(tokens, tx, options)
+  }
+
+  /** Re-use an already-verified Update object (composed PTBs). */
+  buildOracleInputsFromUpdate(tx: Transaction, pythProUpdate: TransactionObjectArgument): OracleInputs {
+    const config = this.getOracleProConfig()
+    return buildOracleInputs(tx, config, pythProUpdate)
+  }
 }