@zofai/zo-sdk 0.1.92 → 0.1.94

package/src/implementations/SLPDataAPI.ts

@@ -37,6 +37,7 @@ import type {
   ISLPSymbolConfig,
   ISLPSymbolInfo,
   ISLPVaultInfo,
+  ISwapFeeBreakdown,
 } from '../interfaces'
 import { joinSymbol, parseSymbolKey, parseValue, suiSymbolToSymbol } from '../utils'
 
@@ -49,6 +50,20 @@ let aprResponse: GetCumulativeAprResponse = {}
 
 const SECONDS_PER_EIGHT_HOUR = 8 * 60 * 60 // 28800 seconds
 
+interface SwapImpactConfig {
+  id: string
+  enabled: boolean
+  impactMultiplier: number
+  maxImpactRate: number
+}
+
+interface EmaVolatilityFeeConfig {
+  id: string
+  enabled: boolean
+  multiplier: number
+  maxFeeRate: number
+}
+
 export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
   constructor(
     network: Network,
@@ -76,7 +91,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     price: number,
     lpSupplyAmount: number,
     timestamp: number,
-    oiModel?: ISLPOiFundingModel,
+    oiState?: ISLPOiFundingState,
     pairedOpeningSize?: number,
   ): number {
     const accFundingRate = SLPDataAPI.calcAccFundingFeeRate(
@@ -86,7 +101,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
       lpSupplyAmount,
       timestamp,
       symbol.long,
-      oiModel,
+      oiState,
       pairedOpeningSize,
     )
     return symbol.unrealisedFundingFeeValue + (accFundingRate - symbol.accFundingRate) * symbol.openingSize
@@ -203,15 +218,18 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     let slpPrice = 0
     let value = 0
 
-    const vaultPromises = Object.keys(this.consts.sudoCore.vaults).map(async (vault) => {
+    const vaultKeys = Object.keys(this.consts.sudoCore.vaults)
+    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 { decimals } = this.consts.coins[vault]
       const vaultValue = totalVaultAmount * oraclePrice / (10 ** decimals)
-      return vaultValue
-    })
+      return { vault, oraclePrice, vaultValue }
+    }))
+    const vaultPrices = Object.fromEntries(vaultData.map(d => [d.vault, d.oraclePrice]))
+    const vaultValues = vaultData.map(d => d.vaultValue)
 
     const symbolPromises = Object.keys(this.consts.sudoCore.symbols).map(async (symbol) => {
       const [direction, tokenId] = parseSymbolKey(symbol)
@@ -227,14 +245,14 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
         price,
         marketInfo.lpSupplyWithDecimals,
         Date.now() / 1000,
-        oiState && oiState.enabled ? oiState.model : undefined,
+        oiState && oiState.enabled ? oiState : undefined,
         pairedInfo.openingSize,
       )
       const symbolValue = fundingFeeDelta + deltaSize
       return symbolValue
     })
 
-    const [vaultValues, symbolValues] = await Promise.all([Promise.all(vaultPromises), Promise.all(symbolPromises)])
+    const symbolValues = await Promise.all(symbolPromises)
 
     const totalVaultValue = vaultValues.reduce((acc: number, curr: number) => acc + curr, 0)
     const totalSymbolValue = symbolValues.reduce((acc: number, curr: number) => acc + curr, 0)
@@ -247,6 +265,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
       price: slpPrice,
       supply: marketInfo.lpSupplyWithDecimals,
       apr: Number(marketInfo.apr),
+      vaultPrices,
     }
   }
 
@@ -332,11 +351,21 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     const value = await this.simValuateVaults(this.consts.sudoCore.adminCap)
     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 vaultPrices = Object.fromEntries(vaultPricesEntries)
+
     return {
       marketCap: value,
       price: slpPrice,
       supply: marketInfo.lpSupplyWithDecimals,
       apr: Number(marketInfo.apr),
+      vaultPrices,
     }
   }
 
@@ -471,6 +500,177 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     }
   }
 
+  public async calculateSwapFeeBreakdown(fromToken: string, toToken: string, fromAmount: number): Promise<ISwapFeeBreakdown> {
+    if (!this.consts.sudoCore) {
+      throw new Error('Sudo Core configuration not found. Make sure you are using LPToken.SLP')
+    }
+
+    const timestamp = Date.now() / 1000
+
+    const fromDecimals = this.consts.coins[fromToken]?.decimals
+    const toDecimals = this.consts.coins[toToken]?.decimals
+    if (fromDecimals === undefined || toDecimals === undefined) {
+      throw new Error(`Unknown token decimals for swap: ${fromToken} -> ${toToken}`)
+    }
+
+    const fromFeed = await this.getOraclePrice(fromToken)
+    const toFeed = await this.getOraclePrice(toToken)
+    const fromPrice = fromFeed.getPriceUnchecked().getPriceAsNumberUnchecked()
+    const toPrice = toFeed.getPriceUnchecked().getPriceAsNumberUnchecked()
+
+    const swapValue = (fromAmount * fromPrice) / (10 ** fromDecimals)
+    const totalVaultsValue = await this.#getTotalVaultsValueUsd(timestamp)
+
+    const rebaseFeeInRate = await this.rebaseFeeRate(fromToken, true, fromAmount)
+    const rebaseFeeInValue = swapValue * rebaseFeeInRate
+
+    const estimatedToAmount = toPrice !== 0
+      ? (swapValue * (10 ** toDecimals)) / toPrice
+      : 0
+    const rebaseFeeOutRate = await this.rebaseFeeRate(toToken, false, estimatedToAmount)
+    const rebaseFeeOutValue = swapValue * rebaseFeeOutRate
+
+    const swapImpactCfg = await this.#getSwapImpactConfig()
+    const swapImpactFeeValue = swapImpactCfg?.enabled
+      ? SLPDataAPI.#computeSwapImpactFeeValue(swapValue, totalVaultsValue, swapImpactCfg.impactMultiplier, swapImpactCfg.maxImpactRate)
+      : 0
+
+    const emaCfg = await this.#getEmaVolatilityFeeConfig()
+    const emaVolatilityFeeValue = emaCfg?.enabled
+      ? SLPDataAPI.#computeEmaVolatilityFeeValue(
+        swapValue,
+        SLPDataAPI.#maxEmaDivergenceRate(fromFeed, toFeed),
+        emaCfg.multiplier,
+        emaCfg.maxFeeRate,
+      )
+      : 0
+
+    const totalFeeValue = rebaseFeeInValue + rebaseFeeOutValue + swapImpactFeeValue + emaVolatilityFeeValue
+    const totalFeeRate = swapValue !== 0 ? totalFeeValue / swapValue : 0
+
+    return {
+      swapValue,
+      totalVaultsValue,
+      rebaseFeeInRate,
+      rebaseFeeOutRate,
+      rebaseFeeInValue,
+      rebaseFeeOutValue,
+      swapImpactFeeValue,
+      emaVolatilityFeeValue,
+      totalFeeValue,
+      totalFeeRate,
+    }
+  }
+
+  async #getTotalVaultsValueUsd(timestamp: number): Promise<number> {
+    if (!this.consts.sudoCore) {
+      return 0
+    }
+    const vaultKeys = Object.keys(this.consts.sudoCore.vaults)
+    const vaultValues = await Promise.all(vaultKeys.map(async (vault) => {
+      const vaultInfo = await this.getVaultInfo(vault)
+      const reservingFeeDelta = SLPDataAPI.calculateVaultReservingFee(vaultInfo, vaultInfo.reservingFeeModel, timestamp)
+      const totalVaultAmount = reservingFeeDelta + vaultInfo.liquidity + vaultInfo.reservedAmount
+      const oraclePrice = (await this.getOraclePrice(vault)).getPriceUnchecked().getPriceAsNumberUnchecked()
+      const { decimals } = this.consts.coins[vault]
+      return totalVaultAmount * oraclePrice / (10 ** decimals)
+    }))
+    return vaultValues.reduce((acc, curr) => acc + curr, 0)
+  }
+
+  async #getSwapImpactConfig(): Promise<SwapImpactConfig | null> {
+    if (!this.consts.sudoCore) {
+      return null
+    }
+    const raw = await this.#getMarketDynamicFieldObjectByKeySuffix(this.consts.sudoCore.market, 'SwapImpactConfigKey')
+    if (!raw)
+      return null
+    return SLPDataAPI.#parseSwapImpactConfig(raw)
+  }
+
+  async #getEmaVolatilityFeeConfig(): Promise<EmaVolatilityFeeConfig | null> {
+    if (!this.consts.sudoCore) {
+      return null
+    }
+    const raw = await this.#getMarketDynamicFieldObjectByKeySuffix(this.consts.sudoCore.market, 'EmaVolatilityFeeConfigKey')
+    if (!raw)
+      return null
+    return SLPDataAPI.#parseEmaVolatilityFeeConfig(raw)
+  }
+
+  async #getMarketDynamicFieldObjectByKeySuffix(parentId: string, keyTypeSuffix: string): Promise<any | null> {
+    let cursor: string | null | undefined
+    let hasNextPage = true
+
+    while (hasNextPage) {
+      const page = await this.provider.getDynamicFields({ parentId, cursor })
+      for (const field of page.data) {
+        const type = (field.name as any)?.type
+        if (typeof type === 'string' && type.endsWith(`::${keyTypeSuffix}`)) {
+          return await this.provider.getDynamicFieldObject({
+            parentId,
+            name: field.name as any,
+          })
+        }
+      }
+      hasNextPage = page.hasNextPage
+      cursor = page.nextCursor
+    }
+    return null
+  }
+
+  static #parseSwapImpactConfig(raw: any): SwapImpactConfig {
+    const { fields } = raw.data.content
+    return {
+      id: fields.id.id,
+      enabled: fields.enabled,
+      impactMultiplier: parseValue(fields.impact_multiplier),
+      maxImpactRate: parseValue(fields.max_impact_rate),
+    }
+  }
+
+  static #parseEmaVolatilityFeeConfig(raw: any): EmaVolatilityFeeConfig {
+    const { fields } = raw.data.content
+    return {
+      id: fields.id.id,
+      enabled: fields.enabled,
+      multiplier: parseValue(fields.multiplier),
+      maxFeeRate: parseValue(fields.max_fee_rate),
+    }
+  }
+
+  static #computeSwapImpactFeeValue(swapValue: number, totalVaultsValue: number, impactMultiplier: number, maxImpactRate: number): number {
+    if (swapValue <= 0 || totalVaultsValue <= 0)
+      return 0
+    const utilization = swapValue / totalVaultsValue
+    const rawImpactRate = impactMultiplier * utilization
+    const impactRate = Math.min(rawImpactRate, maxImpactRate)
+    return swapValue * impactRate
+  }
+
+  static #computeEmaVolatilityFeeValue(swapValue: number, maxDiv: number, multiplier: number, maxFeeRate: number): number {
+    if (swapValue <= 0 || maxDiv <= 0)
+      return 0
+    const rawFeeRate = multiplier * maxDiv
+    const feeRate = Math.min(rawFeeRate, maxFeeRate)
+    return swapValue * feeRate
+  }
+
+  static #maxEmaDivergenceRate(sourceFeed: any, destFeed: any): number {
+    const sourceDiv = SLPDataAPI.#emaDivergenceRate(sourceFeed)
+    const destDiv = SLPDataAPI.#emaDivergenceRate(destFeed)
+    return Math.max(sourceDiv, destDiv)
+  }
+
+  static #emaDivergenceRate(priceFeed: any): number {
+    const price = priceFeed.getPriceUnchecked().getPriceAsNumberUnchecked()
+    const ema = priceFeed.getEmaPriceUnchecked().getPriceAsNumberUnchecked()
+    const denom = Math.abs(price)
+    if (denom === 0)
+      return 0
+    return Math.abs(price - ema) / denom
+  }
+
   public async getPositionInfoList(
     positionCapInfoList: ISLPPositionCapInfo[],
     owner: string,
@@ -703,6 +903,8 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
         longSymbol.openingSize,
         shortSymbol.openingSize,
         elapsed,
+        oiState.maxOiLong,
+        oiState.maxOiShort,
       )
       return long ? deltaRate : -deltaRate
     }
@@ -1082,7 +1284,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     price: number,
     lpSupplyAmount: number,
     timestamp: number,
-    oiModel?: ISLPOiFundingModel,
+    oiState?: ISLPOiFundingState,
     pairedOpeningSize?: number,
   ): number {
     const accFundingRate = this.calcAccFundingFeeRate(
@@ -1092,7 +1294,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
       lpSupplyAmount,
       timestamp,
       position.long,
-      oiModel,
+      oiState,
       pairedOpeningSize,
     )
     return position.fundingFeeValue + (accFundingRate - position.lastFundingRate) * position.positionSize
@@ -1105,17 +1307,17 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     lpSupplyAmount: number,
     timestamp: number,
     isLong: boolean,
-    oiModel?: ISLPOiFundingModel,
+    oiState?: ISLPOiFundingState,
     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') {
+        // Prefer OI-based delta when OI state and paired side are available
+        if (oiState?.enabled && oiState.model && typeof pairedOpeningSize === 'number') {
           const longSize = isLong ? symbol.openingSize : pairedOpeningSize
           const shortSize = isLong ? pairedOpeningSize : symbol.openingSize
-          const deltaRate = SLPDataAPI.calcOiFundingFeeRate(oiModel, longSize, shortSize, elapsed)
+          const deltaRate = SLPDataAPI.calcOiFundingFeeRate(oiState.model, longSize, shortSize, elapsed, oiState.maxOiLong, oiState.maxOiShort)
           const appliedRate = isLong ? deltaRate : -deltaRate
           return symbol.accFundingRate + appliedRate
         }
@@ -1140,16 +1342,42 @@ 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
+  /**
+   * OI funding rate matching Move compute_oi_funding_rate_capped.
+   * When both maxOiLong and maxOiShort are set and > 0, uses normalized skew (oi/cap);
+   * otherwise falls back to (long - short) / total.
+   */
+  private static calcOiFundingFeeRate(
+    model: ISLPOiFundingModel,
+    oiLong: number,
+    oiShort: number,
+    elapsed: number,
+    maxOiLong?: number,
+    maxOiShort?: number,
+  ): number {
+    let skew: number
+    if (maxOiLong && maxOiShort && maxOiLong > 0 && maxOiShort > 0) {
+      const normLong = Math.min(oiLong / maxOiLong, 1)
+      const normShort = Math.min(oiShort / maxOiShort, 1)
+      skew = normLong - normShort
+    }
+    else {
+      const total = oiLong + oiShort
+      if (total === 0)
+        return 0
+      skew = (oiLong - oiShort) / total
+    }
 
-    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
+    if (skew === 0)
+      return 0
+
+    const skewIsPositive = skew > 0
+    const skewAbs = Math.abs(skew)
+    const exponentInt = Math.floor(model.exponent)
+    const skewPow = skewAbs ** exponentInt
+    const dailyRate = Math.min(model.multiplier * skewPow, model.max)
+    const secondsRate = (dailyRate * elapsed) / SECONDS_PER_EIGHT_HOUR
+    return skewIsPositive ? secondsRate : -secondsRate
   }
 
   private static calculatePositionReserveFee(position: ISLPPositionInfo, vault: ISLPVaultInfo, model: ISLPReservingFeeModel, timestamp: number): number {
@@ -1482,6 +1710,8 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
         exponent: parseValue(content.model.fields.exponent),
         max: parseValue(content.model.fields.max),
       },
+      maxOiLong: content.max_oi_long !== null && content.max_oi_long !== undefined ? parseValue(content.max_oi_long) : undefined,
+      maxOiShort: content.max_oi_short !== null && content.max_oi_short !== undefined ? parseValue(content.max_oi_short) : undefined,
     }
   }
 
@@ -1636,7 +1866,7 @@ 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,
+          oiState && oiState.enabled ? oiState : undefined,
           pairedSymbol.openingSize,
         )
       }