@zofai/zo-sdk 0.1.92

package/src/implementations/SLPDataAPI.ts

@@ -0,0 +1,1839 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable @stylistic/indent-binary-ops */
+/* eslint-disable @stylistic/indent */
+/**
+ * SLP DataAPI implementation
+ * Implements SLP-specific data access methods for Sudo SDK
+ */
+
+import type { DynamicFieldInfo, SuiClient } from '@mysten/sui/client'
+import { Transaction } from '@mysten/sui/transactions'
+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 type {
+  IBaseHistoryResponse,
+  IBaseOrderType,
+  ISLPCredential,
+  ISLPDataAPI,
+  ISLPFundingFeeModel,
+  ISLPMarketInfo,
+  ISLPMarketValuationInfo,
+  ISLPOiFundingModel,
+  ISLPOiFundingState,
+  ISLPOrderCapInfo,
+  ISLPOrderInfo,
+  ISLPPositionCapInfo,
+  ISLPPositionConfig,
+  ISLPPositionInfo,
+  ISLPPriceImpactConfig,
+  ISLPRebaseFeeModel,
+  ISLPReservingFeeModel,
+  ISLPStaked,
+  ISLPStakePool,
+  ISLPSymbolConfig,
+  ISLPSymbolInfo,
+  ISLPVaultInfo,
+} from '../interfaces'
+import { joinSymbol, parseSymbolKey, parseValue, suiSymbolToSymbol } from '../utils'
+
+export interface GetCumulativeAprResponse {
+  generatedAt?: string
+  apr?: string
+}
+
+let aprResponse: GetCumulativeAprResponse = {}
+
+const SECONDS_PER_EIGHT_HOUR = 8 * 60 * 60 // 28800 seconds
+
+export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
+  constructor(
+    network: Network,
+    provider: SuiClient,
+    apiEndpoint: string,
+    connectionURL: string,
+  ) {
+    super(network, provider, apiEndpoint, connectionURL, LPToken.SLP)
+  }
+
+  private static calculateVaultReservingFee(
+    vaultInfo: ISLPVaultInfo,
+    reservingFeeModel: { multiplier: number },
+    currentTime: number,
+  ): number {
+    const timeDelta = currentTime - vaultInfo.lastUpdate
+    const periods = Math.floor(timeDelta / SECONDS_PER_EIGHT_HOUR)
+    return vaultInfo.unrealisedReservingFeeAmount
+      + (vaultInfo.reservedAmount * reservingFeeModel.multiplier * periods) / 1e18
+  }
+
+  private static calculateSymbolFundingFee(
+    symbol: ISLPSymbolInfo,
+    model: ISLPFundingFeeModel,
+    price: number,
+    lpSupplyAmount: number,
+    timestamp: number,
+    oiModel?: ISLPOiFundingModel,
+    pairedOpeningSize?: number,
+  ): number {
+    const accFundingRate = SLPDataAPI.calcAccFundingFeeRate(
+      symbol,
+      model,
+      price,
+      lpSupplyAmount,
+      timestamp,
+      symbol.long,
+      oiModel,
+      pairedOpeningSize,
+    )
+    return symbol.unrealisedFundingFeeValue + (accFundingRate - symbol.accFundingRate) * symbol.openingSize
+  }
+
+  public async getRebaseFeeModel(): Promise<ISLPRebaseFeeModel> {
+    this.validateCache()
+    if (this.rebaseFeeModelCache) {
+      return this.rebaseFeeModelCache
+    }
+    const rawData = await this.provider.getObject({
+      id: this.consts.sudoCore.rebaseFeeModel,
+      options: {
+        showContent: true,
+      },
+    })
+    const model = SLPDataAPI.parseRebaseFeeModel(rawData)
+    const exponent = await SLPDataAPI.getRebaseFeeExponent(
+      this.provider,
+      this.consts.sudoCore.rebaseFeeModel,
+      this.consts.sudoCore.upgradedPackage,
+    )
+    return { ...model, exponent }
+  }
+
+  /**
+   * Creates vaults valuation for SLP using Sudo SDK approach
+   */
+  public valuateVaults(tx: Transaction) {
+    if (!this.consts.sudoCore) {
+      throw new Error('Sudo Core configuration not found. Make sure you are using LPToken.SLP')
+    }
+
+    const vaultsValuation = tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::create_vaults_valuation`,
+      typeArguments: [`${this.consts.sudoCore.package}::slp::SLP`],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+      ],
+    })
+
+    for (const key of Object.keys(this.consts.sudoCore.vaults)) {
+      const vault = this.consts.sudoCore.vaults[key]
+
+      tx.moveCall({
+        target: `${this.consts.sudoCore.upgradedPackage}::market::valuate_vault_v1_1`,
+        typeArguments: [
+          `${this.consts.sudoCore.package}::slp::SLP`,
+          this.consts.coins[key].module,
+        ],
+        arguments: [
+          tx.object(this.consts.sudoCore.market),
+          tx.object(vault.reservingFeeModel),
+          tx.object(this.consts.pythFeeder.feeder[key]),
+          vaultsValuation,
+        ],
+      })
+    }
+    return vaultsValuation
+  }
+
+  /**
+   * Creates symbols valuation for SLP using Sudo SDK approach
+   */
+  public valuateSymbols(tx: Transaction) {
+    if (!this.consts.sudoCore) {
+      throw new Error('Sudo Core configuration not found. Make sure you are using LPToken.SLP')
+    }
+
+    const symbolsValuation = tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::create_symbols_valuation`,
+      typeArguments: [`${this.consts.sudoCore.package}::slp::SLP`],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+      ],
+    })
+    for (const key of Object.keys(this.consts.sudoCore.symbols)) {
+      const [direction, token] = parseSymbolKey(key)
+      const symbol = this.consts.sudoCore.symbols[key]
+      tx.moveCall({
+        target: `${this.consts.sudoCore.upgradedPackage}::market::valuate_symbol_v1_1`,
+        typeArguments: [
+          `${this.consts.sudoCore.package}::slp::SLP`,
+          this.consts.coins[token].module,
+          `${this.consts.sudoCore.package}::market::${direction.toUpperCase()}`,
+        ],
+        arguments: [
+          tx.object(this.consts.sudoCore.market),
+          tx.object(symbol.fundingFeeModel),
+          tx.object(this.consts.pythFeeder.feeder[token]),
+          symbolsValuation,
+        ],
+      })
+    }
+    return symbolsValuation
+  }
+
+  /**
+   * Creates both vaults and symbols valuation for SLP
+   */
+  public valuate(tx: Transaction) {
+    const vaultsValuation = this.valuateVaults(tx)
+    const symbolsValuation = this.valuateSymbols(tx)
+    return { vaultsValuation, symbolsValuation }
+  }
+
+  /**
+   * Valuates the SLP market using Sudo SDK's approach
+   */
+  public async valuateMarket(): Promise<ISLPMarketValuationInfo> {
+    const marketInfo = await this.getMarketInfo()
+    let slpPrice = 0
+    let value = 0
+
+    const vaultPromises = Object.keys(this.consts.sudoCore.vaults).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
+    })
+
+    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 deltaSize = SLPDataAPI.calcDeltaSize(symbolInfo, price, direction === 'long')
+
+      const oiState = await this.getSymbolOiFundingState(tokenId)
+      const pairedInfo = await this.getSymbolInfo(tokenId, direction !== 'long')
+      const fundingFeeDelta = SLPDataAPI.calculateSymbolFundingFee(
+        symbolInfo,
+        symbolInfo.fundingFeeModel,
+        price,
+        marketInfo.lpSupplyWithDecimals,
+        Date.now() / 1000,
+        oiState && oiState.enabled ? oiState.model : undefined,
+        pairedInfo.openingSize,
+      )
+      const symbolValue = fundingFeeDelta + deltaSize
+      return symbolValue
+    })
+
+    const [vaultValues, symbolValues] = await Promise.all([Promise.all(vaultPromises), 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)
+
+    value = totalVaultValue + totalSymbolValue
+
+    slpPrice = value / marketInfo.lpSupplyWithDecimals
+    return {
+      marketCap: value,
+      price: slpPrice,
+      supply: marketInfo.lpSupplyWithDecimals,
+      apr: Number(marketInfo.apr),
+    }
+  }
+
+  /**
+   * Valuates market using simulation (Sudo SDK specific)
+   */
+  public async simValuate(sender: string): Promise<number> {
+    const tx = await this.initOracleTxb(
+      Object.keys(this.consts.pythFeeder.feeder),
+    )
+    this.valuate(tx)
+    const res = await this.provider.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender,
+    })
+
+    const symbolsValuationOffset
+      = Object.keys(this.consts.sudoCore.symbols).length + 1
+
+    const vaultsValuation = VaultsValuation.parse(
+      new Uint8Array(
+        (
+          (res.results as any)[
+            (res.results?.length || 0) - symbolsValuationOffset - 1
+          ].mutableReferenceOutputs as any
+        )[1][1],
+      ),
+    )
+
+    const symbolsValuation = SymbolsValuation.parse(
+      new Uint8Array(
+        (
+          (res.results as any)[(res.results?.length || 0) - 1]
+            .mutableReferenceOutputs as any
+        )[1][1],
+      ),
+    )
+
+    const result
+      = Number(
+        BigInt(vaultsValuation.value)
+        + BigInt(symbolsValuation.value.value)
+        * BigInt(symbolsValuation.value.is_positive ? 1 : -1),
+      ) / 1e18
+    return result
+  }
+
+  /**
+   * Valuates only vaults (Sudo SDK specific)
+   */
+  public async simValuateVaults(sender: string): Promise<number> {
+    const tx = await this.initOracleTxb(
+      Object.keys(this.consts.sudoCore.vaults),
+    )
+    this.valuateVaults(tx)
+
+    const res = await this.provider.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender,
+    })
+    const vaultsValuation = VaultsValuation.parse(
+      new Uint8Array(
+        (
+          (res.results as any)[(res.results?.length || 0) - 1]
+            .mutableReferenceOutputs as any
+        )[1][1],
+      ),
+    )
+
+    const result = Number(BigInt(vaultsValuation.value)) / 1e18
+    return result
+  }
+
+  /**
+   * Valuates market with vaults only
+   */
+  public async valuateMarketWithVaultsOnly(): Promise<ISLPMarketValuationInfo> {
+    if (!this.consts.sudoCore) {
+      throw new Error('Sudo Core configuration not found')
+    }
+
+    const marketInfo = await this.getMarketInfo()
+    const value = await this.simValuateVaults(this.consts.sudoCore.adminCap)
+    const slpPrice = value / marketInfo.lpSupplyWithDecimals
+
+    return {
+      marketCap: value,
+      price: slpPrice,
+      supply: marketInfo.lpSupplyWithDecimals,
+      apr: Number(marketInfo.apr),
+    }
+  }
+
+  /**
+   * Gets SLP market information
+   */
+  public async getMarketInfo(): Promise<ISLPMarketInfo> {
+    this.validateCache()
+    if (this.marketInfoCache) {
+      return this.marketInfoCache
+    }
+
+    const rawData = await this.provider.getObject({
+      id: this.consts.sudoCore.market,
+      options: {
+        showContent: true,
+      },
+    })
+    const apr = await this.getCumulativeApr()
+    return {
+      ...SLPDataAPI.parseMarketInfo(rawData),
+      apr,
+    }
+  }
+
+  /**
+   * Gets SLP vault information
+   */
+  public async getVaultInfo(vaultToken: string): Promise<ISLPVaultInfo> {
+    this.validateCache()
+    if (this.vaultInfoCache[vaultToken]) {
+      return this.vaultInfoCache[vaultToken]
+    }
+
+    const rawData = await this.provider.getDynamicFieldObject({
+      parentId: this.consts.sudoCore.vaultsParent,
+      name: {
+        type: `${this.consts.sudoCore.package}::market::VaultName<${this.consts.coins[vaultToken].module}>`,
+        value: { dummy_field: false },
+      },
+    })
+    return await this.parseVaultInfo(rawData)
+  }
+
+  /**
+   * Gets SLP symbol information
+   */
+  public async getSymbolInfo(indexToken: string, long: boolean): Promise<ISLPSymbolInfo> {
+    this.validateCache()
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+    if (this.symbolInfoCache[symbol]) {
+      return this.symbolInfoCache[symbol]
+    }
+
+    const rawData = await this.provider.getDynamicFieldObject({
+      parentId: this.consts.sudoCore.symbolsParent,
+      name: {
+        type: `${this.consts.sudoCore.package}::market::SymbolName<${this.consts.coins[indexToken].module
+          }, ${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'
+          }>`,
+        value: { dummy_field: false },
+      },
+    })
+
+    return await this.parseSymbolInfo(rawData, long)
+  }
+
+  /**
+   * Gets SLP symbol configuration
+   */
+  public async getSymbolConfig(indexToken: string, long: boolean): Promise<ISLPSymbolConfig | null> {
+    this.validateCache()
+    try {
+      const rawData = await this.provider.getDynamicFieldObject({
+        parentId: this.consts.sudoCore.market,
+        name: {
+          type: `${this.consts.sudoCore.package}::market::SymbolName<${this.consts.coins[indexToken].module}, ${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}>`,
+          value: { dummy_field: false },
+        },
+      })
+      return SLPDataAPI.parseSymbolConfig(rawData)
+    }
+    catch {
+      // If the dynamic field doesn't exist, return null
+      console.error('Symbol Config Not Found')
+      return null
+    }
+  }
+
+  /**
+   * Gets price impact configuration for a symbol.
+   * Price impact config applies to both long and short directions for the same index token.
+   */
+  public async getPriceImpactConfig(indexToken: string): Promise<ISLPPriceImpactConfig | null> {
+    this.validateCache()
+    try {
+      const rawData = await this.provider.getDynamicFieldObject({
+        parentId: this.consts.sudoCore.market,
+        name: {
+          type: `0x699769d16326684d94039c23d8568fe8f438854bc69e681328647d6682425a7b::price_impact::PriceImpactConfigKey<${this.consts.coins[indexToken].module}>`,
+          value: { dummy_field: false },
+        },
+      })
+      return SLPDataAPI.parsePriceImpactConfig(rawData)
+    }
+    catch (e: any) {
+      // If the dynamic field doesn't exist, return null (price impact not configured for this symbol)
+      console.error('Error Fetching Price Impact Config:', e)
+      return null
+    }
+  }
+
+  /**
+   * 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: `0x719955743d23874522250584b34d19462b41eed2816334adb5744308217f378a::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,
+    batchSize = 10,
+  ): Promise<ISLPPositionInfo[]> {
+    const positionInfoList: ISLPPositionInfo[] = []
+
+    // Process in batches of 10
+    for (let i = 0; i < positionCapInfoList.length; i += batchSize) {
+      const batch = positionCapInfoList.slice(i, i + batchSize)
+
+      await Promise.all(batch.map(async (positionCapInfo) => {
+        try {
+          const positionRaw = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.sudoCore.positionsParent,
+            name: {
+              type: `${this.consts.sudoCore.package}::market::PositionName<${positionCapInfo.symbol0
+                }, ${positionCapInfo.symbol1}, ${this.consts.sudoCore.package
+                }::market::${positionCapInfo.long ? 'LONG' : 'SHORT'}>`,
+              value: {
+                owner,
+                id: positionCapInfo.positionCapId,
+              },
+            },
+          })
+
+          if (positionRaw?.data?.content) {
+            positionInfoList.push(
+              await this.parsePositionInfo(
+                positionRaw,
+                positionCapInfo.positionCapId,
+              ),
+            )
+          }
+        }
+        catch (error) {
+          // Position might have been deleted after force settlement
+          console.warn(`Failed to parse position info for position cap ID ${positionCapInfo.positionCapId}: ${error}`)
+          // Continue with next position without adding this one to the list
+        }
+      }))
+    }
+
+    return positionInfoList.sort((a, b) =>
+      a.openTimestamp > b.openTimestamp ? 1 : -1,
+    )
+  }
+
+  /**
+   * Gets user history for SLP
+   */
+  public async getHistory(
+    trader: string,
+    page: number,
+    limit: number,
+    orderType?: string,
+    symbol?: string,
+  ): Promise<IBaseHistoryResponse> {
+    const params = new URLSearchParams({
+      trader,
+      page: page.toString(),
+      limit: limit.toString(),
+    })
+
+    if (orderType) {
+      params.append('orderType', orderType)
+    }
+    if (symbol) {
+      params.append('symbol', symbol)
+    }
+
+    const url = `${this.apiEndpoint}/traderEvents?${params}`
+    const res = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })
+    const response = await res.json() as any
+
+    return {
+      histories: response.data?.histories || [],
+      pagination: response.data?.pagination || {
+        total: 0,
+        page: 1,
+        limit: 20,
+        pages: 0,
+      },
+    }
+  }
+
+  public async getStaked(owner: string): Promise<ISLPStaked> {
+    let rawCredentialsData: any[] = []
+    let queryNextPage = true
+    let queryCursor
+    const limit = 50
+
+    while (queryNextPage) {
+      const { data, hasNextPage, nextCursor } = await this.provider.getOwnedObjects({
+        owner,
+        filter: {
+          MoveModule: {
+            package: this.consts.sudoStaking.package,
+            module: 'pool',
+          },
+        },
+        options: {
+          showType: true,
+          showContent: true,
+        },
+        cursor: queryCursor,
+        limit,
+      })
+
+      queryNextPage = hasNextPage
+      queryCursor = nextCursor!
+      if (!data)
+        break
+      rawCredentialsData = [...rawCredentialsData, ...data]
+    }
+
+    const pool = await this.getStakePool()
+    const credentials = rawCredentialsData.map((item: any) =>
+      SLPDataAPI.parseCredential(item, pool),
+    )
+    return {
+      credentials,
+      amount: credentials.reduce(
+        (acc: bigint, cur: ISLPCredential) => acc + cur.amount,
+        BigInt(0),
+      ),
+      claimable: credentials.reduce(
+        (acc: bigint, cur: ISLPCredential) => acc + cur.claimable,
+        BigInt(0),
+      ),
+    }
+  }
+
+  /**
+   * Legacy method: Get stake pool from sudo_staking
+   */
+  public async getStakePool(): Promise<ISLPStakePool> {
+    const raw = await this.provider.getObject({
+      id: this.consts.sudoStaking.pool,
+      options: {
+        showContent: true,
+      },
+    })
+    return SLPDataAPI.parseStakePool(raw)
+  }
+
+  public async getStakePoolV2(): Promise<ISLPStakePool> {
+    const poolId = this.sharedConfig.zoStaking.pools.slp
+    const raw = await this.provider.getObject({
+      id: poolId,
+      options: {
+        showContent: true,
+      },
+    })
+    return SLPDataAPI.parseStakePool(raw)
+  }
+
+  public async getStakedV2(owner: string): Promise<ISLPStaked> {
+    let rawCredentialsData: any[] = []
+    let queryNextPage = true
+    let queryCursor
+    const limit = 50
+
+    while (queryNextPage) {
+      const { data, hasNextPage, nextCursor } = await this.provider.getOwnedObjects({
+        owner,
+        filter: {
+          MoveModule: {
+            package: this.sharedConfig.zoStaking.package,
+            module: 'pool',
+          },
+        },
+        options: {
+          showType: true,
+          showContent: true,
+        },
+        cursor: queryCursor,
+        limit,
+      })
+
+      queryNextPage = hasNextPage
+      queryCursor = nextCursor!
+      if (!data)
+        break
+      rawCredentialsData = [...rawCredentialsData, ...data]
+    }
+
+    const pool = await this.getStakePoolV2()
+
+    const credentials = rawCredentialsData
+      .filter(
+        (item: any) =>
+          item.data.type
+          === `${this.sharedConfig.zoStaking.package}::pool::Credential<${this.consts.sudoCore.package}::slp::SLP, ${this.consts.sudoCore.package}::slp::SLP>`,
+      )
+.map((item: any) =>
+        SLPDataAPI.parseCredential(item, pool),
+      )
+    return {
+      credentials,
+      amount: credentials.reduce(
+        (acc: bigint, cur: ISLPCredential) => acc + cur.amount,
+        BigInt(0),
+      ),
+      claimable: credentials.reduce(
+        (acc: bigint, cur: ISLPCredential) => acc + cur.claimable,
+        BigInt(0),
+      ),
+    }
+  }
+
+  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)
+
+      if (longSymbol.lastUpdate <= 0 && shortSymbol.lastUpdate <= 0) {
+        return 0
+      }
+
+      const elapsed = SECONDS_PER_EIGHT_HOUR
+      const deltaRate = SLPDataAPI.calcOiFundingFeeRate(
+        oiState.model,
+        longSymbol.openingSize,
+        shortSymbol.openingSize,
+        elapsed,
+      )
+      return long ? deltaRate : -deltaRate
+    }
+
+      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> {
+    let vaultValue = 0
+    if (!increase && amount > 0) {
+      amount = -amount
+    }
+    const value = amount * (await this.getOraclePrice(collateralToken)).getPriceUnchecked().getPriceAsNumberUnchecked() / (10 ** this.consts.coins[collateralToken].decimals)
+
+    const vaultPromises = Object.keys(this.consts.sudoCore.vaults).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 res = totalVaultAmount * oraclePrice / (10 ** this.consts.coins[vault].decimals)
+      if (collateralToken === vault) {
+        vaultValue = res
+      }
+      return res
+    })
+
+    const vaultValues = await Promise.all(vaultPromises)
+    const totalVaultValue = vaultValues.reduce((acc, curr) => acc + curr, 0)
+    const targetRatio = Number.parseInt(
+      this.consts.sudoCore.vaults[collateralToken].weight,
+      10,
+    ) / Object.values(this.consts.sudoCore.vaults)
+      .map(e => Number.parseInt(e.weight, 10))
+      .reduce((acc, curr) => acc + curr, 0)
+
+    return SLPDataAPI.calcRebaseFeeRate(
+      await this.getRebaseFeeModel(),
+      increase,
+      (vaultValue + value) / (totalVaultValue + value),
+      targetRatio,
+    )
+  }
+
+  public async reservingFeeRate(collateralToken: string, amount: number, sender?: string): Promise<number> {
+    if (!sender) {
+      throw new Error('Sender address is required for reservingFeeRate calculation')
+    }
+    const vaultInfo = await this.getVaultInfo(collateralToken)
+    const vaultSupply
+      = vaultInfo.liquidity
+      + vaultInfo.reservedAmount
+      + vaultInfo.unrealisedReservingFeeAmount
+      + amount
+    const utilization = vaultSupply
+      ? Number.parseInt(
+        (((vaultInfo.reservedAmount + amount) / vaultSupply) * 1e18).toFixed(
+          0,
+        ),
+        10,
+      )
+      : 0
+    const tx = new Transaction()
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::model::compute_reserving_fee_rate`,
+      arguments: [
+        tx.object(
+          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel,
+        ),
+        tx.pure.u128(utilization),
+        tx.pure.u64(8 * 3600),
+      ],
+    })
+    const res: any = await this.provider.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender,
+    })
+    const de = Rate.parse(
+      new Uint8Array(res.results.at(-1).returnValues[0][0]),
+    )
+    return Number(BigInt(de)) / 1e18
+  }
+
+  public async getPositionConfig(indexToken: string, long: boolean): Promise<ISLPPositionConfig> {
+    this.validateCache()
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+    if (this.positionConfigCache[symbol]) {
+      return this.positionConfigCache[symbol]
+    }
+
+    const rawData = await this.provider.getObject({
+      id: this.consts.sudoCore.symbols[symbol].positionConfig,
+      options: {
+        showContent: true,
+      },
+    })
+    return SLPDataAPI.parsePositionConfig(rawData)
+  }
+
+  public async getOpenPositions(batchSize = 50, symbol = 'sui'): Promise<ISLPPositionInfo[]> {
+    let positionDynamicFields: DynamicFieldInfo[] = []
+    let _continue = true
+    let cursor
+    while (_continue) {
+      // data here will be a list of dynamic fields containing name and value
+      const { data, nextCursor, hasNextPage }
+        = await this.provider.getDynamicFields({
+          parentId: this.consts.sudoCore.positionsParent,
+          cursor,
+        })
+
+      positionDynamicFields = positionDynamicFields.concat(data)
+      _continue = hasNextPage
+      cursor = nextCursor
+    }
+
+    // Filter by symbol if provided
+    if (!(symbol && this.consts.coins[symbol])) {
+      return []
+    }
+    const coinModule = symbol === 'sui' ? '0x2::sui::SUI' : this.consts.coins[symbol].module
+    positionDynamicFields = positionDynamicFields.filter((field) => {
+      // Extract the second coin module from PositionName<coin1, coin2, direction>
+      const typeStr = field.name?.type
+      if (!typeStr)
+        return false
+
+      const match = typeStr.match(/PositionName<([^,]+),([^,]+),([^>]+)>/)
+      if (!match)
+        return false
+
+      const secondCoin = match[2].trim()
+      return secondCoin === coinModule
+    })
+
+    // then we query by dynamic field names and order by time
+    const positionInfoList: ISLPPositionInfo[] = []
+
+    for (let i = 0; i < positionDynamicFields.length; i += batchSize) {
+      const batch = positionDynamicFields.slice(i, i + batchSize)
+
+      await Promise.all(
+        batch.map(async (positionDynamicField) => {
+          const positionRaw = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.sudoCore.positionsParent,
+            name: positionDynamicField.name,
+          })
+
+          if (positionRaw?.data?.content) {
+            // @ts-expect-error: content fields type is not properly defined
+            if (positionRaw?.data?.content?.fields?.value?.fields?.closed) {
+              // skip closed positions
+              return
+            }
+            const positionInfo = await this.parsePositionInfo(
+              positionRaw,
+              positionDynamicField.objectId,
+            )
+            if (positionInfo) {
+              positionInfoList.push(positionInfo)
+            }
+          }
+        }),
+      )
+    }
+
+    return positionInfoList
+      .filter(positionInfo => !positionInfo.closed)
+      .sort((a, b) => (a.openTimestamp > b.openTimestamp ? 1 : -1))
+  }
+
+  public async getPositionCapInfoList(owner: string): Promise<ISLPPositionCapInfo[]> {
+    let cursor: string | undefined | null
+    let hasNextPage = true
+    const positionCapInfoList = []
+
+    while (hasNextPage) {
+      const positionCaps = await this.provider.getOwnedObjects({
+        owner,
+        filter: {
+          StructType: `${this.consts.sudoCore.package}::market::PositionCap`,
+        },
+        options: {
+          showType: true,
+        },
+        cursor,
+      })
+
+      for (const positionCap of positionCaps.data) {
+        if (positionCap.data?.type?.includes('PositionCap')) {
+          positionCapInfoList.push({
+            positionCapId: positionCap.data.objectId,
+            symbol0: positionCap.data.type.split('<')[1].split(',')[0].trim(),
+            symbol1: positionCap.data.type
+              .split('<')[1]
+              .split(',')[1]
+              .split(',')[0]
+              .trim(),
+            long: positionCap.data.type.includes('LONG'),
+          })
+        }
+      }
+
+      hasNextPage = positionCaps.hasNextPage
+      cursor = positionCaps.nextCursor
+    }
+
+    return positionCapInfoList
+  }
+
+  public async getOrderCapInfoList(owner: string): Promise<ISLPOrderCapInfo[]> {
+    let cursor: string | undefined | null
+    let hasNextPage = true
+    const orderCapInfoList = []
+
+    while (hasNextPage) {
+      const orderCaps = await this.provider.getOwnedObjects({
+        owner,
+        filter: {
+          StructType: `${this.consts.sudoCore.package}::market::OrderCap`,
+        },
+        options: {
+          showType: true,
+          showContent: true,
+        },
+        cursor,
+      })
+
+      for (const orderCap of orderCaps.data) {
+        if (orderCap.data?.type?.includes('OrderCap')) {
+          orderCapInfoList.push({
+            orderCapId: orderCap.data.objectId,
+            symbol0: orderCap.data.type.split('<')[1].split(',')[0].trim(),
+            symbol1: orderCap.data.type
+              .split('<')[1]
+              .split(',')[1]
+              .split(',')[0]
+              .trim(),
+            long: orderCap.data.type.includes('LONG'),
+            positionId: (orderCap.data.content as any)?.fields?.position_id,
+          })
+        }
+      }
+
+      hasNextPage = orderCaps.hasNextPage
+      cursor = orderCaps.nextCursor
+    }
+
+    return orderCapInfoList
+  }
+
+  public async hasReferral(referree: string): Promise<boolean> {
+    const raw = await this.getReferralData(referree)
+    return !raw.error
+  }
+
+  public async getReferralData(referree: string): Promise<any> {
+    const raw = await this.provider.getDynamicFieldObject({
+      parentId: this.consts.sudoCore.referralsParent,
+      name: {
+        type: 'address',
+        value: referree,
+      },
+    })
+    return raw
+  }
+
+  /**
+   * Gets user orders for SLP
+   */
+  public async getOrderInfoList(
+    orderCapInfoList: ISLPOrderCapInfo[],
+    owner: string,
+    batchSize = 10,
+  ): Promise<ISLPOrderInfo[]> {
+    const orderInfoList: ISLPOrderInfo[] = []
+
+    // Process in batches of 10
+    for (let i = 0; i < orderCapInfoList.length; i += batchSize) {
+      const batch = orderCapInfoList.slice(i, i + batchSize)
+
+      await Promise.all(batch.map(async (orderCapInfo) => {
+        try {
+          let orderRaw = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.sudoCore.ordersParent,
+            name: {
+              type: `${this.consts.sudoCore.package}::market::OrderName<${orderCapInfo.symbol0
+                }, ${orderCapInfo.symbol1}, ${this.consts.sudoCore.package
+                }::market::${orderCapInfo.long ? 'LONG' : 'SHORT'}, ${orderCapInfo.symbol0}>`,
+              value: {
+                owner,
+                id: orderCapInfo.orderCapId,
+                position_id: {
+                  vec: orderCapInfo.positionId ? [orderCapInfo.positionId] : [],
+                },
+              },
+            },
+          })
+
+          if (orderRaw?.error?.code === 'dynamicFieldNotFound') {
+            orderRaw = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.sudoCore.ordersParent,
+              name: {
+                type: `${this.consts.sudoCore.package}::market::OrderName<${orderCapInfo.symbol0
+                  }, ${orderCapInfo.symbol1}, ${this.consts.sudoCore.package
+                  }::market::${orderCapInfo.long ? 'LONG' : 'SHORT'}, ${this.consts.coins.sui.module}>`,
+                value: {
+                  owner,
+                  id: orderCapInfo.orderCapId,
+                  position_id: {
+                    vec: orderCapInfo.positionId ? [orderCapInfo.positionId] : [],
+                  },
+                },
+              },
+            })
+          }
+          orderInfoList.push(
+            this.parseOrderInfo(orderRaw, orderCapInfo.orderCapId),
+          )
+        }
+        catch (error) {
+          // Order might have been deleted
+          console.warn(`Failed to parse order info for order cap ID ${orderCapInfo.orderCapId}: ${error}`)
+          // Continue with next order without adding this one to the list
+        }
+      }))
+    }
+
+    return orderInfoList.sort((a, b) => (a.createdAt > b.createdAt ? 1 : -1))
+  }
+
+  public async getCumulativeApr() {
+    const refetchDate = new Date(Date.now() - 3600_000)
+    // fetch new every hour
+    if (
+      !aprResponse?.generatedAt
+      || (aprResponse?.generatedAt
+        && refetchDate > new Date(aprResponse?.generatedAt))
+    ) {
+      try {
+        const url = `${this.apiEndpoint}/cumulativeApr`
+        const res = await fetch(url, {
+          method: 'GET',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+        })
+        const data = await res.json()
+        // eslint-disable-next-line require-atomic-updates
+        aprResponse = { ...data }
+        return data.cumulativeApr
+      }
+      catch {
+        console.error('Failed to get cumulative APR')
+      }
+
+      return 0
+    }
+    return aprResponse.apr
+  }
+
+  // Private helper methods
+  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,
+    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)
+      }
+    }
+    return symbol.accFundingRate
+  }
+
+  private static calcDeltaSize(symbol: ISLPSymbolInfo, price: number, isLong: boolean): number {
+    const latestSize = symbol.openingAmount / symbol.priceConfig.precision * price
+    return isLong ? symbol.openingSize - latestSize : latestSize - symbol.openingSize
+  }
+
+  private static calcFundingFeeRate(model: ISLPFundingFeeModel, pnlPerRate: number, elapsed: number): number {
+    const dailyRate = Math.min(model.multiplier * Math.abs(pnlPerRate), model.max)
+    const secondsRate = dailyRate * elapsed / SECONDS_PER_EIGHT_HOUR
+    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.reservedAmount
+  }
+
+  private static calcAccReservingFeeRate(vault: ISLPVaultInfo, model: ISLPReservingFeeModel, timestamp: number): number {
+    if (vault.lastUpdate > 0) {
+      const elapsed = timestamp - vault.lastUpdate
+      if (elapsed > 0) {
+        const utilization = SLPDataAPI.vaultUtilization(vault)
+        return vault.accReservingRate + SLPDataAPI.calcReservingFeeRate(model, utilization, elapsed)
+      }
+    }
+    return vault.accReservingRate
+  }
+
+  private static vaultUtilization(vault: ISLPVaultInfo): number {
+    const supplyAmount = vault.liquidity + vault.reservedAmount + vault.unrealisedReservingFeeAmount
+    if (supplyAmount === 0) {
+      return 0
+    }
+    return vault.reservedAmount / supplyAmount
+  }
+
+  private static calcReservingFeeRate(model: ISLPReservingFeeModel, utilization: number, elapsed: number): number {
+    return model.multiplier * utilization * elapsed / SECONDS_PER_EIGHT_HOUR
+  }
+
+  private static parsePositionConfig(raw: any): ISLPPositionConfig {
+    const positionConfigFields = raw.data.content.fields.inner.fields
+
+    return {
+      decreaseFeeBps: parseValue(positionConfigFields.decrease_fee_bps),
+      liquidationBonus: parseValue(positionConfigFields.liquidation_bonus),
+      liquidationThreshold: parseValue(
+        positionConfigFields.liquidation_threshold,
+      ),
+      maxLeverage: parseValue(positionConfigFields.max_leverage),
+      minHoldingDuration: parseValue(positionConfigFields.min_holding_duration),
+      openFeeBps: parseValue(positionConfigFields.open_fee_bps),
+      maxReservedMultiplier: parseValue(
+        positionConfigFields.max_reserved_multiplier,
+      ),
+      minCollateralValue: parseValue(positionConfigFields.min_collateral_value),
+    }
+  }
+
+  private static parseSymbolConfig(raw: any): ISLPSymbolConfig {
+    const { fields } = raw.data.content
+
+    return {
+      id: fields.id.id,
+      max_opening_size: parseValue(fields.max_opening_size),
+      max_opening_size_enabled: fields.max_opening_size_enabled,
+      max_opening_size_per_position: parseValue(fields.max_opening_size_per_position),
+      max_opening_size_per_position_enabled: fields.max_opening_size_per_position_enabled,
+      instant_exit_fee_config: {
+        instant_exit_tier_1_duration_threshold: parseValue(fields.instant_exit_fee_config.fields.instant_exit_tier_1_duration_threshold),
+        instant_exit_tier_1_fee_bps: parseValue(fields.instant_exit_fee_config.fields.instant_exit_tier_1_fee_bps.fields.value),
+        instant_exit_tier_1_fee_enabled: fields.instant_exit_fee_config.fields.instant_exit_tier_1_fee_enabled,
+        instant_exit_tier_2_duration_threshold: parseValue(fields.instant_exit_fee_config.fields.instant_exit_tier_2_duration_threshold),
+        instant_exit_tier_2_fee_bps: parseValue(fields.instant_exit_fee_config.fields.instant_exit_tier_2_fee_bps.fields.value),
+        instant_exit_tier_2_fee_enabled: fields.instant_exit_fee_config.fields.instant_exit_tier_2_fee_enabled,
+        instant_exit_tier_3_duration_threshold: parseValue(fields.instant_exit_fee_config.fields.instant_exit_tier_3_duration_threshold),
+        instant_exit_tier_3_fee_bps: parseValue(fields.instant_exit_fee_config.fields.instant_exit_tier_3_fee_bps.fields.value),
+        instant_exit_tier_3_fee_enabled: fields.instant_exit_fee_config.fields.instant_exit_tier_3_fee_enabled,
+      },
+    }
+  }
+
+  private static parseRebaseFeeModel(raw: any): ISLPRebaseFeeModel {
+    const { fields } = raw.data.content
+
+    return {
+      base: parseValue(fields.base),
+      multiplier: parseValue(fields.multiplier),
+    }
+  }
+
+  private static calcRebaseFeeRate(model: ISLPRebaseFeeModel, increase: boolean, ratio: number, targetRatio: number): number {
+    if ((increase && ratio <= targetRatio) || (!increase && ratio >= targetRatio)) {
+      return model.base
+    }
+    const exponent = model.exponent ?? 1
+    return model.base + model.multiplier * (Math.abs(ratio - targetRatio) ** exponent)
+  }
+
+  /**
+   * Fetches rebase fee exponent from chain (dynamic field RebaseFeeExponentKey).
+   * Returns 1 (linear) for backward compatibility when not set.
+   */
+  private static async getRebaseFeeExponent(
+    provider: SuiClient,
+    rebaseFeeModelId: string,
+    packageId: string,
+  ): Promise<number> {
+    const WAD = 1e18
+    try {
+      const raw = await provider.getDynamicFieldObject({
+        parentId: rebaseFeeModelId,
+        name: {
+          type: `${packageId}::model::RebaseFeeExponentKey`,
+          value: {},
+        },
+      })
+      if (raw.data?.content && 'fields' in raw.data.content) {
+        const value = (raw.data.content as any).fields?.value
+        if (value !== undefined) {
+          return Number(BigInt(value)) / WAD
+        }
+      }
+    }
+    catch {
+      // Dynamic field doesn't exist - use default WAD (linear)
+    }
+    return 1
+  }
+
+  /**
+   * Computes the spread rate based on OI skew between long and short sides using point evaluation.
+   * This is the offchain equivalent of price_impact::compute_spread_rate in the Move contract.
+   */
+  public static computeSpreadRate(
+    config: ISLPPriceImpactConfig,
+    currentOiThisSide: number,
+    newPositionSize: number,
+    currentOiOpposite: number,
+    maxOiThisSide: number,
+    maxOiOpposite: number,
+  ): number {
+    if (!config.enabled) {
+      return 0
+    }
+    if (maxOiThisSide === 0) {
+      return config.baseSpreadRate
+    }
+    const totalOiThis = currentOiThisSide + newPositionSize
+    const thisUtil = Math.min(totalOiThis / maxOiThisSide, 1)
+    let oppositeUtil = 0
+    if (maxOiOpposite > 0) {
+      oppositeUtil = Math.min(currentOiOpposite / maxOiOpposite, 1)
+    }
+    let skewRatio = thisUtil - oppositeUtil
+    if (skewRatio < 0) {
+      skewRatio = 0
+    }
+    else if (skewRatio > 1) {
+      skewRatio = 1
+    }
+    const exponent = config.impactExponent
+    const exponentInt = Math.floor(exponent)
+    const exponentFrac = exponent - exponentInt
+    let ratioPowered = skewRatio ** exponentInt
+    if (exponentFrac > 0) {
+      const ratioPoweredNext = skewRatio ** (exponentInt + 1)
+      const diff = ratioPoweredNext - ratioPowered
+      if (diff >= 0) {
+        ratioPowered += exponentFrac * diff
+      }
+    }
+    const dynamicSpread = config.maxDynamicSpreadRate * ratioPowered
+    let totalSpread = config.baseSpreadRate + dynamicSpread
+    if (totalSpread > config.maxTotalSpreadRate) {
+      totalSpread = config.maxTotalSpreadRate
+    }
+    return totalSpread
+  }
+
+  private static computeSizeFactor(positionSize: number, referenceSize: number): number {
+    if (referenceSize === 0) {
+      return 1
+    }
+    const ratio = Math.min(positionSize / referenceSize, 1)
+    return 1 + ratio
+  }
+
+  private static computeIntegralAverage(
+    maxDynamic: number,
+    s1: number,
+    s2: number,
+    exponent: number,
+  ): number {
+    if (s1 === s2) {
+      return maxDynamic * (s1 ** exponent)
+    }
+    const nPlus1 = exponent + 1
+    const s2Pow = s2 ** nPlus1
+    const s1Pow = s1 ** nPlus1
+    const numerator = Math.abs(s2Pow - s1Pow)
+    const sDiff = Math.abs(s2 - s1)
+    const denominator = nPlus1 * sDiff
+    if (denominator === 0) {
+      return 0
+    }
+    return maxDynamic * (numerator / denominator)
+  }
+
+  /**
+   * Computes the average spread rate over the trade path with size scaling.
+   * This is the offchain equivalent of price_impact::compute_average_spread_rate in the Move contract.
+   */
+  public static computeAverageSpreadRate(
+    config: ISLPPriceImpactConfig,
+    currentOiThisSide: number,
+    newPositionSize: number,
+    currentOiOpposite: number,
+    maxOiThisSide: number,
+    maxOiOpposite: number,
+  ): number {
+    if (!config.enabled) {
+      return 0
+    }
+    if (maxOiThisSide === 0) {
+      return config.baseSpreadRate
+    }
+    let oppositeUtil = 0
+    if (maxOiOpposite > 0) {
+      oppositeUtil = Math.min(currentOiOpposite / maxOiOpposite, 1)
+    }
+    const startUtil = Math.min(currentOiThisSide / maxOiThisSide, 1)
+    const totalOiThis = currentOiThisSide + newPositionSize
+    const endUtil = Math.min(totalOiThis / maxOiThisSide, 1)
+    let startSkew = startUtil - oppositeUtil
+    if (startSkew < 0) {
+      startSkew = 0
+    }
+    else if (startSkew > 1) {
+      startSkew = 1
+    }
+    let endSkew = endUtil - oppositeUtil
+    if (endSkew < 0) {
+      endSkew = 0
+    }
+    else if (endSkew > 1) {
+      endSkew = 1
+    }
+    const avgDynamicRate = SLPDataAPI.computeIntegralAverage(
+      config.maxDynamicSpreadRate,
+      startSkew,
+      endSkew,
+      config.impactExponent,
+    )
+    const sizeFactor = SLPDataAPI.computeSizeFactor(newPositionSize, config.referenceSize)
+    const scaledDynamicRate = avgDynamicRate * sizeFactor
+    let totalSpread = config.baseSpreadRate + scaledDynamicRate
+    if (totalSpread > config.maxTotalSpreadRate) {
+      totalSpread = config.maxTotalSpreadRate
+    }
+    return totalSpread
+  }
+
+  /**
+   * Applies price impact to a price.
+   * This is the offchain equivalent of price_impact::apply_price_impact in the Move contract.
+   */
+  public static applyPriceImpact(
+    originalPrice: number,
+    spreadRate: number,
+    isLong: boolean,
+    isOpening: boolean,
+  ): number {
+    if (spreadRate === 0) {
+      return originalPrice
+    }
+    const increasePrice = (isLong && isOpening) || (!isLong && !isOpening)
+    const spreadAmount = originalPrice * spreadRate
+    if (increasePrice) {
+      return originalPrice + spreadAmount
+    }
+    const adjusted = originalPrice - spreadAmount
+    return Math.max(adjusted, 0)
+  }
+
+  /**
+   * Convenience method to compute the estimated execution price with price impact.
+   */
+  public async estimatePriceImpact(
+    indexToken: string,
+    isLong: boolean,
+    isOpening: boolean,
+    positionSizeValue: number,
+  ): Promise<{ spreadRate: number, originalPrice: number, adjustedPrice: number } | null> {
+    const config = await this.getPriceImpactConfig(indexToken)
+    if (!config) {
+      return null
+    }
+    const longSymbol = await this.getSymbolInfo(indexToken, true)
+    const shortSymbol = await this.getSymbolInfo(indexToken, false)
+    const oraclePrice = (await this.getOraclePrice(indexToken)).getPriceUnchecked().getPriceAsNumberUnchecked()
+    const currentOiThisSide = isLong ? longSymbol.openingSize : shortSymbol.openingSize
+    const currentOiOpposite = isLong ? shortSymbol.openingSize : longSymbol.openingSize
+    const maxOiThisSide = isLong ? config.maxOiLong : config.maxOiShort
+    const maxOiOpposite = isLong ? config.maxOiShort : config.maxOiLong
+    const spreadRate = SLPDataAPI.computeAverageSpreadRate(
+      config,
+      currentOiThisSide,
+      positionSizeValue,
+      currentOiOpposite,
+      maxOiThisSide,
+      maxOiOpposite,
+    )
+    const adjustedPrice = SLPDataAPI.applyPriceImpact(oraclePrice, spreadRate, isLong, isOpening)
+    return {
+      spreadRate,
+      originalPrice: oraclePrice,
+      adjustedPrice,
+    }
+  }
+
+  private static parseFundingFeeModel(raw: any): ISLPFundingFeeModel {
+    const { fields } = raw.data.content
+
+    return {
+      multiplier: parseValue(fields.multiplier),
+      max: parseValue(fields.max),
+    }
+  }
+
+  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 parsePriceImpactConfig(raw: any): ISLPPriceImpactConfig {
+    const content = raw.data.content.fields
+    return {
+      id: content.id.id,
+      enabled: content.enabled,
+      baseSpreadRate: parseValue(content.base_spread_rate),
+      maxDynamicSpreadRate: parseValue(content.max_dynamic_spread_rate),
+      maxTotalSpreadRate: parseValue(content.max_total_spread_rate),
+      impactExponent: parseValue(content.impact_exponent),
+      maxOiLong: parseValue(content.max_oi_long),
+      maxOiShort: parseValue(content.max_oi_short),
+      referenceSize: parseValue(content.reference_size),
+    }
+  }
+
+  private static parseMarketInfo(raw: any): ISLPMarketInfo {
+    const content = raw.data.content.fields
+
+    return {
+      lpSupply: content.lp_supply.fields.value,
+      positionId: content.positions.fields.id.id,
+      vaultId: content.vaults.fields.id.id,
+      symbolId: content.symbols.fields.id.id,
+      lpSupplyWithDecimals:
+        content.lp_supply.fields.value / 10 ** SLP_TOKEN_DECIMALS,
+    }
+  }
+
+  private async parseVaultInfo(raw: any): Promise<ISLPVaultInfo> {
+    const vaultFields = raw.data.content.fields.value.fields
+    const reservingFeeModelAddr = vaultFields.reserving_fee_model
+    const reservingFeeModelRaw = await this.provider.getObject({
+      id: reservingFeeModelAddr,
+      options: {
+        showContent: true,
+      },
+    })
+    const reservingFeeModel = SLPDataAPI.parseReservingFeeModel(reservingFeeModelRaw)
+
+    return {
+      liquidity: parseValue(vaultFields.liquidity),
+      reservedAmount: parseValue(vaultFields.reserved_amount),
+      unrealisedReservingFeeAmount: parseValue(
+        vaultFields.unrealised_reserving_fee_amount,
+      ),
+      accReservingRate: parseValue(vaultFields.acc_reserving_rate),
+      enabled: vaultFields.enabled,
+      weight: parseValue(vaultFields.weight),
+      lastUpdate: parseValue(vaultFields.last_update),
+      reservingFeeModel,
+      priceConfig: {
+        maxInterval: parseValue(vaultFields.price_config.fields.max_interval),
+        maxConfidence: parseValue(vaultFields.price_config.fields.max_confidence),
+        precision: parseValue(vaultFields.price_config.fields.precision),
+        feeder: vaultFields.price_config.fields.feeder,
+      },
+    }
+  }
+
+  private static parseReservingFeeModel(raw: any): { multiplier: number } {
+    const content = raw.data.content.fields
+    return {
+      multiplier: parseValue(content.multiplier),
+    }
+  }
+
+  private async parseSymbolInfo(raw: any, long: boolean): Promise<ISLPSymbolInfo> {
+    const { objectId } = raw.data
+    const { fields } = raw.data.content.fields.value
+    const fundingFeeModelAddr = fields.funding_fee_model
+    const fundingFeeModelRaw = await this.provider.getObject({
+      id: fundingFeeModelAddr,
+      options: {
+        showContent: true,
+      },
+    })
+    const fundingFeeModel = SLPDataAPI.parseFundingFeeModel(fundingFeeModelRaw)
+
+    return {
+      objectId,
+      openingSize: parseValue(fields.opening_size),
+      openingAmount: parseValue(fields.opening_amount),
+      accFundingRate: parseValue(fields.acc_funding_rate),
+      realisedPnl: parseValue(fields.realised_pnl),
+      unrealisedFundingFeeValue: parseValue(
+        fields.unrealised_funding_fee_value,
+      ),
+      openEnabled: fields.open_enabled,
+      liquidateEnabled: fields.liquidate_enabled,
+      decreaseEnabled: fields.decrease_enabled,
+      lastUpdate: parseValue(fields.last_update),
+      fundingFeeModel,
+      long,
+      priceConfig: {
+        maxInterval: parseValue(fields.price_config.fields.max_interval),
+        maxConfidence: parseValue(fields.price_config.fields.max_confidence),
+        precision: parseValue(fields.price_config.fields.precision),
+        feeder: fields.price_config.fields.feeder,
+      },
+    }
+  }
+
+  private async parsePositionInfo(raw: any, id_: string): Promise<ISLPPositionInfo> {
+    const { content } = raw.data
+    const { fields } = content
+    const positionFields = fields.value.fields
+    const dataType = fields.name.type
+
+    const positionInfo = {
+      id: id_,
+      long: dataType.includes('::market::LONG'),
+      owner: fields.name.fields.owner,
+      version: Number.parseInt(raw.data.version, 10),
+      collateralToken: suiSymbolToSymbol(
+        dataType.split('<')[1].split(',')[0].trim(),
+        this.consts,
+      ),
+      indexToken: suiSymbolToSymbol(dataType.split(',')[1].trim(), this.consts),
+      collateralAmount: parseValue(positionFields.collateral),
+      positionAmount: parseValue(positionFields.position_amount),
+      reservedAmount: parseValue(positionFields.reserved),
+      positionSize: parseValue(positionFields.position_size),
+      lastFundingRate: parseValue(positionFields.last_funding_rate),
+      lastReservingRate: parseValue(positionFields.last_reserving_rate),
+      reservingFeeAmount: parseValue(positionFields.reserving_fee_amount),
+      fundingFeeValue: parseValue(positionFields.funding_fee_value),
+      closed: positionFields.closed,
+      openTimestamp: parseValue(positionFields.open_timestamp),
+      protocol: 'sudo',
+    }
+
+    if (!positionFields.closed) {
+      try {
+        positionInfo.reservingFeeAmount = SLPDataAPI.calculatePositionReserveFee(
+          positionInfo,
+          await this.getVaultInfo(positionInfo.collateralToken),
+          (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),
+          (await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long)).fundingFeeModel,
+          (await this.getOraclePrice(positionInfo.indexToken)).getPriceUnchecked().getPriceAsNumberUnchecked(),
+          (await this.getMarketInfo()).lpSupplyWithDecimals,
+          Date.now() / 1000,
+          oiState && oiState.enabled ? oiState.model : undefined,
+          pairedSymbol.openingSize,
+        )
+      }
+      catch (e) {
+        console.error(e)
+        positionInfo.reservingFeeAmount = 0
+        positionInfo.fundingFeeValue = 0
+      }
+    }
+
+    return positionInfo
+  }
+
+  private parseOrderInfo(raw: any, capId: string): ISLPOrderInfo {
+    const { content } = raw.data
+    const { fields } = content.fields.value
+
+    // Extract tokens from dataType
+    const dataType = content?.type
+
+    let orderType: IBaseOrderType
+    if (content.fields.value?.type.includes('OpenPositionOrder')) {
+      orderType = 'OPEN_POSITION'
+    }
+    else if (content.fields.value?.type.includes('OpenMarketOrder')) {
+      orderType = 'OPEN_MARKET'
+    }
+    else if (content.fields.value?.type.includes('DecreasePositionOrder')) {
+      orderType = 'DECREASE_POSITION'
+    }
+    else {
+      orderType = 'DECREASE_MARKET'
+    }
+    const orderVersion = content.fields.value?.type.includes('V2')
+      ? 'V2'
+      : 'V1_1'
+
+    const ret: ISLPOrderInfo = {
+      id: content.fields.id.id,
+      capId,
+      executed: fields.executed,
+      owner: content.fields.name.fields.owner,
+      collateralToken: suiSymbolToSymbol(
+        dataType.split('<')[2].split(',')[0].trim(),
+        this.consts,
+      ),
+      indexToken: suiSymbolToSymbol(dataType.split(',')[1].trim(), this.consts),
+      feeToken: suiSymbolToSymbol(
+        dataType.split(',')[3].split('>')[0].trim(),
+        this.consts,
+      ),
+      // Use index_price for open orders, limited_index_price for decrease orders
+      indexPrice: orderType === 'OPEN_MARKET'
+        ? parseValue(fields.index_price)
+        : parseValue(fields.limited_index_price?.fields?.price || fields.limited_index_price),
+      collateralPriceThreshold: fields.collateral_price_threshold ? parseValue(fields.collateral_price_threshold) : 0,
+      // New index price threshold
+      indexPriceThreshold: fields.index_price_threshold ? parseValue(fields.index_price_threshold) : undefined,
+      feeAmount: BigInt(fields.fee),
+      long: dataType.includes('::market::LONG'),
+      orderType,
+      orderVersion,
+      createdAt: parseValue(fields.created_at),
+      v11Order: !fields.limited_index_price?.fields?.price,
+      // New: referrer and scard fields
+      referrer: fields.referrer,
+      scardId: (
+        fields.scard_id?.fields?.some?.fields?.id
+        || fields.scard_id?.fields?.value?.fields?.id
+        || fields.scard_id?.fields?.id
+        || fields.scard_id?.id
+      ),
+      scardRebateRate: (() => {
+        const inner = fields.scard_rebate_rate?.fields?.some ?? fields.scard_rebate_rate?.fields?.value
+        return inner ? parseValue(inner) : undefined
+      })(),
+    }
+
+    if (orderType === 'OPEN_POSITION' || orderType === 'OPEN_MARKET') {
+      ret.openOrder = {
+        reserveAmount: BigInt(fields.reserve_amount),
+        collateralAmount: BigInt(fields.collateral),
+        openAmount: BigInt(fields.open_amount),
+        // New: position_config from OpenMarketOrder
+        positionConfig: fields.position_config?.fields
+          ? {
+              decreaseFeeBps: parseValue(fields.position_config.fields.decrease_fee_bps),
+              liquidationBonus: parseValue(fields.position_config.fields.liquidation_bonus),
+              liquidationThreshold: parseValue(fields.position_config.fields.liquidation_threshold),
+              maxLeverage: parseValue(fields.position_config.fields.max_leverage),
+              minHoldingDuration: parseValue(fields.position_config.fields.min_holding_duration),
+              openFeeBps: parseValue(fields.position_config.fields.open_fee_bps),
+              maxReservedMultiplier: parseValue(fields.position_config.fields.max_reserved_multiplier),
+              minCollateralValue: parseValue(fields.position_config.fields.min_collateral_value),
+            }
+          : undefined,
+      }
+    }
+    else if (orderType === 'DECREASE_POSITION' || orderType === 'DECREASE_MARKET') {
+      ret.decreaseOrder = {
+        decreaseAmount: BigInt(fields.decrease_amount),
+        takeProfit: fields.take_profit,
+      }
+    }
+
+    return ret
+  }
+
+  private static parseCredential(raw: any, pool: ISLPStakePool): ISLPCredential {
+    const stakedAmount = BigInt(raw.data.content.fields.stake)
+    const accRewardPerShare = BigInt(
+      raw.data.content.fields.acc_reward_per_share,
+    )
+    return {
+      id: raw.data.objectId,
+      lockUntil: parseValue(raw.data.content.fields.lock_until),
+      amount: stakedAmount,
+      accRewardPerShare,
+      claimable:
+        ((pool.accRewardPerShare - accRewardPerShare) * stakedAmount)
+        / BigInt(1e18),
+    }
+  }
+
+  private static parseStakePool(raw: any): ISLPStakePool {
+    const content = raw.data.content.fields
+
+    // Check if this is the new version with reward_vault and reward_rate
+    const isNewVersion = content.reward_vault !== undefined && content.reward_rate !== undefined
+
+    const pool: ISLPStakePool = {
+      id: content.id.id,
+      enabled: content.enabled,
+      lastUpdatedTime: parseValue(content.last_updated_time),
+      stakedAmount: BigInt(content.staked_amount),
+      // Support both old 'reward' and new 'reward_vault' field names
+      reward: BigInt(content.reward_vault || content.reward),
+      startTime: parseValue(content.start_time),
+      endTime: parseValue(content.end_time),
+      accRewardPerShare: BigInt(content.acc_reward_per_share),
+      lockDuration: parseValue(content.lock_duration),
+      // Add rewardRate if available (new version)
+      ...(isNewVersion && { rewardRate: BigInt(content.reward_rate) }),
+    }
+
+    // Use appropriate refresh method based on version
+    if (isNewVersion) {
+      SLPDataAPI.refreshPoolV2(pool, Math.floor(Date.now() / 1000))
+    }
+ else {
+      SLPDataAPI.refreshPool(pool, Math.floor(Date.now() / 1000))
+    }
+
+    return pool
+  }
+
+  // Legacy refresh method for backward compatibility
+  private static refreshPool(pool: ISLPStakePool, timestamp: number): void {
+    if (timestamp === pool.lastUpdatedTime || timestamp < pool.startTime) {
+      return
+    }
+    if (
+      pool.lastUpdatedTime === pool.endTime
+      || pool.stakedAmount === BigInt(0)
+    ) {
+      return
+    }
+    if (timestamp > pool.endTime) {
+      timestamp = pool.endTime
+    }
+
+    const rewardAmount
+      = (pool.reward * BigInt(timestamp - pool.lastUpdatedTime))
+      / BigInt(pool.endTime - pool.lastUpdatedTime)
+
+    pool.lastUpdatedTime = timestamp
+    const rewardPerShare = (rewardAmount * BigInt(1e18)) / pool.stakedAmount
+    pool.accRewardPerShare += rewardPerShare
+  }
+
+  // New refresh method matching SLP implementation
+  private static refreshPoolV2(pool: ISLPStakePool, timestamp: number): void {
+    if (timestamp <= pool.lastUpdatedTime || timestamp < pool.startTime) {
+      return
+    }
+
+    const applicableEndTime = Math.max(pool.endTime, pool.lastUpdatedTime)
+
+    const calculationEndTime = Math.min(timestamp, applicableEndTime)
+
+    if (calculationEndTime > pool.lastUpdatedTime && pool.stakedAmount > BigInt(0) && pool.rewardRate && pool.rewardRate > BigInt(0)) {
+      const timeDiff = BigInt(calculationEndTime - pool.lastUpdatedTime)
+      const rewardAmount = timeDiff * pool.rewardRate
+      const rewardPerShare = (rewardAmount * BigInt(1e18)) / pool.stakedAmount
+      pool.accRewardPerShare += rewardPerShare
+    }
+
+    pool.lastUpdatedTime = calculationEndTime
+  }
+}