@zofai/zo-sdk 0.2.30 → 0.2.31

package/src/implementations/ZLPDataAPI.ts

@@ -307,7 +307,7 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
   public async getMarketInfo(): Promise<IZLPMarketInfo> {
     this.validateCache()
     if (this.marketInfoCache) {
-      return this.marketInfoCache
+      return this.marketInfoCache as IZLPMarketInfo
     }
     const rawData = await this.provider.getObject({
       id: this.consts.zoCore.market,
@@ -315,7 +315,9 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
         showContent: true,
       },
     })
-    return ZLPDataAPI.parseMarketInfo(rawData)
+    const info = ZLPDataAPI.parseMarketInfo(rawData)
+    this.marketInfoCache = info
+    return info
   }
 
   /**
@@ -324,7 +326,7 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
   public async getVaultInfo(vaultToken: string): Promise<IZLPVaultInfo> {
     this.validateCache()
     if (this.vaultInfoCache[vaultToken]) {
-      return this.vaultInfoCache[vaultToken]
+      return this.vaultInfoCache[vaultToken] as IZLPVaultInfo
     }
 
     const rawData = await this.provider.getDynamicFieldObject({
@@ -334,7 +336,9 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
         value: { dummy_field: false },
       },
     })
-    return await this.parseVaultInfo(rawData)
+    const info = await this.parseVaultInfo(rawData)
+    this.vaultInfoCache[vaultToken] = info
+    return info
   }
 
   /**
@@ -344,7 +348,7 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
     this.validateCache()
     const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
     if (this.symbolInfoCache[symbol]) {
-      return this.symbolInfoCache[symbol]
+      return this.symbolInfoCache[symbol] as IZLPSymbolInfo
     }
     const rawData = await this.provider.getDynamicFieldObject({
       parentId: this.consts.zoCore.symbolsParent,
@@ -353,14 +357,16 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
         value: { dummy_field: false },
       },
     })
-    return await this.parseSymbolInfo(rawData, long)
+    const info = await this.parseSymbolInfo(rawData, long)
+    this.symbolInfoCache[symbol] = info
+    return info
   }
 
   public async getPositionConfig(indexToken: string, long: boolean): Promise<IZLPPositionConfig> {
     this.validateCache()
     const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
     if (this.positionConfigCache[symbol]) {
-      return this.positionConfigCache[symbol]
+      return this.positionConfigCache[symbol] as IZLPPositionConfig
     }
     const rawData = await this.provider.getObject({
       id: this.consts.zoCore.symbols[symbol].positionConfig,
@@ -368,7 +374,9 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
         showContent: true,
       },
     })
-    return ZLPDataAPI.parsePositionConfig(rawData)
+    const info = ZLPDataAPI.parsePositionConfig(rawData)
+    this.positionConfigCache[symbol] = info
+    return info
   }
 
   /**
@@ -398,6 +406,9 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
    */
   public async getSymbolOiFundingState(indexToken: string): Promise<IZLPOiFundingState | null> {
     this.validateCache()
+    if (Object.prototype.hasOwnProperty.call(this.oiFundingStateCache, indexToken)) {
+      return this.oiFundingStateCache[indexToken] as IZLPOiFundingState | null
+    }
     try {
       const rawData = await this.provider.getDynamicFieldObject({
         parentId: this.consts.zoCore.market,
@@ -406,11 +417,14 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
           value: { dummy_field: false },
         },
       })
-      return ZLPDataAPI.parseOiFundingState(rawData)
+      const info = ZLPDataAPI.parseOiFundingState(rawData)
+      this.oiFundingStateCache[indexToken] = info
+      return info
     }
     catch (e: any) {
       // If the dynamic field doesn't exist, return null
       console.error('Error Fetching Symbol OI Funding State:', e)
+      this.oiFundingStateCache[indexToken] = null
       return null
     }
   }
@@ -839,7 +853,7 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
   public async getRebaseFeeModel(): Promise<IZLPRebaseFeeModel> {
     this.validateCache()
     if (this.rebaseFeeModelCache) {
-      return this.rebaseFeeModelCache
+      return this.rebaseFeeModelCache as IZLPRebaseFeeModel
     }
     const rawData = await this.provider.getObject({
       id: this.consts.zoCore.rebaseFeeModel,
@@ -853,7 +867,9 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
       this.consts.zoCore.rebaseFeeModel,
       this.consts.zoCore.upgradedPackage,
     )
-    return { ...model, exponent }
+    const info = { ...model, exponent }
+    this.rebaseFeeModelCache = info
+    return info
   }
 
   public async fundingFeeRate(indexToken: string, long: boolean): Promise<number> {
@@ -1246,14 +1262,21 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
       openTimestamp: parseValue(positionFields.open_timestamp),
     }
 
-    positionInfo.reservingFeeAmount = ZLPDataAPI.calculatePositionReserveFee(positionInfo, await this.getVaultInfo(positionInfo.collateralToken), (await this.getVaultInfo(positionInfo.collateralToken)).reservingFeeModel, Date.now() / 1000)
+    const vaultInfo = await this.getVaultInfo(positionInfo.collateralToken)
+    positionInfo.reservingFeeAmount = ZLPDataAPI.calculatePositionReserveFee(
+      positionInfo,
+      vaultInfo,
+      vaultInfo.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)
+    const symbolInfo = await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long)
     const computedFundingFeeValue = ZLPDataAPI.calculatePositionFundingFee(
       positionInfo,
-      await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long),
-      (await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long)).fundingFeeModel,
+      symbolInfo,
+      symbolInfo.fundingFeeModel,
       (await this.getOraclePrice(positionInfo.indexToken)).getPriceUnchecked().getPriceAsNumberUnchecked(),
       (await this.getMarketInfo()).lpSupplyWithDecimals,
       Date.now() / 1000,

package/src/index.ts

@@ -33,6 +33,7 @@ export * from './oraclePro'
 export type { PythProChannel } from './pythProClient'
 export * from './storkClient'
 export * from './storkOracle'
+export * from './traderPositions'
 export * from './utils'
 
 // Re-export commonly used types from Sui SDK

package/src/interfaces/base.ts

@@ -196,6 +196,15 @@ export interface IBasePositionCapInfo {
   long: boolean
 }
 
+export interface IGetTraderOpenPositionsOptions {
+  indexToken?: string
+  collateralToken?: string
+  /** RPC batch size for getPositionInfoList (default 10). */
+  batchSize?: number
+  /** Max OPEN rows to load from the API (default: all pages). */
+  limit?: number
+}
+
 export interface IBaseOrderCapInfo {
   orderCapId: string
   symbol0: string
@@ -291,6 +300,11 @@ export interface IBaseDataAPI {
   // User data methods
   getPositionCapInfoList: (owner: string) => Promise<IBasePositionCapInfo[]>
   getPositionInfoList: (positionCapInfoList: IBasePositionCapInfo[], owner: string, batchSize?: number) => Promise<IBasePositionInfo[]>
+  /**
+   * Fetch OPEN positions from zo API `/trader-positions`, then hydrate live details via RPC.
+   * Skips on-chain PositionCap discovery; uses indexed position ids + symbol metadata.
+   */
+  getTraderOpenPositionInfoList: (owner: string, options?: IGetTraderOpenPositionsOptions) => Promise<IBasePositionInfo[]>
   getOrderCapInfoList: (owner: string) => Promise<IBaseOrderCapInfo[]>
   getOrderInfoList: (orderCapInfoList: IBaseOrderCapInfo[], owner: string, batchSize?: number) => Promise<IBaseOrderInfo[]>
   getHistory: (trader: string, page: number, limit: number, orderType?: string, symbol?: string) => Promise<IBaseHistoryResponse>
@@ -330,7 +344,7 @@ export interface IBaseDataAPI {
 
   resolveStorkAssetsForTokens: (tokens: string[]) => string[]
 
-  fetchStorkUpdateDataForTokens: (tokens: string[]) => Promise<import('../storkClient').IStorkUpdateData[]>
+  fetchStorkUpdateDataForTokens: (tokens: string[]) => Promise<Array<import('../storkClient').IStorkUpdateData>>
 
   estimateStorkUpdateFeeForTokens: (tokens: string[]) => bigint
 

package/src/traderPositions.ts

@@ -0,0 +1,218 @@
+import type { IConsts } from './consts'
+import type { IBasePositionCapInfo } from './interfaces'
+
+export type TraderPositionStatus = 'OPEN' | 'CLOSED' | 'LIQUIDATED' | 'UNKNOWN'
+
+/** Row shape from GET /trader-positions (zo API). */
+export interface ITraderPositionRecord {
+  positionId: string
+  owner: string
+  address: string
+  chain?: string
+  pool?: string | null
+  collateralToken?: string | null
+  indexToken?: string | null
+  direction?: string | null
+  status: TraderPositionStatus
+  closed?: boolean | null
+  openedAt?: string | null
+  closedAt?: string | null
+  updatedAt?: string
+  lastOrderId?: string | null
+  lastEventName?: string | null
+  lastTxDigest?: string | null
+  lastEventSeq?: string | null
+  positionNameType?: string | null
+  openAmount?: string | null
+  decreaseAmount?: string | null
+  collateralAmount?: string | null
+  reserveAmount?: string | null
+  positionSize?: string | null
+  settledAmount?: string | null
+  collateralPrice?: number | null
+  indexPrice?: number | null
+  pnl?: number | null
+}
+
+export interface ITraderPositionsPagination {
+  total: number
+  limit: number
+  offset: number
+}
+
+export interface ITraderPositionsQuery {
+  owner: string
+  status?: TraderPositionStatus
+  indexToken?: string
+  collateralToken?: string
+  limit?: number
+  offset?: number
+}
+
+export interface ITraderPositionsApiResponse {
+  success: boolean
+  data?: {
+    positions: ITraderPositionRecord[]
+    pagination: ITraderPositionsPagination
+  }
+  error?: string
+  message?: string
+}
+
+const DEFAULT_PAGE_LIMIT = 200
+
+/**
+ * Parse `PositionName<collateral, index, LONG|SHORT>` from a Move type string.
+ */
+export function parsePositionNameType(positionNameType: string): {
+  symbol0: string
+  symbol1: string
+  long: boolean
+} | null {
+  const marker = 'PositionName<'
+  const start = positionNameType.indexOf(marker)
+  if (start < 0) {
+    return null
+  }
+  const inner = positionNameType.slice(start + marker.length).split('>')[0]
+  if (!inner) {
+    return null
+  }
+  const parts = inner.split(',').map(part => part.trim())
+  if (parts.length < 3) {
+    return null
+  }
+  return {
+    symbol0: parts[0],
+    symbol1: parts[1],
+    long: parts[2].includes('LONG'),
+  }
+}
+
+function tokenKeyToMoveType(tokenKey: string, consts: IConsts): string | null {
+  const key = tokenKey.toLowerCase()
+  if (key === 'sui') {
+    return '0x2::sui::SUI'
+  }
+  const coin = consts.coins[key]
+  return coin?.module ?? null
+}
+
+/** Map an indexed trader position row to PositionCap lookup fields for on-chain hydration. */
+export function traderPositionToCapInfo(
+  record: ITraderPositionRecord,
+  consts: IConsts,
+): IBasePositionCapInfo | null {
+  if (!record.positionId) {
+    return null
+  }
+
+  const fromType = record.positionNameType
+    ? parsePositionNameType(record.positionNameType)
+    : null
+  if (fromType) {
+    return {
+      positionCapId: record.positionId,
+      symbol0: fromType.symbol0,
+      symbol1: fromType.symbol1,
+      long: fromType.long,
+    }
+  }
+
+  const collateral = record.collateralToken?.trim().toLowerCase()
+  const index = record.indexToken?.trim().toLowerCase()
+  if (!collateral || !index) {
+    return null
+  }
+
+  const symbol0 = tokenKeyToMoveType(collateral, consts)
+  const symbol1 = tokenKeyToMoveType(index, consts)
+  if (!symbol0 || !symbol1) {
+    return null
+  }
+
+  return {
+    positionCapId: record.positionId,
+    symbol0,
+    symbol1,
+    long: (record.direction?.toUpperCase() ?? 'LONG') === 'LONG',
+  }
+}
+
+export async function fetchTraderPositionsPage(
+  apiEndpoint: string,
+  query: ITraderPositionsQuery,
+): Promise<{ positions: ITraderPositionRecord[], pagination: ITraderPositionsPagination }> {
+  if (!apiEndpoint) {
+    throw new Error('apiEndpoint is required to fetch trader positions')
+  }
+
+  const params = new URLSearchParams({
+    owner: query.owner.trim().toLowerCase(),
+  })
+  if (query.status) {
+    params.set('status', query.status)
+  }
+  if (query.indexToken) {
+    params.set('indexToken', query.indexToken.trim().toLowerCase())
+  }
+  if (query.collateralToken) {
+    params.set('collateralToken', query.collateralToken.trim().toLowerCase())
+  }
+  if (query.limit != null) {
+    params.set('limit', String(query.limit))
+  }
+  if (query.offset != null) {
+    params.set('offset', String(query.offset))
+  }
+
+  const url = `${apiEndpoint.replace(/\/$/, '')}/trader-positions?${params}`
+  const res = await fetch(url, {
+    method: 'GET',
+    headers: { 'Content-Type': 'application/json' },
+  })
+
+  const body = await res.json() as ITraderPositionsApiResponse
+  if (!res.ok || !body.success || !body.data) {
+    throw new Error(
+      body.error || body.message || `Failed to fetch trader positions (${res.status})`,
+    )
+  }
+
+  return body.data
+}
+
+/** Fetch all pages matching the query (respects optional total `limit`). */
+export async function fetchAllTraderPositions(
+  apiEndpoint: string,
+  query: Omit<ITraderPositionsQuery, 'limit' | 'offset'>,
+  maxRows?: number,
+): Promise<ITraderPositionRecord[]> {
+  const rows: ITraderPositionRecord[] = []
+  let offset = 0
+  let total = Number.POSITIVE_INFINITY
+
+  while (offset < total) {
+    const remaining = maxRows != null ? maxRows - rows.length : DEFAULT_PAGE_LIMIT
+    if (remaining <= 0) {
+      break
+    }
+
+    const pageLimit = Math.min(DEFAULT_PAGE_LIMIT, remaining)
+    const { positions, pagination } = await fetchTraderPositionsPage(apiEndpoint, {
+      ...query,
+      limit: pageLimit,
+      offset,
+    })
+
+    rows.push(...positions)
+    total = pagination.total
+    offset += positions.length
+
+    if (positions.length === 0 || offset >= total) {
+      break
+    }
+  }
+
+  return maxRows != null ? rows.slice(0, maxRows) : rows
+}