@zofai/zo-sdk 0.1.93 → 0.1.95

package/src/implementations/USDZDataAPI.ts

@@ -15,6 +15,7 @@ import type {
   IBaseHistoryResponse,
   IBaseOrderType,
   IBaseStaked,
+  ISwapFeeBreakdown,
   IUSDZCredential,
   IUSDZDataAPI,
   IUSDZFundingFeeModel,
@@ -37,6 +38,20 @@ import type {
 } from '../interfaces'
 import { joinSymbol, parseSymbolKey, parseValue, suiSymbolToSymbol } from '../utils'
 
+interface SwapImpactConfig {
+  id: string
+  enabled: boolean
+  impactMultiplier: number
+  maxImpactRate: number
+}
+
+interface EmaVolatilityFeeConfig {
+  id: string
+  enabled: boolean
+  multiplier: number
+  maxFeeRate: number
+}
+
 export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
   constructor(
     network: Network,
@@ -226,7 +241,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
         (await this.getOraclePrice(tokenId)).getPriceUnchecked().getPriceAsNumberUnchecked(),
         marketInfo.lpSupplyWithDecimals,
         Date.now() / 1000,
-        oiState && oiState.enabled ? oiState.model : undefined,
+        oiState && oiState.enabled ? oiState : undefined,
         pairedSymbol.openingSize,
       )
 
@@ -385,6 +400,164 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     }
   }
 
+  public async calculateSwapFeeBreakdown(fromToken: string, toToken: string, fromAmount: number): Promise<ISwapFeeBreakdown> {
+    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
+      ? USDZDataAPI.#computeSwapImpactFeeValue(swapValue, totalVaultsValue, swapImpactCfg.impactMultiplier, swapImpactCfg.maxImpactRate)
+      : 0
+
+    const emaCfg = await this.#getEmaVolatilityFeeConfig()
+    const emaVolatilityFeeValue = emaCfg?.enabled
+      ? USDZDataAPI.#computeEmaVolatilityFeeValue(
+          swapValue,
+          USDZDataAPI.#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> {
+    const vaultKeys = Object.keys(this.consts.zoCore.vaults)
+    const vaultValues = await Promise.all(vaultKeys.map(async (vault) => {
+      const vaultInfo = await this.getVaultInfo(vault)
+      const reservingFeeDelta = USDZDataAPI.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> {
+    const raw = await this.#getMarketDynamicFieldObjectByKeySuffix(this.consts.zoCore.market, 'SwapImpactConfigKey')
+    if (!raw)
+      return null
+    return USDZDataAPI.#parseSwapImpactConfig(raw)
+  }
+
+  async #getEmaVolatilityFeeConfig(): Promise<EmaVolatilityFeeConfig | null> {
+    const raw = await this.#getMarketDynamicFieldObjectByKeySuffix(this.consts.zoCore.market, 'EmaVolatilityFeeConfigKey')
+    if (!raw)
+      return null
+    return USDZDataAPI.#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 = USDZDataAPI.#emaDivergenceRate(sourceFeed)
+    const destDiv = USDZDataAPI.#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 getPositionCapInfoList(owner: string): Promise<IUSDZPositionCapInfo[]> {
     const positionCapInfoList: IUSDZPositionCapInfo[] = []
     let cursor: string | undefined | null
@@ -638,7 +811,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     const longSize = longSymbol.openingSize
     const shortSize = shortSymbol.openingSize
 
-    const deltaRate = USDZDataAPI.calcOiFundingFeeRate(oiState.model, longSize, shortSize, elapsed)
+    const deltaRate = USDZDataAPI.calcOiFundingFeeRate(oiState.model, longSize, shortSize, elapsed, oiState.maxOiLong, oiState.maxOiShort)
     return long ? deltaRate : -deltaRate
   }
 
@@ -725,12 +898,42 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     return pnlPerRate >= 0 ? -secondsRate : secondsRate
   }
 
-  private static calcOiFundingFeeRate(model: IUSDZOiFundingModel, longSize: number, shortSize: number, elapsed: number): number {
-    const imbalance = Math.abs(longSize - shortSize)
-    const total = longSize + shortSize > 0 ? longSize + shortSize : 1
-    const dailyRate = Math.min((model.multiplier * (imbalance ** model.exponent)) / total, model.max)
-    const secondsRate = dailyRate * elapsed / SECONDS_PER_EIGHT_HOUR
-    return longSize >= shortSize ? secondsRate : -secondsRate
+  /**
+   * 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: IUSDZOiFundingModel,
+    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
+    }
+
+    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 calcAccFundingFeeRate(
@@ -739,16 +942,16 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     price: number,
     lpSupplyAmount: number,
     timestamp: number,
-    oiModel?: IUSDZOiFundingModel,
+    oiState?: IUSDZOiFundingState,
     pairedOpeningSize?: number,
   ): number {
     if (symbol.lastUpdate > 0) {
       const elapsed = timestamp - symbol.lastUpdate
       if (elapsed > 0) {
-        if (oiModel && typeof pairedOpeningSize === 'number') {
+        if (oiState?.enabled && oiState.model && typeof pairedOpeningSize === 'number') {
           const longSize = symbol.long ? symbol.openingSize : pairedOpeningSize
           const shortSize = symbol.long ? pairedOpeningSize : symbol.openingSize
-          const deltaRate = USDZDataAPI.calcOiFundingFeeRate(oiModel, longSize, shortSize, elapsed)
+          const deltaRate = USDZDataAPI.calcOiFundingFeeRate(oiState.model, longSize, shortSize, elapsed, oiState.maxOiLong, oiState.maxOiShort)
           return symbol.accFundingRate + deltaRate
         }
         const deltaSize = USDZDataAPI.calcDeltaSize(symbol, price)
@@ -765,7 +968,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     price: number,
     lpSupplyAmount: number,
     timestamp: number,
-    oiModel?: IUSDZOiFundingModel,
+    oiState?: IUSDZOiFundingState,
     pairedOpeningSize?: number,
   ): number {
     const accFundingRate = USDZDataAPI.calcAccFundingFeeRate(
@@ -774,7 +977,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
       price,
       lpSupplyAmount,
       timestamp,
-      oiModel,
+      oiState,
       pairedOpeningSize,
     )
     return symbol.unrealisedFundingFeeValue + (accFundingRate - symbol.accFundingRate) * symbol.openingSize
@@ -980,7 +1183,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
       (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,
     )
 
@@ -994,7 +1197,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     price: number,
     lpSupplyAmount: number,
     timestamp: number,
-    oiModel?: IUSDZOiFundingModel,
+    oiState?: IUSDZOiFundingState,
     pairedOpeningSize?: number,
   ): number {
     const accFundingRate = USDZDataAPI.calcAccFundingFeeRate(
@@ -1003,7 +1206,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
       price,
       lpSupplyAmount,
       timestamp,
-      oiModel,
+      oiState,
       pairedOpeningSize,
     )
     return position.fundingFeeValue + (accFundingRate - position.lastFundingRate) * position.positionSize
@@ -1045,6 +1248,8 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
         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,
     }
   }
 

package/src/implementations/ZLPAPI.ts

@@ -624,6 +624,49 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     return tx
   }
 
+  /**
+   * Swaps tokens and returns the output coin to the user (PTB).
+   * Same as swap() but returns the output coin as TransactionObjectArgument for use in composed transactions.
+   * Pass optional tx to compose with other move calls; otherwise a new transaction is created.
+   */
+  public async swapV2Ptb(
+    fromToken: string,
+    toToken: string,
+    fromAmount: bigint,
+    fromCoinObjects: string[],
+    minAmountOut?: number,
+    tx?: Transaction,
+  ): Promise<TransactionObjectArgument> {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    tx = await this.initOracleTxb(Object.keys(this.consts.zoCore.vaults), tx)
+    const fromCoinObject = this.processCoins(tx, fromToken, fromCoinObjects)
+    const [fromDepositObject] = tx.splitCoins(fromCoinObject, [
+      tx.pure.u64(fromAmount),
+    ])
+    const vaultsValuation = this.dataAPI.valuateVaults(tx)
+
+    const [outputCoin] = tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::swap_v2_ptb`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[fromToken].module,
+        this.consts.coins[toToken].module,
+      ],
+      arguments: [
+        tx.object(this.consts.zoCore.market),
+        tx.object(this.consts.zoCore.rebaseFeeModel),
+        fromDepositObject,
+        tx.pure.u64(minAmountOut || 0),
+        vaultsValuation,
+        tx.object(this.consts.pythFeeder.feeder[fromToken]),
+        tx.object(this.consts.pythFeeder.feeder[toToken]),
+      ],
+    })
+    return outputCoin
+  }
+
   /**
    * Opens a new position in ZLP
    */