@zofai/zo-sdk 0.2.29 → 0.2.31

package/src/implementations/ZLPDataAPI.ts

@@ -35,6 +35,8 @@ import type {
   IZLPSymbolInfo,
   IZLPVaultInfo,
 } from '../interfaces'
+import type { OracleInputs } from '../oraclePro'
+import { valuateSymbolsV2, valuateVaultsV2 } from '../oraclePro'
 import type { DynamicFieldInfo, SuiClient } from '../suiClient'
 import { joinSymbol, parseSymbolKey, parseValue, suiSymbolToSymbol } from '../utils'
 
@@ -204,6 +206,46 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
     return { vaultsValuation, symbolsValuation }
   }
 
+  /**
+   * Creates vaults valuation using valuate_vault_v2 (Pyth Pro + Stork).
+   */
+  public valuateVaultsV2(tx: Transaction, oracle: OracleInputs) {
+    return valuateVaultsV2({
+      tx,
+      upgradedPackage: this.consts.zoCore.upgradedPackage,
+      lpType: `${this.consts.zoCore.package}::zlp::ZLP`,
+      market: this.consts.zoCore.market,
+      vaults: this.consts.zoCore.vaults,
+      coinModules: this.consts.coins,
+      oracle,
+    })
+  }
+
+  /**
+   * Creates symbols valuation using valuate_symbol_v2 (Pyth Pro + Stork).
+   */
+  public valuateSymbolsV2(tx: Transaction, oracle: OracleInputs) {
+    return valuateSymbolsV2({
+      tx,
+      upgradedPackage: this.consts.zoCore.upgradedPackage,
+      marketPackage: this.consts.zoCore.package,
+      lpType: `${this.consts.zoCore.package}::zlp::ZLP`,
+      market: this.consts.zoCore.market,
+      symbols: this.consts.zoCore.symbols,
+      coinModules: this.consts.coins,
+      oracle,
+    })
+  }
+
+  /**
+   * Creates both vaults and symbols valuation (Pyth Pro + Stork).
+   */
+  public valuateV2(tx: Transaction, oracle: OracleInputs) {
+    const vaultsValuation = this.valuateVaultsV2(tx, oracle)
+    const symbolsValuation = this.valuateSymbolsV2(tx, oracle)
+    return { vaultsValuation, symbolsValuation }
+  }
+
   /**
    * Valuates the ZLP market
    */
@@ -265,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,
@@ -273,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
   }
 
   /**
@@ -282,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({
@@ -292,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
   }
 
   /**
@@ -302,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,
@@ -311,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,
@@ -326,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
   }
 
   /**
@@ -356,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,
@@ -364,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
     }
   }
@@ -797,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,
@@ -811,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> {
@@ -1204,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

@@ -30,8 +30,10 @@ export * from './consts'
 export * from './data'
 export * from './oracle'
 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/interfaces/zlp.ts

@@ -5,6 +5,7 @@
 
 import type { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions'
 
+import type { OracleInputs } from '../oraclePro'
 import type {
   IBaseAPI,
   IBaseCredential,
@@ -139,6 +140,9 @@ export interface IZLPDataAPI extends IBaseDataAPI {
   getSymbolConfig: (indexToken: string, long: boolean) => Promise<IZLPSymbolConfig | null>
   getPriceImpactConfig: (indexToken: string) => Promise<IZLPPriceImpactConfig | null>
   calculateSwapFeeBreakdown: (fromToken: string, toToken: string, fromAmount: number) => Promise<ISwapFeeBreakdown>
+  valuateVaultsV2: (tx: Transaction, oracle: OracleInputs) => TransactionObjectArgument
+  valuateSymbolsV2: (tx: Transaction, oracle: OracleInputs) => TransactionObjectArgument
+  valuateV2: (tx: Transaction, oracle: OracleInputs) => { vaultsValuation: TransactionObjectArgument, symbolsValuation: TransactionObjectArgument }
 }
 
 // ZLP-specific API interface
@@ -262,4 +266,170 @@ export interface IZLPAPI extends IBaseAPI {
     minAmountOut?: number,
     tx?: Transaction,
   ) => Promise<TransactionObjectArgument>
+
+  /** Pyth Pro + Stork swap (transfers output). */
+  swapV3: (
+    fromToken: string,
+    toToken: string,
+    fromAmount: bigint,
+    fromCoinObjects: string[],
+    pythProUpdateBytes: Uint8Array | number[],
+    minAmountOut?: number,
+    tx?: Transaction,
+  ) => Promise<Transaction>
+
+  /** Pyth Pro + Stork swap PTB (returns output coin). */
+  swapV3Ptb: (
+    fromToken: string,
+    toToken: string,
+    fromAmount: bigint,
+    fromCoinObjects: string[],
+    pythProUpdateBytes: Uint8Array | number[],
+    minAmountOut?: number,
+    tx?: Transaction,
+  ) => Promise<TransactionObjectArgument>
+
+  openPositionV3: (
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    collateralAmount: bigint,
+    coinObjects: string[],
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    pythProUpdateBytes: Uint8Array | number[],
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    referralAddress?: string,
+    sender?: string,
+    sponsoredTx?: boolean,
+  ) => Promise<Transaction>
+
+  openPositionWithSCardV3: (
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    collateralAmount: bigint,
+    coinObjects: string[],
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: import('@mysten/kiosk').KioskClient,
+    kioskCap: import('@mysten/kiosk').KioskOwnerCap,
+    scard: string,
+    pythProUpdateBytes: Uint8Array | number[],
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    referralAddress?: string,
+    sender?: string,
+    sponsoredTx?: boolean,
+  ) => Promise<Transaction>
+
+  openPositionWithCoinV3: (
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    coinObj: TransactionObjectArgument,
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    pythProUpdateBytes: Uint8Array | number[],
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    referralAddress?: string,
+    sender?: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+  ) => Promise<Transaction>
+
+  openPositionWithCoinAndSCardV3: (
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    coinObj: TransactionObjectArgument,
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: import('@mysten/kiosk').KioskClient,
+    kioskCap: import('@mysten/kiosk').KioskOwnerCap,
+    scard: string,
+    pythProUpdateBytes: Uint8Array | number[],
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    referralAddress?: string,
+    sender?: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+  ) => Promise<Transaction>
+
+  decreasePositionV3: (
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: bigint,
+    long: boolean,
+    indexPrice: number,
+    collateralPrice: number,
+    pythProUpdateBytes: Uint8Array | number[],
+    isTriggerOrder?: boolean,
+    isTakeProfitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    coinObjects?: string[],
+    sponsoredTx?: boolean,
+    sender?: string,
+  ) => Promise<Transaction>
+
+  decreasePositionWithSCardV3: (
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: bigint,
+    long: boolean,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: import('@mysten/kiosk').KioskClient,
+    kioskCap: import('@mysten/kiosk').KioskOwnerCap,
+    scard: string,
+    pythProUpdateBytes: Uint8Array | number[],
+    isTriggerOrder?: boolean,
+    isTakeProfitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    coinObjects?: string[],
+    sponsoredTx?: boolean,
+    sender?: string,
+  ) => Promise<Transaction>
+
+  /** Pyth Pro path (not legacy feeder v2). */
+  redeemFromPositionV2: (
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: number,
+    long: boolean,
+    pythProUpdateBytes: Uint8Array | number[],
+    tx?: Transaction,
+  ) => Promise<Transaction>
 }

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
+}