zo-sdk 0.1.43 → 0.1.45

package/src/implementations/SLPDataAPI.ts

@@ -11,7 +11,7 @@ import { Transaction } from '@mysten/sui/transactions'
 import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui/utils'
 
 import { BaseDataAPI } from '../abstract'
-import { Rate, SRate, SymbolsValuation, VaultsValuation } from '../bcs'
+import { Rate, SymbolsValuation, VaultsValuation } from '../bcs'
 import type { Network } from '../consts'
 import { LPToken, SLP_TOKEN_DECIMALS } from '../consts'
 import type {
@@ -21,6 +21,8 @@ import type {
   ISLPFundingFeeModel,
   ISLPMarketInfo,
   ISLPMarketValuationInfo,
+  ISLPOiFundingModel,
+  ISLPOiFundingState,
   ISLPOrderCapInfo,
   ISLPOrderInfo,
   ISLPPositionCapInfo,
@@ -346,6 +348,28 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     }
   }
 
+  /**
+   * Gets SLP symbol OI funding state (global per symbol)
+   */
+  public async getSymbolOiFundingState(indexToken: string): Promise<ISLPOiFundingState | null> {
+    this.validateCache()
+    try {
+      const rawData = await this.provider.getDynamicFieldObject({
+        parentId: this.consts.sudoCore.market,
+        name: {
+          type: `${this.consts.sudoCore.upgradedPackage}::funding::FundingStateKey<${this.consts.coins[indexToken].module}>`,
+          value: { dummy_field: false },
+        },
+      })
+      return SLPDataAPI.parseOiFundingState(rawData)
+    }
+    catch (e: any) {
+      // If the dynamic field doesn't exist, return null
+      console.error('Error Fetching SLP Symbol OI Funding State:', e)
+      return null
+    }
+  }
+
   public async getPositionInfoList(
     positionCapInfoList: ISLPPositionCapInfo[],
     owner: string,
@@ -562,70 +586,38 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     }
   }
 
-  public async fundingFeeRate(indexToken: string, long: boolean, sender?: string): Promise<number> {
-    if (!sender) {
-      throw new Error('Sender address is required for fundingFeeRate calculation')
-    }
-    const tx = await this.initOracleTxb([indexToken])
-    const symbol_ = joinSymbol(long ? 'long' : 'short', indexToken)
-    const currentTimestamp = Number.parseInt((Date.now() / 1000).toFixed(0), 10)
-    const symbol = tx.moveCall({
-      target: `${this.consts.sudoCore.upgradedPackage}::market::symbol`,
-      typeArguments: [
-        `${this.consts.sudoCore.package}::slp::SLP`,
-        this.consts.coins[indexToken].module,
-        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-      ],
-      arguments: [tx.object(this.consts.sudoCore.market)],
-    })
-    const aggPriceConfig = tx.moveCall({
-      target: `${this.consts.sudoCore.package}::pool::symbol_price_config`,
-      typeArguments: [],
-      arguments: [symbol],
-    })
-    const aggPrice = tx.moveCall({
-      target: `${this.consts.sudoCore.package}::agg_price::parse_pyth_feeder_v1_1`,
-      typeArguments: [],
-      arguments: [
-        aggPriceConfig,
-        tx.object(this.consts.pythFeeder.feeder[indexToken]),
-        tx.pure.u64(currentTimestamp),
-      ],
-    })
-    const deltaSize = tx.moveCall({
-      target: `${this.consts.sudoCore.package}::pool::symbol_delta_size`,
-      typeArguments: [],
-      arguments: [symbol, aggPrice, tx.pure.bool(long)],
-    })
-    const LpSupplyAmount = tx.moveCall({
-      target: `${this.consts.sudoCore.upgradedPackage}::market::lp_supply_amount`,
-      typeArguments: [`${this.consts.sudoCore.package}::slp::SLP`],
-      arguments: [tx.object(this.consts.sudoCore.market)],
-    })
-    const PnlPerLp = tx.moveCall({
-      target: `${this.consts.sudoCore.package}::pool::symbol_pnl_per_lp`,
-      typeArguments: [],
-      arguments: [symbol, deltaSize, LpSupplyAmount],
-    })
-    tx.moveCall({
-      target: `${this.consts.sudoCore.package}::model::compute_funding_fee_rate`,
-      arguments: [
-        tx.object(this.consts.sudoCore.symbols[symbol_].fundingFeeModel),
-        PnlPerLp,
-        tx.pure.u64(8 * 3600),
-      ],
-    })
+  public async fundingFeeRate(indexToken: string, long: boolean): Promise<number> {
+    const oiState = await this.getSymbolOiFundingState(indexToken)
+    if (oiState && oiState.enabled) {
+      const longSymbol = await this.getSymbolInfo(indexToken, true)
+      const shortSymbol = await this.getSymbolInfo(indexToken, false)
 
-    const res: any = await this.provider.devInspectTransactionBlock({
-      transactionBlock: tx,
-      sender,
-    })
+      if (longSymbol.lastUpdate <= 0 && shortSymbol.lastUpdate <= 0) {
+        return 0
+      }
 
-    const de = SRate.parse(
-      new Uint8Array(res.results.at(-1).returnValues[0][0]),
-    )
+      const elapsed = SECONDS_PER_EIGHT_HOUR
+      const deltaRate = SLPDataAPI.calcOiFundingFeeRate(
+        oiState.model,
+        longSymbol.openingSize,
+        shortSymbol.openingSize,
+        elapsed,
+      )
+      return long ? deltaRate : -deltaRate
+    }
 
-    return (Number(BigInt(de.value)) / 1e18) * (de.is_positive ? 1 : -1)
+      const symbol = await this.getSymbolInfo(indexToken, long)
+      if (symbol.lastUpdate <= 0) {
+        return 0
+      }
+      const price = (await this.getOraclePrice(indexToken)).getPriceUnchecked().getPriceAsNumberUnchecked()
+      const lpSupplyAmount = (await this.getMarketInfo()).lpSupplyWithDecimals
+      const model = symbol.fundingFeeModel
+      const elapsed = SECONDS_PER_EIGHT_HOUR
+
+      const deltaSize = SLPDataAPI.calcDeltaSize(symbol, price, symbol.long)
+      const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount
+      return SLPDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed)
   }
 
   public async rebaseFeeRate(collateralToken: string, increase: boolean, amount: number, sender?: string): Promise<number> {
@@ -1000,15 +992,52 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
   }
 
   // Private helper methods
-  private static calculatePositionFundingFee(position: ISLPPositionInfo, symbol: ISLPSymbolInfo, model: ISLPFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number): number {
-    const accFundingRate = this.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, position.long)
+  private static calculatePositionFundingFee(
+    position: ISLPPositionInfo,
+    symbol: ISLPSymbolInfo,
+    model: ISLPFundingFeeModel,
+    price: number,
+    lpSupplyAmount: number,
+    timestamp: number,
+    oiModel?: ISLPOiFundingModel,
+    pairedOpeningSize?: number,
+  ): number {
+    const accFundingRate = this.calcAccFundingFeeRate(
+      symbol,
+      model,
+      price,
+      lpSupplyAmount,
+      timestamp,
+      position.long,
+      oiModel,
+      pairedOpeningSize,
+    )
     return position.fundingFeeValue + (accFundingRate - position.lastFundingRate) * position.positionSize
   }
 
-  private static calcAccFundingFeeRate(symbol: ISLPSymbolInfo, model: ISLPFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number, isLong: boolean): number {
+  private static calcAccFundingFeeRate(
+    symbol: ISLPSymbolInfo,
+    model: ISLPFundingFeeModel,
+    price: number,
+    lpSupplyAmount: number,
+    timestamp: number,
+    isLong: boolean,
+    oiModel?: ISLPOiFundingModel,
+    pairedOpeningSize?: number,
+  ): number {
     if (symbol.lastUpdate > 0) {
       const elapsed = timestamp - symbol.lastUpdate
       if (elapsed > 0) {
+        // Prefer OI-based delta when OI model and paired side are available
+        if (oiModel && typeof pairedOpeningSize === 'number') {
+          const longSize = isLong ? symbol.openingSize : pairedOpeningSize
+          const shortSize = isLong ? pairedOpeningSize : symbol.openingSize
+          const deltaRate = SLPDataAPI.calcOiFundingFeeRate(oiModel, longSize, shortSize, elapsed)
+          const appliedRate = isLong ? deltaRate : -deltaRate
+          return symbol.accFundingRate + appliedRate
+        }
+
+        // Fallback to PnL-based funding delta
         const deltaSize = this.calcDeltaSize(symbol, price, isLong)
         const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount
         return symbol.accFundingRate + SLPDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed)
@@ -1028,6 +1057,18 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     return pnlPerRate >= 0 ? -secondsRate : secondsRate
   }
 
+  private static calcOiFundingFeeRate(model: ISLPOiFundingModel, longSize: number, shortSize: number, elapsed: number): number {
+    const imbalance = Math.abs(longSize - shortSize)
+    const denom = longSize + shortSize > 0 ? longSize + shortSize : 1
+
+    const dailyRate = Math.min(
+      (model.multiplier * (imbalance ** model.exponent)) / denom,
+      model.max,
+    )
+    const secondsRate = dailyRate * elapsed / SECONDS_PER_EIGHT_HOUR
+    return longSize >= shortSize ? secondsRate : -secondsRate
+  }
+
   private static calculatePositionReserveFee(position: ISLPPositionInfo, vault: ISLPVaultInfo, model: ISLPReservingFeeModel, timestamp: number): number {
     const accReservingRate = SLPDataAPI.calcAccReservingFeeRate(vault, model, timestamp)
     return position.reservingFeeAmount + (accReservingRate - position.lastReservingRate) * position.collateralAmount
@@ -1112,6 +1153,21 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     }
   }
 
+  private static parseOiFundingState(raw: any): ISLPOiFundingState {
+    const content = raw.data.content.fields
+    return {
+      id: content.id.id,
+      enabled: content.enabled,
+      last_update: parseValue(content.last_update),
+      model: {
+        id: content.model.fields.id.id,
+        multiplier: parseValue(content.model.fields.multiplier),
+        exponent: parseValue(content.model.fields.exponent),
+        max: parseValue(content.model.fields.max),
+      },
+    }
+  }
+
   private static parseMarketInfo(raw: any): ISLPMarketInfo {
     const content = raw.data.content.fields
 
@@ -1236,6 +1292,11 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
           (await this.getVaultInfo(positionInfo.collateralToken)).reservingFeeModel,
           Date.now() / 1000,
         )
+
+        // OI context for funding: fetch state and paired side size when enabled
+        const oiState = await this.getSymbolOiFundingState(positionInfo.indexToken)
+        const pairedSymbol = await this.getSymbolInfo(positionInfo.indexToken, !positionInfo.long)
+
         positionInfo.fundingFeeValue = SLPDataAPI.calculatePositionFundingFee(
           positionInfo,
           await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long),
@@ -1243,6 +1304,8 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
           (await this.getOraclePrice(positionInfo.indexToken)).getPriceUnchecked().getPriceAsNumberUnchecked(),
           (await this.getMarketInfo()).lpSupplyWithDecimals,
           Date.now() / 1000,
+          oiState && oiState.enabled ? oiState.model : undefined,
+          pairedSymbol.openingSize,
         )
       }
       catch (e) {

package/src/interfaces/slp.ts

@@ -87,6 +87,20 @@ export interface ISLPSymbolConfig {
   instant_exit_fee_config: ISLPPositionInstantExitFeeConfig
 }
 
+export interface ISLPOiFundingModel {
+  id: string
+  multiplier: number
+  exponent: number
+  max: number
+}
+
+export interface ISLPOiFundingState {
+  id: string
+  enabled: boolean
+  last_update: number
+  model: ISLPOiFundingModel
+}
+
 // Sudo SDK specific data structures
 export interface ISudoMarket {
   lpSupply: bigint