zo-sdk 0.1.2 → 0.1.4

package/src/implementations/ZLPDataAPI.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-await-in-loop */
 /**
  * ZLP DataAPI implementation
  * Implements ZLP-specific data access methods
@@ -6,45 +7,46 @@
 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 { BaseDataAPI } from '../abstract'
 import type { Network } from '../consts'
-import { LPToken, ZLP_TOKEN_DECIMALS, SECONDS_PER_EIGHT_HOUR } from '../consts'
+import { LPToken, SECONDS_PER_EIGHT_HOUR, ZLP_TOKEN_DECIMALS } from '../consts'
 import type {
+  IBaseHistoryResponse,
+  IBaseStaked,
+  IBaseStakePool,
   IZLPDataAPI,
-  IZLPMarketValuationInfo,
+  IZLPFundingFeeModel,
   IZLPMarketInfo,
-  IZLPVaultInfo,
-  IZLPSymbolInfo,
-  IZLPPositionInfo,
+  IZLPMarketValuationInfo,
+  IZLPOrderCapInfo,
   IZLPOrderInfo,
-  IZLPFundingFeeModel,
-  IZLPPositionConfig,
   IZLPPositionCapInfo,
-  IZLPReservingFeeModel,
-  IZLPOrderCapInfo,
+  IZLPPositionConfig,
+  IZLPPositionInfo,
   IZLPRebaseFeeModel,
-  IBaseHistoryResponse,
-  IBaseStaked,
-  IBaseStakePool
+  IZLPReservingFeeModel,
+  IZLPSymbolInfo,
+  IZLPVaultInfo,
 } from '../interfaces'
-import { BaseDataAPI } from '../abstract'
-import { parseSymbolKey, parseValue, suiSymbolToSymbol, joinSymbol } from '../utils'
+import { joinSymbol, parseSymbolKey, parseValue, suiSymbolToSymbol } from '../utils'
 
 export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
   constructor(
     network: Network,
     provider: SuiClient,
     apiEndpoint: string,
-    connectionURL: string
+    connectionURL: string,
   ) {
     super(network, provider, apiEndpoint, connectionURL, LPToken.ZLP)
   }
 
-  public getStaked(owner: string): Promise<IBaseStaked> {
-    throw new Error('Method not implemented.')
+  public getStaked(_owner: string): Promise<IBaseStaked> {
+    throw new Error(`${this.constructor.name}: Method not implemented.`)
   }
 
   public getStakePool(): Promise<IBaseStakePool> {
-    throw new Error('Method not implemented.')
+    throw new Error(`${this.constructor.name}: Method not implemented.`)
   }
 
   /**
@@ -134,22 +136,22 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
 
     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 reservingFeeDelta = ZLPDataAPI.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)
+      const deltaSize = ZLPDataAPI.calcDeltaSize(symbolInfo, (await this.getOraclePrice(tokenId)).getPriceUnchecked().getPriceAsNumberUnchecked())
+      const fundingFeeDelta = ZLPDataAPI.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)
+    value = vaultValues.reduce((acc: number, curr: number) => acc + curr, 0)
+    value += symbolValues.reduce((acc: number, curr: number) => acc + curr, 0)
 
     zlpPrice = value / marketInfo.lpSupplyWithDecimals
 
@@ -175,7 +177,7 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
         showContent: true,
       },
     })
-    return this.parseMarketInfo(rawData)
+    return ZLPDataAPI.parseMarketInfo(rawData)
   }
 
   /**
@@ -228,12 +230,12 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
         showContent: true,
       },
     })
-    return this.parsePositionConfig(rawData)
+    return ZLPDataAPI.parsePositionConfig(rawData)
   }
 
   public async getPositionCapInfoList(owner: string): Promise<IZLPPositionCapInfo[]> {
     const positionCapInfoList: IZLPPositionCapInfo[] = []
-    let cursor: string | undefined | null = undefined
+    let cursor: string | undefined | null
     let hasNextPage = true
 
     while (hasNextPage) {
@@ -270,7 +272,7 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
     return positionCapInfoList
   }
 
-  public async getPositionInfoList(positionCapInfoList: IZLPPositionCapInfo[], owner: string, batchSize: number = 10) {
+  public async getPositionInfoList(positionCapInfoList: IZLPPositionCapInfo[], owner: string, batchSize = 10) {
     const positionInfoList: IZLPPositionInfo[] = []
 
     // Process in batches of 10
@@ -290,7 +292,8 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
             },
           })
           positionInfoList.push(await this.parsePositionInfo(positionRaw, positionCapInfo.positionCapId))
-        } catch (error) {
+        }
+        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
@@ -301,14 +304,14 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
     return positionInfoList.sort((a, b) => a.openTimestamp > b.openTimestamp ? 1 : -1)
   }
 
-  public async getOpenPositions(batchSize: number = 50, symbol: string = 'sui'): Promise<IZLPPositionInfo[]> {
+  public async getOpenPositions(batchSize = 50, symbol = 'sui'): Promise<IZLPPositionInfo[]> {
     let positionDynamicFields: DynamicFieldInfo[] = []
     let _continue = true
-    let cursor = undefined
+    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({
+      const { data, nextCursor, hasNextPage }
+        = await this.provider.getDynamicFields({
           parentId: this.consts.zoCore.positionsParent,
           cursor,
         })
@@ -319,22 +322,23 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
     }
 
     // Filter by symbol if provided
-    if (symbol && this.consts.coins[symbol]) {
-      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*([^>]+)>/)
-        if (!match) return false
-
-        const secondCoin = match[2].trim()
-        return secondCoin === coinModule
-      })
-    } else {
+    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: IZLPPositionInfo[] = []
@@ -344,14 +348,14 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
       const batch = positionDynamicFields.slice(i, i + batchSize)
 
       await Promise.all(
-        batch.map(async positionDynamicField => {
+        batch.map(async (positionDynamicField) => {
           const positionRaw = await this.provider.getDynamicFieldObject({
             parentId: this.consts.zoCore.positionsParent,
             name: positionDynamicField.name,
           })
 
           if (positionRaw?.data?.content) {
-            // @ts-ignore
+            // @ts-expect-error: content fields type is not properly defined
             if (positionRaw?.data?.content?.fields?.value?.fields?.closed) {
               // skip closed positions
               return
@@ -375,7 +379,7 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
 
   public async getOrderCapInfoList(owner: string): Promise<IZLPOrderCapInfo[]> {
     const orderCapInfoList: IZLPOrderCapInfo[] = []
-    let cursor: string | undefined | null = undefined
+    let cursor: string | undefined | null
     let hasNextPage = true
 
     while (hasNextPage) {
@@ -413,7 +417,7 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
     return orderCapInfoList
   }
 
-  public async getOrderInfoList(orderCapInfoList: IZLPOrderCapInfo[], owner: string, batchSize: number = 10) {
+  public async getOrderInfoList(orderCapInfoList: IZLPOrderCapInfo[], owner: string, batchSize = 10) {
     const orderInfoList: IZLPOrderInfo[] = []
 
     // Process in batches of 10
@@ -437,7 +441,8 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
             },
           })
           orderInfoList.push(this.parseOrderInfo(orderRaw, orderCapInfo.orderCapId))
-        } catch (error) {
+        }
+        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
@@ -478,7 +483,7 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
         showContent: true,
       },
     })
-    return this.parseRebaseFeeModel(rawData)
+    return ZLPDataAPI.parseRebaseFeeModel(rawData)
   }
 
   public async fundingFeeRate(indexToken: string, long: boolean): Promise<number> {
@@ -491,9 +496,9 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
     const model = symbol.fundingFeeModel
     const elapsed = SECONDS_PER_EIGHT_HOUR
 
-    const deltaSize = this.calcDeltaSize(symbol, price)
+    const deltaSize = ZLPDataAPI.calcDeltaSize(symbol, price)
     const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount
-    return this.calcFundingFeeRate(model, pnlPerLp, elapsed)
+    return ZLPDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed)
   }
 
   public async rebaseFeeRate(collateralToken: string, increase: boolean, amount: number): Promise<number> {
@@ -504,7 +509,7 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
     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 reservingFeeDelta = ZLPDataAPI.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
@@ -521,7 +526,7 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
       .map(e => Number.parseInt(e.weight, 10))
       .reduce((acc, curr) => acc + curr, 0)
 
-    return this.calcRebaseFeeRate(
+    return ZLPDataAPI.calcRebaseFeeRate(
       await this.getRebaseFeeModel(),
       increase,
       (vaultValue + value) / (totalVaultValue + value),
@@ -533,7 +538,7 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
     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)
+    return ZLPDataAPI.calcReservingFeeRate(vaultInfo.reservingFeeModel, utilization, SECONDS_PER_EIGHT_HOUR)
   }
 
   public async getHistory(trader: string, page: number, limit: number, orderType?: string, symbol?: string): Promise<IBaseHistoryResponse> {
@@ -572,53 +577,53 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
   }
 
   // Private helper methods
-  private calcFundingFeeRate(model: IZLPFundingFeeModel, pnlPerRate: number, elapsed: number): number {
+  private static calcFundingFeeRate(model: IZLPFundingFeeModel, 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 calcAccFundingFeeRate(symbol: IZLPSymbolInfo, model: IZLPFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number): number {
+  private static calcAccFundingFeeRate(symbol: IZLPSymbolInfo, model: IZLPFundingFeeModel, 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 deltaSize = ZLPDataAPI.calcDeltaSize(symbol, price)
         const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount
-        return symbol.accFundingRate + this.calcFundingFeeRate(model, pnlPerLp, elapsed)
+        return symbol.accFundingRate + ZLPDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed)
       }
     }
     return symbol.accFundingRate
   }
 
-  private calculateSymbolFundingFee(symbol: IZLPSymbolInfo, model: IZLPFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number): number {
-    const accFundingRate = this.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp)
+  private static calculateSymbolFundingFee(symbol: IZLPSymbolInfo, model: IZLPFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number): number {
+    const accFundingRate = ZLPDataAPI.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp)
     return symbol.unrealisedFundingFeeValue + (accFundingRate - symbol.accFundingRate) * symbol.openingSize
   }
 
-  private calculatePositionReserveFee(position: IZLPPositionInfo, vault: IZLPVaultInfo, model: IZLPReservingFeeModel, timestamp: number): number {
-    const accReservingRate = this.calcAccReservingFeeRate(vault, model, timestamp)
+  private static calculatePositionReserveFee(position: IZLPPositionInfo, vault: IZLPVaultInfo, model: IZLPReservingFeeModel, timestamp: number): number {
+    const accReservingRate = ZLPDataAPI.calcAccReservingFeeRate(vault, model, timestamp)
     return position.reservingFeeAmount + (accReservingRate - position.lastReservingRate) * position.collateralAmount
   }
 
-  private calcAccReservingFeeRate(vault: IZLPVaultInfo, model: IZLPReservingFeeModel, timestamp: number): number {
+  private static calcAccReservingFeeRate(vault: IZLPVaultInfo, model: IZLPReservingFeeModel, 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)
+        const utilization = ZLPDataAPI.vaultUtilization(vault)
+        return vault.accReservingRate + ZLPDataAPI.calcReservingFeeRate(model, utilization, elapsed)
       }
     }
     return vault.accReservingRate
   }
 
-  private calcRebaseFeeRate(model: IZLPRebaseFeeModel, increase: boolean, ratio: number, targetRatio: number): number {
+  private static calcRebaseFeeRate(model: IZLPRebaseFeeModel, 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)
   }
 
-  private vaultUtilization(vault: IZLPVaultInfo): number {
+  private static vaultUtilization(vault: IZLPVaultInfo): number {
     const supplyAmount = vault.liquidity + vault.reservedAmount + vault.unrealisedReservingFeeAmount
     if (supplyAmount === 0) {
       return 0
@@ -626,16 +631,16 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
     return vault.reservedAmount / supplyAmount
   }
 
-  private calcReservingFeeRate(model: IZLPReservingFeeModel, utilization: number, elapsed: number): number {
+  private static calcReservingFeeRate(model: IZLPReservingFeeModel, utilization: number, elapsed: number): number {
     return model.multiplier * utilization * elapsed / SECONDS_PER_EIGHT_HOUR
   }
 
-  private calcDeltaSize(symbol: IZLPSymbolInfo, price: number): number {
+  private static calcDeltaSize(symbol: IZLPSymbolInfo, price: number): number {
     const latestSize = symbol.openingAmount / symbol.priceConfig.precision * price
     return symbol.long ? symbol.openingSize - latestSize : latestSize - symbol.openingSize
   }
 
-  private parseMarketInfo(raw: any): IZLPMarketInfo {
+  private static parseMarketInfo(raw: any): IZLPMarketInfo {
     const content = raw.data.content.fields
 
     return {
@@ -659,7 +664,7 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
         showContent: true,
       },
     })
-    const reservingFeeModel = this.parseReservingFeeModel(reservingFeeModelRaw)
+    const reservingFeeModel = ZLPDataAPI.parseReservingFeeModel(reservingFeeModelRaw)
 
     return {
       liquidity: parseValue(vaultFields.liquidity),
@@ -690,7 +695,7 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
         showContent: true,
       },
     })
-    const fundingFeeModel = this.parseFundingFeeModel(fundingFeeModelRaw)
+    const fundingFeeModel = ZLPDataAPI.parseFundingFeeModel(fundingFeeModelRaw)
 
     return {
       openingSize: parseValue(fields.opening_size),
@@ -713,7 +718,7 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
     }
   }
 
-  private parsePositionConfig(raw: any): IZLPPositionConfig {
+  private static parsePositionConfig(raw: any): IZLPPositionConfig {
     const positionConfigFields = raw.data.content.fields.inner.fields
 
     return {
@@ -753,18 +758,18 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
       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)
+    positionInfo.reservingFeeAmount = ZLPDataAPI.calculatePositionReserveFee(positionInfo, await this.getVaultInfo(positionInfo.collateralToken), (await this.getVaultInfo(positionInfo.collateralToken)).reservingFeeModel, Date.now() / 1000)
+    positionInfo.fundingFeeValue = ZLPDataAPI.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
   }
 
-  private calculatePositionFundingFee(position: IZLPPositionInfo, symbol: IZLPSymbolInfo, model: IZLPFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number): number {
-    const accFundingRate = this.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp)
+  private static calculatePositionFundingFee(position: IZLPPositionInfo, symbol: IZLPSymbolInfo, model: IZLPFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number): number {
+    const accFundingRate = ZLPDataAPI.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp)
     return position.fundingFeeValue + (accFundingRate - position.lastFundingRate) * position.positionSize
   }
 
-  private parseRebaseFeeModel(raw: any): { base: number; multiplier: number } {
+  private static parseRebaseFeeModel(raw: any): { base: number, multiplier: number } {
     const { fields } = raw.data.content
 
     return {
@@ -773,14 +778,14 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
     }
   }
 
-  private parseReservingFeeModel(raw: any): { multiplier: number } {
+  private static parseReservingFeeModel(raw: any): { multiplier: number } {
     const content = raw.data.content.fields
     return {
       multiplier: parseValue(content.multiplier),
     }
   }
 
-  private parseFundingFeeModel(raw: any): { multiplier: number; max: number } {
+  private static parseFundingFeeModel(raw: any): { multiplier: number, max: number } {
     const content = raw.data.content.fields
     return {
       multiplier: parseValue(content.multiplier),
@@ -843,14 +848,14 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
     return Number.parseFloat(await res.text() || '0')
   }
 
-  private calculateVaultReservingFee(
+  private static calculateVaultReservingFee(
     vaultInfo: IZLPVaultInfo,
     reservingFeeModel: { multiplier: number },
-    currentTime: 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
+    return vaultInfo.unrealisedReservingFeeAmount
+      + (vaultInfo.reservedAmount * reservingFeeModel.multiplier * periods) / 1e18
   }
-}
+}

package/src/implementations/index.ts

@@ -4,11 +4,11 @@
  */
 
 // Data API implementations
-export { ZLPDataAPI } from './ZLPDataAPI'
 export { SLPDataAPI } from './SLPDataAPI'
 export { USDZDataAPI } from './USDZDataAPI'
+export { ZLPDataAPI } from './ZLPDataAPI'
 
 // API implementations
-export { ZLPAPI } from './ZLPAPI'
 export { SLPAPI } from './SLPAPI'
-export { USDZAPI } from './USDZAPI'
+export { USDZAPI } from './USDZAPI'
+export { ZLPAPI } from './ZLPAPI'

package/src/index.ts

@@ -1,20 +1,25 @@
 /**
  * ZO SDK - Re-architected Multi-LP Token SDK
- * 
+ *
  * This SDK provides a unified interface for interacting with multiple LP tokens:
  * - ZLP (ZO Liquidity Provider)
- * - SLP (Sudo Liquidity Provider) 
+ * - SLP (Sudo Liquidity Provider)
  * - USDZ (USD Stablecoin)
- * 
+ *
  * The architecture follows a common interface pattern with specific implementations
  * for each LP token type, allowing for easy extension to support future LP tokens.
  */
 
 // Export new re-architected interfaces and implementations
-export * from './interfaces'
+/**
+ * Default SDK instance for backward compatibility and convenience
+ */
+import { SDKFactory } from './factory/SDKFactory'
+
 export * from './abstract'
-export * from './implementations'
 export * from './factory/SDKFactory'
+export * from './implementations'
+export * from './interfaces'
 
 // Export legacy components for backward compatibility
 export * from './api'
@@ -30,29 +35,24 @@ export type { Transaction } from '@mysten/sui/transactions'
 
 /**
  * Main SDK Factory instance for convenient access
- * 
+ *
  * Usage examples:
- * 
+ *
  * ```typescript
  * import { SDK, LPToken } from '@zo/sdk'
- * 
+ *
  * // Create ZLP API instance
  * const zlpAPI = SDK.createZLPAPI(network, provider, apiEndpoint, connectionURL)
- * 
- * // Create SLP API instance  
+ *
+ * // Create SLP API instance
  * const slpAPI = SDK.createSLPAPI(network, provider, apiEndpoint, connectionURL)
- * 
+ *
  * // Create USDZ API instance
  * const usdzAPI = SDK.createUSDZAPI(network, provider, apiEndpoint, connectionURL)
- * 
+ *
  * // Or use the generic factory method
  * const api = SDK.createAPI(LPToken.ZLP, network, provider, apiEndpoint, connectionURL)
  * ```
  */
 export { SDKFactory as SDK } from './factory/SDKFactory'
-
-/**
- * Default SDK instance for backward compatibility and convenience
- */
-import { SDKFactory } from './factory/SDKFactory'
 export const defaultSDK = SDKFactory.getInstance()