zo-sdk 0.1.2 → 0.1.3

package/src/implementations/SLPDataAPI.ts

@@ -1,3 +1,6 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable @stylistic/indent-binary-ops */
+/* eslint-disable @stylistic/indent */
 /**
  * SLP DataAPI implementation
  * Implements SLP-specific data access methods for Sudo SDK
@@ -6,30 +9,31 @@
 import type { DynamicFieldInfo, SuiClient } from '@mysten/sui/client'
 import { Transaction } from '@mysten/sui/transactions'
 import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui/utils'
+
+import { BaseDataAPI } from '../abstract'
+import { Rate, SRate, SymbolsValuation, VaultsValuation } from '../bcs'
 import type { Network } from '../consts'
 import { LPToken, SLP_TOKEN_DECIMALS } from '../consts'
 import type {
+  IBaseHistoryResponse,
+  ISLPCredential,
   ISLPDataAPI,
-  ISLPMarketValuationInfo,
+  ISLPFundingFeeModel,
   ISLPMarketInfo,
-  ISLPVaultInfo,
-  ISLPSymbolInfo,
-  ISLPPositionInfo,
+  ISLPMarketValuationInfo,
+  ISLPOrderCapInfo,
   ISLPOrderInfo,
-  ISLPStakePool,
-  ISLPCredential,
-  IBaseHistoryResponse,
   ISLPPositionCapInfo,
-  ISLPOrderCapInfo,
-  ISLPStaked,
   ISLPPositionConfig,
-  ISLPFundingFeeModel,
+  ISLPPositionInfo,
+  ISLPRebaseFeeModel,
   ISLPReservingFeeModel,
-  ISLPRebaseFeeModel
+  ISLPStaked,
+  ISLPStakePool,
+  ISLPSymbolInfo,
+  ISLPVaultInfo,
 } from '../interfaces'
-import { BaseDataAPI } from '../abstract'
 import { decimalToObject, joinSymbol, parseSymbolKey, parseValue, suiSymbolToSymbol } from '../utils'
-import { Rate, SRate, SymbolsValuation, VaultsValuation } from '../bcs'
 
 export interface GetCumulativeAprResponse {
   generatedAt?: string
@@ -38,14 +42,14 @@ export interface GetCumulativeAprResponse {
 
 let aprResponse: GetCumulativeAprResponse = {}
 
-const SECONDS_PER_EIGHT_HOUR = 8 * 60 * 60; // 28800 seconds
+const SECONDS_PER_EIGHT_HOUR = 8 * 60 * 60 // 28800 seconds
 
 export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
   constructor(
     network: Network,
     provider: SuiClient,
     apiEndpoint: string,
-    connectionURL: string
+    connectionURL: string,
   ) {
     super(network, provider, apiEndpoint, connectionURL, LPToken.SLP)
   }
@@ -61,7 +65,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
         showContent: true,
       },
     })
-    return this.parseRebaseFeeModel(rawData)
+    return SLPDataAPI.parseRebaseFeeModel(rawData)
   }
 
   /**
@@ -178,8 +182,8 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
       sender,
     })
 
-    const symbolsValuationOffset =
-      Object.keys(this.consts.sudoCore.symbols).length + 1
+    const symbolsValuationOffset
+      = Object.keys(this.consts.sudoCore.symbols).length + 1
 
     const vaultsValuation = VaultsValuation.parse(
       new Uint8Array(
@@ -200,11 +204,11 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
       ),
     )
 
-    const result =
-      Number(
-        BigInt(vaultsValuation.value) +
-        BigInt(symbolsValuation.value.value) *
-        BigInt(symbolsValuation.value.is_positive ? 1 : -1),
+    const result
+      = Number(
+        BigInt(vaultsValuation.value)
+        + BigInt(symbolsValuation.value.value)
+        * BigInt(symbolsValuation.value.is_positive ? 1 : -1),
       ) / 1e18
     return result
   }
@@ -231,7 +235,6 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
       ),
     )
 
-
     const result = Number(BigInt(vaultsValuation.value)) / 1e18
     return result
   }
@@ -245,8 +248,8 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     }
 
     const marketInfo = await this.getMarketInfo()
-    let value = await this.simValuateVaults(this.consts.sudoCore.adminCap)
-    let slpPrice = value / marketInfo.lpSupplyWithDecimals
+    const value = await this.simValuateVaults(this.consts.sudoCore.adminCap)
+    const slpPrice = value / marketInfo.lpSupplyWithDecimals
 
     return {
       marketCap: value,
@@ -273,7 +276,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     })
     const apr = await this.getCumulativeApr()
     return {
-      ...this.parseMarketInfo(rawData),
+      ...SLPDataAPI.parseMarketInfo(rawData),
       apr,
     }
   }
@@ -301,10 +304,10 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
    * Gets SLP symbol information
    */
   public async getSymbolInfo(indexToken: string, long: boolean): Promise<ISLPSymbolInfo> {
-    this.validateCache();
-    const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+    this.validateCache()
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
     if (this.symbolInfoCache[symbol]) {
-      return this.symbolInfoCache[symbol];
+      return this.symbolInfoCache[symbol]
     }
 
     const rawData = await this.provider.getDynamicFieldObject({
@@ -322,11 +325,11 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
 
   public async getPositionInfoList(
     positionCapInfoList: ISLPPositionCapInfo[],
-    owner: string
+    owner: string,
   ): Promise<ISLPPositionInfo[]> {
     const positionInfoList: ISLPPositionInfo[] = []
     await Promise.all(
-      positionCapInfoList.map(async positionCapInfo => {
+      positionCapInfoList.map(async (positionCapInfo) => {
         const positionRaw = await this.provider.getDynamicFieldObject({
           parentId: this.consts.sudoCore.positionsParent,
           name: {
@@ -356,7 +359,6 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     )
   }
 
-
   /**
    * Gets user history for SLP
    */
@@ -365,7 +367,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     page: number,
     limit: number,
     orderType?: string,
-    symbol?: string
+    symbol?: string,
   ): Promise<IBaseHistoryResponse> {
     const params = new URLSearchParams({
       trader,
@@ -403,7 +405,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
   public async getStaked(owner: string): Promise<ISLPStaked> {
     let rawCredentialsData: any[] = []
     let queryNextPage = true
-    let queryCursor = undefined
+    let queryCursor
     const limit = 50
 
     while (queryNextPage) {
@@ -425,13 +427,14 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
 
       queryNextPage = hasNextPage
       queryCursor = nextCursor!
-      if (!data) break
+      if (!data)
+        break
       rawCredentialsData = [...rawCredentialsData, ...data]
     }
 
     const pool = await this.getStakePool()
     const credentials = rawCredentialsData.map((item: any) =>
-      this.parseCredential(item, pool),
+      SLPDataAPI.parseCredential(item, pool),
     )
     return {
       credentials,
@@ -453,13 +456,16 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
         showContent: true,
       },
     })
-    return this.parseStakePool(raw)
+    return SLPDataAPI.parseStakePool(raw)
   }
 
-  public async fundingFeeRate(indexToken: string, long: boolean, sender: string): Promise<number> {
+  public async fundingFeeRate(indexToken: string, long: boolean, sender?: string): Promise<number> {
+    if (!sender) {
+      throw new Error('Sender address is required for fundingFeeRate calculation')
+    }
     const tx = await this.initOracleTxb([indexToken])
     const symbol_ = joinSymbol(long ? 'long' : 'short', indexToken)
-    const currentTimestamp = parseInt((+new Date() / 1000).toFixed(0))
+    const currentTimestamp = Number.parseInt((Date.now() / 1000).toFixed(0), 10)
     const symbol = tx.moveCall({
       target: `${this.consts.sudoCore.package}::market::symbol`,
       typeArguments: [
@@ -513,13 +519,16 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     })
 
     const de = SRate.parse(
-      new Uint8Array(res.results[res.results.length - 1].returnValues[0][0]),
+      new Uint8Array(res.results.at(-1).returnValues[0][0]),
     )
 
     return (Number(BigInt(de.value)) / 1e18) * (de.is_positive ? 1 : -1)
   }
 
-  public async rebaseFeeRate(collateralToken: string, increase: boolean, amount: number, sender: string): Promise<number> {
+  public async rebaseFeeRate(collateralToken: string, increase: boolean, amount: number, sender?: string): Promise<number> {
+    if (!sender) {
+      throw new Error('Sender address is required for rebaseFeeRate calculation')
+    }
     const tx1 = await this.initOracleTxb(
       Object.keys(this.consts.pythFeeder.feeder),
     )
@@ -536,9 +545,9 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
         )[1][1],
       ),
     )
-    const singleVaultValue =
-      BigInt(
-        // @ts-ignore
+    const singleVaultValue
+      = BigInt(
+        // @ts-expect-error: vaultsValuation.handled type is not properly defined in BCS schema
         vaultsValuation.handled.find((item: any) =>
           (item.key || '').includes(this.consts.coins[collateralToken].module.slice(2)) || false,
         )?.value.value,
@@ -565,23 +574,27 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
       sender,
     })
     const de = Rate.parse(
-      new Uint8Array(res2.results[res2.results.length - 1].returnValues[0][0]),
+      new Uint8Array(res2.results.at(-1).returnValues[0][0]),
     )
     return Number(BigInt(de)) / 1e18
   }
 
-  public async reservingFeeRate(collateralToken: string, amount: number, sender: string): Promise<number> {
+  public async reservingFeeRate(collateralToken: string, amount: number, sender?: string): Promise<number> {
+    if (!sender) {
+      throw new Error('Sender address is required for reservingFeeRate calculation')
+    }
     const vaultInfo = await this.getVaultInfo(collateralToken)
-    const vaultSupply =
-      vaultInfo.liquidity +
-      vaultInfo.reservedAmount +
-      vaultInfo.unrealisedReservingFeeAmount +
-      amount
+    const vaultSupply
+      = vaultInfo.liquidity
+      + vaultInfo.reservedAmount
+      + vaultInfo.unrealisedReservingFeeAmount
+      + amount
     const utilization = vaultSupply
-      ? parseInt(
+      ? Number.parseInt(
         (((vaultInfo.reservedAmount + amount) / vaultSupply) * 1e18).toFixed(
           0,
         ),
+        10,
       )
       : 0
     const tx = new Transaction()
@@ -600,7 +613,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
       sender,
     })
     const de = Rate.parse(
-      new Uint8Array(res.results[res.results.length - 1].returnValues[0][0]),
+      new Uint8Array(res.results.at(-1).returnValues[0][0]),
     )
     return Number(BigInt(de)) / 1e18
   }
@@ -618,17 +631,17 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
         showContent: true,
       },
     })
-    return this.parsePositionConfig(rawData)
+    return SLPDataAPI.parsePositionConfig(rawData)
   }
 
-  public async getOpenPositions(batchSize: number = 50, symbol: string = 'sui'): Promise<ISLPPositionInfo[]> {
+  public async getOpenPositions(batchSize = 50, symbol = 'sui'): Promise<ISLPPositionInfo[]> {
     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.sudoCore.positionsParent,
           cursor,
         })
@@ -639,22 +652,23 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     }
 
     // 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: ISLPPositionInfo[] = []
@@ -663,14 +677,14 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
       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.sudoCore.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
@@ -693,7 +707,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
   }
 
   public async getPositionCapInfoList(owner: string): Promise<ISLPPositionCapInfo[]> {
-    let cursor: string | undefined | null = undefined
+    let cursor: string | undefined | null
     let hasNextPage = true
     const positionCapInfoList = []
 
@@ -732,7 +746,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
   }
 
   public async getOrderCapInfoList(owner: string): Promise<ISLPOrderCapInfo[]> {
-    let cursor: string | undefined | null = undefined
+    let cursor: string | undefined | null
     let hasNextPage = true
     const orderCapInfoList = []
 
@@ -793,17 +807,17 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
    */
   public async getOrderInfoList(
     orderCapInfoList: ISLPOrderCapInfo[],
-    owner: string
+    owner: string,
   ): Promise<ISLPOrderInfo[]> {
     const orderInfoList: ISLPOrderInfo[] = []
     await Promise.all(
-      orderCapInfoList.map(async orderCapInfo => {
+      orderCapInfoList.map(async (orderCapInfo) => {
         const orderRaw = await this.provider.getDynamicFieldObject({
           parentId: this.consts.sudoCore.ordersParent,
           name: {
             type: `${this.consts.sudoCore.package}::market::OrderName<${orderCapInfo.symbol0
               }, ${orderCapInfo.symbol1}, ${this.consts.sudoCore.package
-              }::market::${orderCapInfo.long ? 'LONG' : 'SHORT'}, ${this.consts.coins['sui'].module
+              }::market::${orderCapInfo.long ? 'LONG' : 'SHORT'}, ${this.consts.coins.sui.module
               }>`,
             value: {
               owner,
@@ -826,9 +840,9 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     const refetchDate = new Date(Date.now() - 3600_000)
     // fetch new every hour
     if (
-      !aprResponse?.generatedAt ||
-      (aprResponse?.generatedAt &&
-        refetchDate > new Date(aprResponse?.generatedAt))
+      !aprResponse?.generatedAt
+      || (aprResponse?.generatedAt
+        && refetchDate > new Date(aprResponse?.generatedAt))
     ) {
       try {
         const url = `${this.apiEndpoint}/cumulativeApr`
@@ -839,72 +853,73 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
           },
         })
         const data = await res.json()
+        // eslint-disable-next-line require-atomic-updates
         aprResponse = { ...data }
         return data.cumulativeApr
-      } catch (e) {
+      }
+      catch {
         console.error('Failed to get cumulative APR')
       }
 
       return 0
-    } else {
-      return aprResponse.apr
     }
+    return aprResponse.apr
   }
 
   // Private helper methods
-  private calculatePositionFundingFee(position: ISLPPositionInfo, symbol: ISLPSymbolInfo, model: ISLPFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number): number {
-    const accFundingRate = this.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, position.long);
-    return position.fundingFeeValue + (accFundingRate - position.lastFundingRate) * position.positionSize;
+  private static calculatePositionFundingFee(position: ISLPPositionInfo, symbol: ISLPSymbolInfo, model: ISLPFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number): number {
+    const accFundingRate = this.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, position.long)
+    return position.fundingFeeValue + (accFundingRate - position.lastFundingRate) * position.positionSize
   }
 
-  private calcAccFundingFeeRate(symbol: ISLPSymbolInfo, model: ISLPFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number, isLong: boolean): number {
+  private static calcAccFundingFeeRate(symbol: ISLPSymbolInfo, model: ISLPFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number, isLong: boolean): number {
     if (symbol.lastUpdate > 0) {
-      const elapsed = timestamp - symbol.lastUpdate;
+      const elapsed = timestamp - symbol.lastUpdate
       if (elapsed > 0) {
-        const deltaSize = this.calcDeltaSize(symbol, price, isLong);
-        const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
-        return symbol.accFundingRate + this.calcFundingFeeRate(model, pnlPerLp, elapsed);
+        const deltaSize = this.calcDeltaSize(symbol, price, isLong)
+        const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount
+        return symbol.accFundingRate + SLPDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed)
       }
     }
-    return symbol.accFundingRate;
+    return symbol.accFundingRate
   }
 
-  private calcDeltaSize(symbol: ISLPSymbolInfo, price: number, isLong: boolean): number {
-    const latestSize = symbol.openingAmount * price;
-    return isLong ? symbol.openingSize - latestSize : latestSize - symbol.openingSize;
+  private static calcDeltaSize(symbol: ISLPSymbolInfo, price: number, isLong: boolean): number {
+    const latestSize = symbol.openingAmount * price
+    return isLong ? symbol.openingSize - latestSize : latestSize - symbol.openingSize
   }
 
-  private calcFundingFeeRate(model: ISLPFundingFeeModel, pnlPerRate: number, elapsed: number): number {
-    const dailyRate = Math.min(model.multiplier * Math.abs(pnlPerRate), model.max);
-    const secondsRate = dailyRate * elapsed / SECONDS_PER_EIGHT_HOUR;
-    return pnlPerRate >= 0 ? -secondsRate : secondsRate;
+  private static calcFundingFeeRate(model: ISLPFundingFeeModel, pnlPerRate: number, elapsed: number): number {
+    const dailyRate = Math.min(model.multiplier * Math.abs(pnlPerRate), model.max)
+    const secondsRate = dailyRate * elapsed / SECONDS_PER_EIGHT_HOUR
+    return pnlPerRate >= 0 ? -secondsRate : secondsRate
   }
 
-  private calculatePositionReserveFee(position: ISLPPositionInfo, vault: ISLPVaultInfo, model: ISLPReservingFeeModel, timestamp: number): number {
-    const accReservingRate = this.calcAccReservingFeeRate(vault, model, timestamp);
-    return position.reservingFeeAmount + (accReservingRate - position.lastReservingRate) * position.collateralAmount;
+  private static calculatePositionReserveFee(position: ISLPPositionInfo, vault: ISLPVaultInfo, model: ISLPReservingFeeModel, timestamp: number): number {
+    const accReservingRate = SLPDataAPI.calcAccReservingFeeRate(vault, model, timestamp)
+    return position.reservingFeeAmount + (accReservingRate - position.lastReservingRate) * position.collateralAmount
   }
 
-  private calcAccReservingFeeRate(vault: ISLPVaultInfo, model: ISLPReservingFeeModel, timestamp: number): number {
+  private static calcAccReservingFeeRate(vault: ISLPVaultInfo, model: ISLPReservingFeeModel, timestamp: number): number {
     if (vault.lastUpdate > 0) {
-      const elapsed = timestamp - vault.lastUpdate;
+      const elapsed = timestamp - vault.lastUpdate
       if (elapsed > 0) {
-        const utilization = this.vaultUtilization(vault);
-        return vault.accReservingRate + this.calcReservingFeeRate(model, utilization, elapsed);
+        const utilization = SLPDataAPI.vaultUtilization(vault)
+        return vault.accReservingRate + SLPDataAPI.calcReservingFeeRate(model, utilization, elapsed)
       }
     }
-    return vault.accReservingRate;
+    return vault.accReservingRate
   }
 
-  private vaultUtilization(vault: ISLPVaultInfo): number {
-    return vault.liquidity > 0 ? vault.reservedAmount / vault.liquidity : 0;
+  private static vaultUtilization(vault: ISLPVaultInfo): number {
+    return vault.liquidity > 0 ? vault.reservedAmount / vault.liquidity : 0
   }
 
-  private calcReservingFeeRate(model: ISLPReservingFeeModel, utilization: number, elapsed: number): number {
+  private static calcReservingFeeRate(model: ISLPReservingFeeModel, utilization: number, elapsed: number): number {
     return model.multiplier * utilization * elapsed / SECONDS_PER_EIGHT_HOUR
   }
 
-  private parsePositionConfig(raw: any): ISLPPositionConfig {
+  private static parsePositionConfig(raw: any): ISLPPositionConfig {
     const positionConfigFields = raw.data.content.fields.inner.fields
 
     return {
@@ -923,7 +938,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     }
   }
 
-  private parseRebaseFeeModel(raw: any): ISLPRebaseFeeModel {
+  private static parseRebaseFeeModel(raw: any): ISLPRebaseFeeModel {
     const { fields } = raw.data.content
 
     return {
@@ -932,7 +947,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     }
   }
 
-  private parseFundingFeeModel(raw: any): ISLPFundingFeeModel {
+  private static parseFundingFeeModel(raw: any): ISLPFundingFeeModel {
     const { fields } = raw.data.content
 
     return {
@@ -941,7 +956,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     }
   }
 
-  private parseMarketInfo(raw: any): ISLPMarketInfo {
+  private static parseMarketInfo(raw: any): ISLPMarketInfo {
     const content = raw.data.content.fields
 
     return {
@@ -963,7 +978,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
         showContent: true,
       },
     })
-    const reservingFeeModel = this.parseReservingFeeModel(reservingFeeModelRaw)
+    const reservingFeeModel = SLPDataAPI.parseReservingFeeModel(reservingFeeModelRaw)
 
     return {
       liquidity: parseValue(vaultFields.liquidity),
@@ -985,7 +1000,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     }
   }
 
-  private parseReservingFeeModel(raw: any): { multiplier: number } {
+  private static parseReservingFeeModel(raw: any): { multiplier: number } {
     const content = raw.data.content.fields
     return {
       multiplier: parseValue(content.multiplier),
@@ -993,7 +1008,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
   }
 
   private async parseSymbolInfo(raw: any, long: boolean): Promise<ISLPSymbolInfo> {
-    const fields = raw.data.content.fields.value.fields
+    const { fields } = raw.data.content.fields.value
     const fundingFeeModelAddr = fields.funding_fee_model
     const fundingFeeModelRaw = await this.provider.getObject({
       id: fundingFeeModelAddr,
@@ -1001,7 +1016,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
         showContent: true,
       },
     })
-    const fundingFeeModel = this.parseFundingFeeModel(fundingFeeModelRaw)
+    const fundingFeeModel = SLPDataAPI.parseFundingFeeModel(fundingFeeModelRaw)
 
     return {
       openingSize: parseValue(fields.opening_size),
@@ -1027,8 +1042,8 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
   }
 
   private async parsePositionInfo(raw: any, id_: string): Promise<ISLPPositionInfo> {
-    const content = raw.data.content
-    const fields = content.fields
+    const { content } = raw.data
+    const { fields } = content
     const positionFields = fields.value.fields
     const dataType = fields.name.type
 
@@ -1036,7 +1051,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
       id: id_,
       long: dataType.includes('::market::LONG'),
       owner: fields.name.fields.owner,
-      version: parseInt(raw.data.version, 10),
+      version: Number.parseInt(raw.data.version, 10),
       collateralToken: suiSymbolToSymbol(
         dataType.split('<')[1].split(',')[0].trim(),
         this.consts,
@@ -1057,21 +1072,22 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
 
     if (!positionFields.closed) {
       try {
-        positionInfo.reservingFeeAmount = this.calculatePositionReserveFee(
+        positionInfo.reservingFeeAmount = SLPDataAPI.calculatePositionReserveFee(
           positionInfo,
           await this.getVaultInfo(positionInfo.collateralToken),
           (await this.getVaultInfo(positionInfo.collateralToken)).reservingFeeModel,
-          Date.now() / 1000
+          Date.now() / 1000,
         )
-        positionInfo.fundingFeeValue = this.calculatePositionFundingFee(
+        positionInfo.fundingFeeValue = SLPDataAPI.calculatePositionFundingFee(
           positionInfo,
           await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long),
           (await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long)).fundingFeeModel,
           (await this.getOraclePrice(positionInfo.indexToken)).getPriceUnchecked().getPriceAsNumberUnchecked(),
           (await this.getMarketInfo()).lpSupplyWithDecimals,
-          Date.now() / 1000
+          Date.now() / 1000,
         )
-      } catch (e) {
+      }
+      catch (e) {
         console.error(e)
         positionInfo.reservingFeeAmount = 0
         positionInfo.fundingFeeValue = 0
@@ -1082,17 +1098,17 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
   }
 
   private parseOrderInfo(raw: any, capId: string): ISLPOrderInfo {
-    let content = raw.data.content
-    let fields = content.fields.value.fields
+    const { content } = raw.data
+    const { fields } = content.fields.value
 
     // Extract tokens from dataType
-    let dataType = content.type
+    const dataType = content.type
 
     const orderType = content.fields.value.type.includes('OpenPositionOrder')
       ? 'OPEN_POSITION'
       : 'DECREASE_POSITION'
 
-    let ret: ISLPOrderInfo = {
+    const ret: ISLPOrderInfo = {
       id: content.fields.id.id,
       capId,
       executed: fields.executed,
@@ -1120,7 +1136,8 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
         collateralAmount: BigInt(fields.collateral),
         openAmount: BigInt(fields.open_amount),
       }
-    } else {
+    }
+    else {
       ret.decreaseOrder = {
         decreaseAmount: BigInt(fields.decrease_amount),
         takeProfit: fields.take_profit,
@@ -1130,7 +1147,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     return ret
   }
 
-  private parseCredential(raw: any, pool: ISLPStakePool): ISLPCredential {
+  private static parseCredential(raw: any, pool: ISLPStakePool): ISLPCredential {
     const stakedAmount = BigInt(raw.data.content.fields.stake)
     const accRewardPerShare = BigInt(
       raw.data.content.fields.acc_reward_per_share,
@@ -1141,12 +1158,12 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
       amount: stakedAmount,
       accRewardPerShare,
       claimable:
-        ((pool.accRewardPerShare - accRewardPerShare) * stakedAmount) /
-        BigInt(1e18),
+        ((pool.accRewardPerShare - accRewardPerShare) * stakedAmount)
+        / BigInt(1e18),
     }
   }
 
-  private parseStakePool(raw: any): ISLPStakePool {
+  private static parseStakePool(raw: any): ISLPStakePool {
     const content = raw.data.content.fields
     const pool = {
       id: content.id.id,
@@ -1159,17 +1176,17 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
       accRewardPerShare: BigInt(content.acc_reward_per_share),
       lockDuration: parseValue(content.lock_duration),
     }
-    this.refreshPool(pool, Math.floor(Date.now() / 1000))
+    SLPDataAPI.refreshPool(pool, Math.floor(Date.now() / 1000))
     return pool
   }
 
-  private refreshPool(pool: ISLPStakePool, timestamp: number): void {
+  private static refreshPool(pool: ISLPStakePool, timestamp: number): void {
     if (timestamp === pool.lastUpdatedTime || timestamp < pool.startTime) {
       return
     }
     if (
-      pool.lastUpdatedTime === pool.endTime ||
-      pool.stakedAmount === BigInt(0)
+      pool.lastUpdatedTime === pool.endTime
+      || pool.stakedAmount === BigInt(0)
     ) {
       return
     }
@@ -1177,12 +1194,12 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
       timestamp = pool.endTime
     }
 
-    const rewardAmount =
-      (pool.reward * BigInt(timestamp - pool.lastUpdatedTime)) /
-      BigInt(pool.endTime - pool.lastUpdatedTime)
+    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
   }
-}
+}