@zofai/zo-sdk 0.1.92

package/src/data.ts

@@ -0,0 +1,1279 @@
+/* eslint-disable class-methods-use-this */
+
+import type { DynamicFieldInfo, SuiClient } from '@mysten/sui/client'
+import type { Transaction } from '@mysten/sui/transactions'
+import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui/utils'
+
+import type { Network } from './consts'
+import { SECONDS_PER_EIGHT_HOUR, ZLP_TOKEN_DECIMALS } from './consts'
+import { OracleAPI } from './oracle'
+import { createJsonRpcProvider, joinSymbol, parseSymbolKey, parseValue, suiSymbolToSymbol } from './utils'
+
+export interface IMarketInfo {
+  lpSupply: string
+  positionId: string
+  vaultId: string
+  symbolId: string
+  referralId: string
+  orderId: string
+  rebaseFeeModel: string
+  lpSupplyWithDecimals: number
+};
+
+export interface IRebaseFeeModel {
+  base: number
+  multiplier: number
+}
+
+export interface IReservingFeeModel {
+  multiplier: number
+}
+
+export interface IFundingFeeModel {
+  multiplier: number
+  max: number
+}
+
+export interface IVaultInfo {
+  liquidity: number
+  reservedAmount: number
+  unrealisedReservingFeeAmount: number
+  accReservingRate: number
+  enabled: boolean
+  weight: number
+  lastUpdate: number
+  reservingFeeModel: IReservingFeeModel
+  priceConfig: {
+    maxInterval: number
+    maxConfidence: number
+    precision: number
+    feeder: string
+  }
+}
+
+export interface ISymbolInfo {
+  openingSize: number
+  openingAmount: number
+  accFundingRate: number
+  realisedPnl: number
+  unrealisedFundingFeeValue: number
+  openEnabled: boolean
+  liquidateEnabled: boolean
+  decreaseEnabled: boolean
+  lastUpdate: number
+  fundingFeeModel: IFundingFeeModel
+  long: boolean
+  priceConfig: {
+    maxInterval: number
+    maxConfidence: number
+    precision: number
+    feeder: string
+  }
+}
+
+export interface IPositionInfo {
+  id: string
+  long: boolean
+  owner: string
+  version: number
+
+  collateralToken: string
+  indexToken: string
+
+  collateralAmount: number
+  positionAmount: number
+  reservedAmount: number
+
+  positionSize: number
+  lastFundingRate: number
+  lastReservingRate: number
+
+  reservingFeeAmount: number
+  fundingFeeValue: number
+
+  closed: boolean
+
+  openTimestamp: number
+}
+
+export interface IPositionCapInfo {
+  positionCapId: string
+  symbol0: string
+  symbol1: string
+  long: boolean
+}
+
+export interface IOrderCapInfo {
+  orderCapId: string
+  symbol0: string
+  symbol1: string
+  long: boolean
+  positionId: string | null
+}
+
+export interface IOrderInfo {
+  id: string
+  capId: string
+  executed: boolean
+  owner: string
+  collateralToken: string
+  indexToken: string
+  feeToken: string
+  collateralPriceThreshold: number
+  feeAmount: bigint
+  long: boolean
+  indexPrice: number
+  openOrder?: {
+    reserveAmount: bigint
+    collateralAmount: bigint
+    openAmount: bigint
+  }
+  decreaseOrder?: {
+    decreaseAmount: bigint
+    takeProfit: boolean
+  }
+  orderType: 'OPEN_POSITION' | 'DECREASE_POSITION'
+  createdAt: number
+  v11Order: boolean
+}
+
+export interface IMarketValuationInfo {
+  marketCap: number
+  zlpPrice: number
+  zlpSupply: number
+  apr?: number
+}
+
+export interface IPositionConfig {
+  decreaseFeeBps: number
+  liquidationBonus: number
+  liquidationThreshold: number
+  maxLeverage: number
+  minHoldingDuration: number
+  openFeeBps: number
+  maxReservedMultiplier: number
+  minCollateralValue: number
+}
+
+export interface IHistory {
+  owner: string
+  txid: string
+  id: string
+  created: number
+  eventName: string
+  indexToken: string
+  direction: string
+  collateralAmount: number
+  collateralPrice: number
+  indexPrice: number
+  pnl: number
+  positionId: string
+  volume: number
+  fee: number
+  network: string
+}
+
+export interface IStaked {
+  credentials: ICredential[]
+  amount: bigint
+  claimable: bigint
+}
+
+export interface ICredential {
+  id: string
+  lockUntil: number
+  accRewardPerShare: bigint
+  amount: bigint
+  claimable: bigint
+}
+
+export interface IStakePool {
+  id: string
+  enabled: boolean
+  lastUpdatedTime: number
+  stakedAmount: bigint
+  reward: bigint
+  startTime: number
+  endTime: number
+  accRewardPerShare: bigint
+  lockDuration: number
+}
+
+export interface IMarketValidationResult {
+  handledVaults: Record<string, {
+    weight: number
+    value: number
+  }>
+  totalWeight: number
+  totalVaultsValue: number
+  marketValue: number
+}
+
+export class DataAPI extends OracleAPI {
+  provider: SuiClient
+  apiEndpoint: string
+
+  private vaultInfoCache: Record<string, IVaultInfo> = {}
+
+  private symbolInfoCache: Record<string, ISymbolInfo> = {}
+
+  private marketInfoCache: IMarketInfo | null = null
+  private positionConfigCache: Record<string, IPositionConfig> = {}
+
+  private rebaseFeeModelCache: IRebaseFeeModel | null = null
+  private lastUpdate = 0
+
+  constructor(
+    network: Network,
+    provider: SuiClient | null,
+    apiEndpoint: string,
+    connectionURL: string,
+  ) {
+    super(network, provider, connectionURL)
+    this.provider = provider || createJsonRpcProvider(network)
+    this.apiEndpoint = apiEndpoint
+  }
+
+  validateCache = () => {
+    super.validateCache()
+    if (this.lastUpdate + 1000 * 60 * 3 < Date.now()) {
+      this.lastUpdate = Date.now()
+      this.vaultInfoCache = {}
+      this.symbolInfoCache = {}
+      this.marketInfoCache = null
+      this.positionConfigCache = {}
+      this.rebaseFeeModelCache = null
+    }
+  }
+
+  valuateVaults = (tx: Transaction) => {
+    const vaultsValuation = tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::create_vaults_valuation`,
+      typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.zoCore.market),
+      ],
+    })
+    for (const key of Object.keys(this.consts.zoCore.vaults)) {
+      const vault = this.consts.zoCore.vaults[key]
+      tx.moveCall({
+        // todo
+        target: `${this.consts.zoCore.upgradedPackage}::market::valuate_vault`,
+        typeArguments: [
+          `${this.consts.zoCore.package}::zlp::ZLP`,
+          this.consts.coins[key].module,
+        ],
+        arguments: [
+          tx.object(this.consts.zoCore.market),
+          tx.object(vault.reservingFeeModel),
+          tx.object(this.consts.pythFeeder.feeder[key]),
+          vaultsValuation,
+        ],
+      })
+    }
+    return vaultsValuation
+  }
+
+  valuateSymbols = (tx: Transaction) => {
+    const symbolsValuation = tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::create_symbols_valuation`,
+      typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.zoCore.market),
+      ],
+    })
+    for (const key of Object.keys(this.consts.zoCore.symbols)) {
+      const [direction, token] = parseSymbolKey(key)
+      const symbol = this.consts.zoCore.symbols[key]
+      tx.moveCall({
+        target: `${this.consts.zoCore.upgradedPackage}::market::valuate_symbol`,
+        typeArguments: [
+          `${this.consts.zoCore.package}::zlp::ZLP`,
+          this.consts.coins[token].module,
+          `${this.consts.zoCore.package}::market::${direction.toUpperCase()}`,
+        ],
+        arguments: [
+          tx.object(this.consts.zoCore.market),
+          tx.object(symbol.fundingFeeModel),
+          tx.object(this.consts.pythFeeder.feeder[token]),
+          symbolsValuation,
+        ],
+      })
+    }
+    return symbolsValuation
+  }
+
+  valuate = (tx: Transaction) => {
+    const vaultsValuation = this.valuateVaults(tx)
+    const symbolsValuation = this.valuateSymbols(tx)
+
+    return {
+      vaultsValuation,
+      symbolsValuation,
+    }
+  }
+
+  /**
+   * Validates the market valuation by calling the validate_market_valuation Move function
+   * @param tx Transaction object
+   * @returns An object containing handled vaults, total weight, total vaults value, and market value
+   */
+  validateMarketValuation = (tx: Transaction) => {
+    // First, create the valuations using existing methods
+    const vaultsValuation = this.valuateVaults(tx)
+    const symbolsValuation = this.valuateSymbols(tx)
+
+    // Call the validate_market_valuation Move function
+    const result = tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::validate_market_valuation`,
+      typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`],
+      arguments: [
+        tx.object(this.consts.zoCore.market),
+        vaultsValuation,
+        symbolsValuation,
+      ],
+    })
+
+    return result
+  }
+
+  #parseMarketInfo(raw: any): IMarketInfo {
+    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,
+      referralId: content.referrals.fields.id.id,
+      orderId: content.orders.fields.id.id,
+      rebaseFeeModel: content.rebase_fee_model,
+      lpSupplyWithDecimals: content.lp_supply.fields.value / (10 ** ZLP_TOKEN_DECIMALS),
+    }
+  }
+
+  #parseVaultInfo = async (raw: any): Promise<IVaultInfo> => {
+    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 = this.#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,
+      },
+    }
+  }
+
+  #parseSymbolInfo = async (raw: any, long: boolean): Promise<ISymbolInfo> => {
+    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 = this.#parseFundingFeeModel(fundingFeeModelRaw)
+
+    return {
+      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,
+      },
+    }
+  }
+
+  #parseRebaseFeeModel(raw: any): IRebaseFeeModel {
+    const { fields } = raw.data.content
+
+    return {
+      base: parseValue(fields.base),
+      multiplier: parseValue(fields.multiplier),
+    }
+  }
+
+  #parseReservingFeeModel(raw: any): IReservingFeeModel {
+    const { fields } = raw.data.content
+
+    return {
+      multiplier: parseValue(fields.multiplier),
+    }
+  }
+
+  #parseFundingFeeModel(raw: any): IFundingFeeModel {
+    const { fields } = raw.data.content
+
+    return {
+      multiplier: parseValue(fields.multiplier),
+      max: parseValue(fields.max),
+    }
+  }
+
+  #parsePositionConfig(raw: any): IPositionConfig {
+    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),
+    }
+  }
+
+  async #parsePositionInfo(raw: any, id_: string): Promise<IPositionInfo> {
+    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),
+    }
+
+    positionInfo.reservingFeeAmount = this.#calculatePositionReserveFee(positionInfo, await this.getVaultInfo(positionInfo.collateralToken), (await this.getVaultInfo(positionInfo.collateralToken)).reservingFeeModel, Date.now() / 1000)
+    positionInfo.fundingFeeValue = this.#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)
+
+    return positionInfo
+  }
+
+  #parseOrderInfo(raw: any, capId: string): IOrderInfo {
+    const { content } = raw.data
+    const { fields } = content.fields.value
+
+    // Extract tokens from dataType
+    const dataType = content.type
+
+    const orderType = content.fields.value.type.includes('OpenPositionOrder') ? 'OPEN_POSITION' : 'DECREASE_POSITION'
+
+    const ret: IOrderInfo = {
+      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),
+      indexPrice: parseValue(fields.limited_index_price.fields.price || fields.limited_index_price),
+      collateralPriceThreshold: parseValue(fields.collateral_price_threshold),
+      feeAmount: BigInt(fields.fee),
+      long: dataType.includes('::market::LONG'),
+      orderType,
+      createdAt: parseValue(fields.created_at),
+      v11Order: !fields.limited_index_price.fields.price,
+    }
+
+    if (orderType === 'OPEN_POSITION') {
+      ret.openOrder = {
+        reserveAmount: BigInt(fields.reserve_amount),
+        collateralAmount: BigInt(fields.collateral),
+        openAmount: BigInt(fields.open_amount),
+      }
+    }
+    else {
+      ret.decreaseOrder = {
+        decreaseAmount: BigInt(fields.decrease_amount),
+        takeProfit: fields.take_profit,
+      }
+    }
+
+    return ret
+  }
+
+  #calcRebaseFeeRate(model: IRebaseFeeModel, increase: boolean, ratio: number, targetRatio: number): number {
+    if ((increase && ratio <= targetRatio) || (!increase && ratio >= targetRatio)) {
+      return model.base
+    }
+    return model.base + model.multiplier * Math.abs(ratio - targetRatio)
+  }
+
+  #calcReservingFeeRate(model: IReservingFeeModel, utilization: number, elapsed: number): number {
+    return model.multiplier * utilization * elapsed / SECONDS_PER_EIGHT_HOUR
+  }
+
+  #calcFundingFeeRate(model: IFundingFeeModel, 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
+  }
+
+  #vaultUtilization(vault: IVaultInfo): number {
+    const supplyAmount = vault.liquidity + vault.reservedAmount + vault.unrealisedReservingFeeAmount
+    if (supplyAmount === 0) {
+      return 0
+    }
+    return vault.reservedAmount / supplyAmount
+  }
+
+  #calcAccReservingFeeRate(vault: IVaultInfo, model: IReservingFeeModel, timestamp: number): number {
+    if (vault.lastUpdate > 0) {
+      const elapsed = timestamp - vault.lastUpdate
+      if (elapsed > 0) {
+        const utilization = this.#vaultUtilization(vault)
+        return vault.accReservingRate + this.#calcReservingFeeRate(model, utilization, elapsed)
+      }
+    }
+    return vault.accReservingRate
+  }
+
+  #calcDeltaSize(symbol: ISymbolInfo, price: number): number {
+    const latestSize = symbol.openingAmount / symbol.priceConfig.precision * price
+    return symbol.long ? symbol.openingSize - latestSize : latestSize - symbol.openingSize
+  }
+
+  #calcAccFundingFeeRate(symbol: ISymbolInfo, model: IFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number): number {
+    if (symbol.lastUpdate > 0) {
+      const elapsed = timestamp - symbol.lastUpdate
+      if (elapsed > 0) {
+        const deltaSize = this.#calcDeltaSize(symbol, price)
+        const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount
+        return symbol.accFundingRate + this.#calcFundingFeeRate(model, pnlPerLp, elapsed)
+      }
+    }
+    return symbol.accFundingRate
+  }
+
+  #calculateSymbolFundingFee(symbol: ISymbolInfo, model: IFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number): number {
+    const accFundingRate = this.#calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp)
+    return symbol.unrealisedFundingFeeValue + (accFundingRate - symbol.accFundingRate) * symbol.openingSize
+  }
+
+  #calculatePositionFundingFee(position: IPositionInfo, symbol: ISymbolInfo, model: IFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number): number {
+    const accFundingRate = this.#calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp)
+    return position.fundingFeeValue + (accFundingRate - position.lastFundingRate) * position.positionSize
+  }
+
+  #calculateVaultReservingFee(vault: IVaultInfo, model: IReservingFeeModel, timestamp: number): number {
+    const accReservingRate = this.#calcAccReservingFeeRate(vault, model, timestamp)
+    return vault.unrealisedReservingFeeAmount + (accReservingRate - vault.accReservingRate) * vault.reservedAmount
+  }
+
+  #calculatePositionReserveFee(position: IPositionInfo, vault: IVaultInfo, model: IReservingFeeModel, timestamp: number): number {
+    const accReservingRate = this.#calcAccReservingFeeRate(vault, model, timestamp)
+    return position.reservingFeeAmount + (accReservingRate - position.lastReservingRate) * position.collateralAmount
+  }
+
+  public async getPastFee(days = 7) {
+    // FIXME: Use Sentio data
+    const url = `${this.apiEndpoint}/histories/proxy/fee?days=${days}`
+    const res = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })
+    return Number.parseFloat(await res.text() || '0')
+  }
+
+  public async valuateMarket(): Promise<IMarketValuationInfo> {
+    const marketInfo = await this.getMarketInfo()
+    const days = 7
+    const fee = await this.getPastFee(days)
+    let zlpPrice = 0
+    let value = 0
+
+    const vaultPromises = Object.keys(this.consts.zoCore.vaults).map(async (vault) => {
+      const vaultInfo = await this.getVaultInfo(vault)
+      const reservingFeeDelta = this.#calculateVaultReservingFee(vaultInfo, vaultInfo.reservingFeeModel, Date.now() / 1000)
+      return (reservingFeeDelta + vaultInfo.liquidity + vaultInfo.reservedAmount) * (await this.getOraclePrice(vault)).getPriceUnchecked().getPriceAsNumberUnchecked() / (10 ** this.consts.coins[vault].decimals)
+    })
+
+    const symbolPromises = Object.keys(this.consts.zoCore.symbols).map(async (symbol) => {
+      const [direction, tokenId] = parseSymbolKey(symbol)
+      const symbolInfo = await this.getSymbolInfo(tokenId, direction === 'long')
+      const deltaSize = this.#calcDeltaSize(symbolInfo, (await this.getOraclePrice(tokenId)).getPriceUnchecked().getPriceAsNumberUnchecked())
+      const fundingFeeDelta = this.#calculateSymbolFundingFee(symbolInfo, symbolInfo.fundingFeeModel, (await this.getOraclePrice(tokenId)).getPriceUnchecked().getPriceAsNumberUnchecked(), marketInfo.lpSupplyWithDecimals, Date.now() / 1000)
+      return fundingFeeDelta + deltaSize
+    })
+
+    const [vaultValues, symbolValues] = await Promise.all([Promise.all(vaultPromises), Promise.all(symbolPromises)])
+
+    value = vaultValues.reduce((acc, curr) => acc + curr, 0)
+    value += symbolValues.reduce((acc, curr) => acc + curr, 0)
+
+    zlpPrice = value / marketInfo.lpSupplyWithDecimals
+
+    return {
+      marketCap: value,
+      zlpPrice,
+      zlpSupply: marketInfo.lpSupplyWithDecimals,
+      apr: (fee / value) * 365 / days,
+    }
+  }
+
+  public async getMarketInfo() {
+    this.validateCache()
+    if (this.marketInfoCache) {
+      return this.marketInfoCache
+    }
+    const rawData = await this.provider.getObject({
+      id: this.consts.zoCore.market,
+      options: {
+        showContent: true,
+      },
+    })
+    return this.#parseMarketInfo(rawData)
+  }
+
+  public async getVaultInfo(vaultToken: string) {
+    this.validateCache()
+    if (this.vaultInfoCache[vaultToken]) {
+      return this.vaultInfoCache[vaultToken]
+    }
+
+    const rawData = await this.provider.getDynamicFieldObject({
+      parentId: this.consts.zoCore.vaultsParent,
+      name: {
+        type: `${this.consts.zoCore.package}::market::VaultName<${this.consts.coins[vaultToken].module}>`,
+        value: { dummy_field: false },
+      },
+    })
+    return await this.#parseVaultInfo(rawData)
+  }
+
+  public async getSymbolInfo(indexToken: string, long: boolean) {
+    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.zoCore.symbolsParent,
+      name: {
+        type: `${this.consts.zoCore.package}::market::SymbolName<${this.consts.coins[indexToken].module}, ${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}>`,
+        value: { dummy_field: false },
+      },
+    })
+    return await this.#parseSymbolInfo(rawData, long)
+  }
+
+  public async getPositionConfig(indexToken: string, long: boolean) {
+    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.zoCore.symbols[symbol].positionConfig,
+      options: {
+        showContent: true,
+      },
+    })
+    return this.#parsePositionConfig(rawData)
+  }
+
+  public async getPositionCapInfoList(owner: string): Promise<IPositionCapInfo[]> {
+    const positionCapInfoList: IPositionCapInfo[] = []
+    let cursor: string | undefined | null
+    let hasNextPage = true
+
+    while (hasNextPage) {
+      /* eslint-disable-next-line no-await-in-loop -- pagination requires sequential fetches */
+      const positionCaps = await this.provider.getOwnedObjects({
+        owner,
+        filter: {
+          MoveModule: {
+            package: this.consts.zoCore.package,
+            module: 'market',
+          },
+        },
+        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'),
+          })
+        }
+      }
+
+      // If we don't want to fetch all pages or there are no more pages, break the loop
+      hasNextPage = positionCaps.hasNextPage
+      cursor = positionCaps.nextCursor
+    }
+
+    return positionCapInfoList
+  }
+
+  public async getPositionInfoList(positionCapInfoList: IPositionCapInfo[], owner: string, batchSize = 10) {
+    const positionInfoList: IPositionInfo[] = []
+
+    // Process in batches of 10
+    for (let i = 0; i < positionCapInfoList.length; i += batchSize) {
+      const batch = positionCapInfoList.slice(i, i + batchSize)
+
+      /* eslint-disable-next-line no-await-in-loop -- batch processed in parallel via Promise.all */
+      await Promise.all(batch.map(async (positionCapInfo) => {
+        try {
+          const positionRaw = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.zoCore.positionsParent,
+            name: {
+              type: `${this.consts.zoCore.package}::market::PositionName<${positionCapInfo.symbol0}, ${positionCapInfo.symbol1}, ${this.consts.zoCore.package}::market::${positionCapInfo.long ? 'LONG' : 'SHORT'}>`,
+              value: {
+                owner,
+                id: positionCapInfo.positionCapId,
+              },
+            },
+          })
+          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)
+  }
+
+  // find all open positions by positionsParent
+  public async getOpenPositions(batchSize = 50, symbol = 'sui') {
+    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 }
+        /* eslint-disable-next-line no-await-in-loop -- pagination requires sequential fetches */
+        = await this.provider.getDynamicFields({
+          parentId: this.consts.zoCore.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<([^,\s]+),\s*([^,\s]+),\s*([^>\s]+)>/)
+      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: IPositionInfo[] = []
+
+    // Process in batches of 50 (or specified batchSize)
+    for (let i = 0; i < positionDynamicFields.length; i += batchSize) {
+      const batch = positionDynamicFields.slice(i, i + batchSize)
+
+      /* eslint-disable-next-line no-await-in-loop -- batch processed in parallel via Promise.all */
+      await Promise.all(
+        batch.map(async (positionDynamicField) => {
+          const positionRaw = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.zoCore.positionsParent,
+            name: positionDynamicField.name,
+          })
+
+          if (positionRaw?.data?.content) {
+            // @ts-expect-error -- optional chain on dynamic Move content
+            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 getOrderCapInfoList(owner: string): Promise<IOrderCapInfo[]> {
+    const orderCapInfoList: IOrderCapInfo[] = []
+    let cursor: string | undefined | null
+    let hasNextPage = true
+
+    while (hasNextPage) {
+      /* eslint-disable-next-line no-await-in-loop -- pagination requires sequential fetches */
+      const orderCaps = await this.provider.getOwnedObjects({
+        owner,
+        filter: {
+          MoveModule: {
+            package: this.consts.zoCore.package,
+            module: 'market',
+          },
+        },
+        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 getOrderInfoList(orderCapInfoList: IOrderCapInfo[], owner: string, batchSize = 10) {
+    const orderInfoList: IOrderInfo[] = []
+
+    // Process in batches of 10
+    for (let i = 0; i < orderCapInfoList.length; i += batchSize) {
+      const batch = orderCapInfoList.slice(i, i + batchSize)
+
+      /* eslint-disable-next-line no-await-in-loop -- batch processed in parallel via Promise.all */
+      await Promise.all(batch.map(async (orderCapInfo) => {
+        try {
+          const orderRaw = await this.provider.getDynamicFieldObject({
+            parentId: this.consts.zoCore.ordersParent,
+            name: {
+              // We have enforced collateral coin type to match with fee coin type so we can use symbol0 in the first slot and the last slot of the OrderName
+              type: `${this.consts.zoCore.package}::market::OrderName<${orderCapInfo.symbol0}, ${orderCapInfo.symbol1}, ${this.consts.zoCore.package}::market::${orderCapInfo.long ? 'LONG' : 'SHORT'}, ${orderCapInfo.symbol0}>`,
+              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 getRebaseFeeModel() {
+    this.validateCache()
+    if (this.rebaseFeeModelCache) {
+      return this.rebaseFeeModelCache
+    }
+    const rawData = await this.provider.getObject({
+      id: this.consts.zoCore.rebaseFeeModel,
+      options: {
+        showContent: true,
+      },
+    })
+    return this.#parseRebaseFeeModel(rawData)
+  }
+
+  fundingFeeRate = async (indexToken: string, long: boolean) => {
+    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 = this.#calcDeltaSize(symbol, price)
+    const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount
+    return this.#calcFundingFeeRate(model, pnlPerLp, elapsed)
+  }
+
+  rebaseFeeRate = async (collateralToken: string, increase: boolean, amount: 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.zoCore.vaults).map(async (vault) => {
+      const vaultInfo = await this.getVaultInfo(vault)
+      const reservingFeeDelta = this.#calculateVaultReservingFee(vaultInfo, vaultInfo.reservingFeeModel, Date.now() / 1000)
+      const res = (reservingFeeDelta + vaultInfo.liquidity + vaultInfo.reservedAmount) * (await this.getOraclePrice(vault)).getPriceUnchecked().getPriceAsNumberUnchecked() / (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.zoCore.vaults[collateralToken].weight,
+      10,
+    ) / Object.values(this.consts.zoCore.vaults)
+      .map(e => Number.parseInt(e.weight, 10))
+      .reduce((acc, curr) => acc + curr, 0)
+
+    return this.#calcRebaseFeeRate(
+      await this.getRebaseFeeModel(),
+      increase,
+      (vaultValue + value) / (totalVaultValue + value),
+      targetRatio,
+    )
+  }
+
+  reservingFeeRate = async (collateralToken: string, amount = 0) => {
+    const vaultInfo = await this.getVaultInfo(collateralToken)
+    const vaultSupply = vaultInfo.liquidity + vaultInfo.reservedAmount + vaultInfo.unrealisedReservingFeeAmount + amount
+    const utilization = vaultSupply ? ((vaultInfo.reservedAmount + amount) / vaultSupply) : 0
+    return this.#calcReservingFeeRate(vaultInfo.reservingFeeModel, utilization, SECONDS_PER_EIGHT_HOUR)
+  }
+
+  getProxiedHistories = async (trader: string, page?: number, limit?: number): Promise<IHistory[]> => {
+    const params = new URLSearchParams({ trader })
+    if (page !== undefined) {
+      params.append('page', page.toString())
+    }
+    if (limit !== undefined) {
+      params.append('limit', limit.toString())
+    }
+
+    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
+
+    // Handle both old format (array) and new format (object with data)
+    if (Array.isArray(response)) {
+      return response
+    }
+
+    return response.data?.histories || []
+  }
+
+  getProxiedHistoriesWithPagination = async (
+    trader: string,
+    page = 1,
+    limit = 20,
+    orderType?: string,
+    symbol?: string,
+  ) => {
+    const params = new URLSearchParams({
+      trader,
+      page: page.toString(),
+      limit: limit.toString(),
+    })
+
+    // Add filter parameters if provided
+    if (orderType && orderType !== 'all') {
+      params.append('orderType', orderType)
+    }
+    if (symbol && symbol !== 'all') {
+      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,
+      },
+    }
+  }
+
+  getStaked = async (owner: string): Promise<IStaked> => {
+    const rawCredentials = await this.provider.getOwnedObjects({
+      owner,
+      filter: {
+        MoveModule: {
+          package: this.consts.zoStaking.package,
+          module: 'pool',
+        },
+      },
+      options: {
+        showType: true,
+        showContent: true,
+      },
+    })
+    const pool = await this.getStakePool()
+    const credentials = rawCredentials.data.map((item: any) => this.#parseCredential(item, pool))
+    return {
+      credentials,
+      amount: credentials.reduce((acc: bigint, cur: ICredential) => acc + cur.amount, BigInt(0)),
+      claimable: credentials.reduce((acc: bigint, cur: ICredential) => acc + cur.claimable, BigInt(0)),
+    }
+  }
+
+  getStakePool = async (): Promise<IStakePool> => {
+    const raw = await this.provider.getObject({
+      id: this.consts.zoStaking.pool,
+      options: {
+        showContent: true,
+      },
+    })
+    return this.#parseStakePool(raw)
+  }
+
+  #parseStakePool(raw: any): IStakePool {
+    const content = raw.data.content.fields
+    const pool = {
+      id: content.id.id,
+      enabled: content.enabled,
+      lastUpdatedTime: parseValue(content.last_updated_time),
+      stakedAmount: BigInt(content.staked_amount),
+      reward: BigInt(content.reward),
+      startTime: parseValue(content.start_time),
+      endTime: parseValue(content.end_time),
+      accRewardPerShare: BigInt(content.acc_reward_per_share),
+      lockDuration: parseValue(content.lock_duration),
+    }
+    this.#refreshPool(pool, Math.floor(Date.now() / 1000))
+    return pool
+  }
+
+  #parseCredential(raw: any, pool: IStakePool): ICredential {
+    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),
+    }
+  }
+
+  #refreshPool(pool: IStakePool, 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
+  }
+
+  async getReferralData(referree: string): Promise<any> {
+    const raw = await this.provider.getDynamicFieldObject({
+      parentId: this.consts.zoCore.referralsParent,
+      name: {
+        type: 'address',
+        value: referree,
+      },
+    })
+    return raw
+  }
+
+  async hasReferral(referree: string): Promise<boolean> {
+    const raw = await this.getReferralData(referree)
+    return !raw.error
+  }
+
+  async getReferreeFromReferrer(referrer: string): Promise<any> {
+    const url = new URL(`${this.apiEndpoint}/executions`)
+    const data = {
+      projectId: `${this.network === 'mainnet' ? 'nCBQRfhN' : 'C5iFbF6X'}`,
+      projectSlug: `zo-${this.network}`,
+      projectOwner: 'zo',
+      sqlQuery: {
+        sql: `SELECT referralSender, timestamp from \`Referral_Added\` WHERE  referralReferrer = '${referrer}'`,
+        size: 100,
+      },
+    }
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(data),
+    })
+    return (await res.json()).result.rows.map((e: any) => ({ address: e.referralSender, date: new Date(e.timestamp) }))
+  }
+
+  async getReferreeDetail(referree: string): Promise<any> {
+    const url = new URL(`${this.apiEndpoint}/executions`)
+    const data = {
+      projectId: `${this.network === 'mainnet' ? 'nCBQRfhN' : 'C5iFbF6X'}`,
+      projectSlug: `zo-${this.network}`,
+      projectOwner: 'zo',
+      sqlQuery: {
+        sql: `SELECT sum(volume) as volumeUsd, sum(rebate) as rebateUsd FROM \`User_Interaction\` WHERE  distinct_id = '${referree}' and  rebate != 0`,
+        size: 100,
+      },
+    }
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(data),
+    })
+    const row = (await res.json()).result.rows[0]
+    return {
+      volumeUsd: Number.parseFloat(row.volumeUsd),
+      rebateUsd: Number.parseFloat(row.rebateUsd),
+    }
+  }
+
+  async getReferrerDetail(referrer: string): Promise<any> {
+    const url = new URL(`${this.apiEndpoint}/executions`)
+    const data = {
+      projectId: `${this.network === 'mainnet' ? 'nCBQRfhN' : 'C5iFbF6X'}`,
+      projectSlug: `zo-${this.network}`,
+      projectOwner: 'zo',
+      sqlQuery: {
+        sql: `SELECT sum(volume) as volumeUsd, sum(rebate) as rebateUsd FROM \`User_Interaction\` WHERE  referralReceiver = '${referrer}' and  rebate != 0`,
+        size: 100,
+      },
+    }
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(data),
+    })
+    const row = (await res.json()).result.rows[0]
+    return {
+      volumeUsd: Number.parseFloat(row.volumeUsd),
+      rebateUsd: Number.parseFloat(row.rebateUsd),
+    }
+  }
+
+  async getReferralTxs(referrer: string): Promise<any> {
+    const url = new URL(`${this.apiEndpoint}/executions`)
+    const data = {
+      projectId: `${this.network === 'mainnet' ? 'nCBQRfhN' : 'C5iFbF6X'}`,
+      projectSlug: `zo-${this.network}`,
+      projectOwner: 'zo',
+      sqlQuery: {
+        sql: `SELECT distinct_id, volume, rebate, timestamp, transaction_hash FROM \`User_Interaction\` WHERE  referralReceiver = '${referrer}' and  rebate != 0 order by timestamp desc`,
+        size: 100,
+      },
+    }
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(data),
+    })
+
+    const { rows } = (await res.json()).result
+
+    return rows.map((e: any) => {
+      return {
+        referree: e.distinct_id,
+        volume: Number.parseFloat(e.volume),
+        rebate: Number.parseFloat(e.rebate),
+        date: new Date(e.timestamp),
+        tx: e.transaction_hash,
+      }
+    })
+  }
+}