zo-sdk 0.1.2 → 0.1.3

package/src/implementations/USDZDataAPI.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-await-in-loop */
 /**
  * USDZ DataAPI implementation
  * Implements USDZ-specific data access methods
@@ -6,44 +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, USDZ_TOKEN_DECIMALS, SECONDS_PER_EIGHT_HOUR } from '../consts'
+import { LPToken, SECONDS_PER_EIGHT_HOUR, USDZ_TOKEN_DECIMALS } from '../consts'
 import type {
+  IBaseHistoryResponse,
+  IBaseStaked,
+  IBaseStakePool,
   IUSDZDataAPI,
-  IUSDZMarketValuationInfo,
+  IUSDZFundingFeeModel,
   IUSDZMarketInfo,
-  IUSDZVaultInfo,
-  IUSDZSymbolInfo,
-  IUSDZPositionInfo,
+  IUSDZMarketValuationInfo,
+  IUSDZOrderCapInfo,
   IUSDZOrderInfo,
-  IUSDZFundingFeeModel,
-  IUSDZPositionConfig,
   IUSDZPositionCapInfo,
-  IUSDZReservingFeeModel,
-  IUSDZOrderCapInfo,
+  IUSDZPositionConfig,
+  IUSDZPositionInfo,
   IUSDZRebaseFeeModel,
-  IBaseHistoryResponse,
-  IBaseStaked,
-  IBaseStakePool
+  IUSDZReservingFeeModel,
+  IUSDZSymbolInfo,
+  IUSDZVaultInfo,
 } from '../interfaces'
-import { BaseDataAPI } from '../abstract'
-import { parseSymbolKey, parseValue, suiSymbolToSymbol, joinSymbol } from '../utils'
+import { joinSymbol, parseSymbolKey, parseValue, suiSymbolToSymbol } from '../utils'
 
 export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
   constructor(
     network: Network,
     provider: SuiClient,
     apiEndpoint: string,
-    connectionURL: string
+    connectionURL: string,
   ) {
     super(network, provider, apiEndpoint, connectionURL, LPToken.USDZ)
   }
 
-  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.`)
   }
 
   /**
@@ -133,22 +136,22 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
 
     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 = USDZDataAPI.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 = USDZDataAPI.calcDeltaSize(symbolInfo, (await this.getOraclePrice(tokenId)).getPriceUnchecked().getPriceAsNumberUnchecked())
+      const fundingFeeDelta = USDZDataAPI.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)
 
     usdzPrice = value / marketInfo.lpSupplyWithDecimals
 
@@ -174,7 +177,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
         showContent: true,
       },
     })
-    return this.parseMarketInfo(rawData)
+    return USDZDataAPI.parseMarketInfo(rawData)
   }
 
   /**
@@ -227,12 +230,12 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
         showContent: true,
       },
     })
-    return this.parsePositionConfig(rawData)
+    return USDZDataAPI.parsePositionConfig(rawData)
   }
 
   public async getPositionCapInfoList(owner: string): Promise<IUSDZPositionCapInfo[]> {
     const positionCapInfoList: IUSDZPositionCapInfo[] = []
-    let cursor: string | undefined | null = undefined
+    let cursor: string | undefined | null
     let hasNextPage = true
 
     while (hasNextPage) {
@@ -269,7 +272,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     return positionCapInfoList
   }
 
-  public async getPositionInfoList(positionCapInfoList: IUSDZPositionCapInfo[], owner: string, batchSize: number = 10) {
+  public async getPositionInfoList(positionCapInfoList: IUSDZPositionCapInfo[], owner: string, batchSize = 10) {
     const positionInfoList: IUSDZPositionInfo[] = []
 
     // Process in batches of 10
@@ -289,7 +292,8 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
             },
           })
           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
@@ -303,11 +307,11 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
   public async getOpenPositions(): Promise<IUSDZPositionInfo[]> {
     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,
         })
@@ -320,7 +324,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     // then we query by dynamic field names and order by time
     const positionInfoList: IUSDZPositionInfo[] = []
     await Promise.all(
-      positionDynamicFields.map(async positionDynamicField => {
+      positionDynamicFields.map(async (positionDynamicField) => {
         const positionRaw = await this.provider.getDynamicFieldObject({
           parentId: this.consts.zoCore.positionsParent,
           name: positionDynamicField.name,
@@ -345,7 +349,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
 
   public async getOrderCapInfoList(owner: string): Promise<IUSDZOrderCapInfo[]> {
     const orderCapInfoList: IUSDZOrderCapInfo[] = []
-    let cursor: string | undefined | null = undefined
+    let cursor: string | undefined | null
     let hasNextPage = true
 
     while (hasNextPage) {
@@ -383,7 +387,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     return orderCapInfoList
   }
 
-  public async getOrderInfoList(orderCapInfoList: IUSDZOrderCapInfo[], owner: string, batchSize: number = 10) {
+  public async getOrderInfoList(orderCapInfoList: IUSDZOrderCapInfo[], owner: string, batchSize = 10) {
     const orderInfoList: IUSDZOrderInfo[] = []
 
     // Process in batches of 10
@@ -407,7 +411,8 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
             },
           })
           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
@@ -437,7 +442,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
   /**
    * Gets rebase fee model for USDZ
    */
-  public async getRebaseFeeModel(): Promise<{ base: number; multiplier: number }> {
+  public async getRebaseFeeModel(): Promise<{ base: number, multiplier: number }> {
     this.validateCache()
     if (this.rebaseFeeModelCache) {
       return this.rebaseFeeModelCache
@@ -448,10 +453,10 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
         showContent: true,
       },
     })
-    return this.parseRebaseFeeModel(rawData)
+    return USDZDataAPI.parseRebaseFeeModel(rawData)
   }
 
-  public async fundingFeeRate(indexToken: string, long: boolean,): Promise<number> {
+  public async fundingFeeRate(indexToken: string, long: boolean): Promise<number> {
     const symbol = await this.getSymbolInfo(indexToken, long)
     if (symbol.lastUpdate <= 0) {
       return 0
@@ -461,9 +466,9 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     const model = symbol.fundingFeeModel
     const elapsed = SECONDS_PER_EIGHT_HOUR
 
-    const deltaSize = this.calcDeltaSize(symbol, price)
+    const deltaSize = USDZDataAPI.calcDeltaSize(symbol, price)
     const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount
-    return this.calcFundingFeeRate(model, pnlPerLp, elapsed)
+    return USDZDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed)
   }
 
   public async rebaseFeeRate(collateralToken: string, increase: boolean, amount: number): Promise<number> {
@@ -474,7 +479,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     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 = USDZDataAPI.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
@@ -491,7 +496,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
       .map(e => Number.parseInt(e.weight, 10))
       .reduce((acc, curr) => acc + curr, 0)
 
-    return this.calcRebaseFeeRate(
+    return USDZDataAPI.calcRebaseFeeRate(
       await this.getRebaseFeeModel(),
       increase,
       (vaultValue + value) / (totalVaultValue + value),
@@ -503,7 +508,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     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 USDZDataAPI.calcReservingFeeRate(vaultInfo.reservingFeeModel, utilization, SECONDS_PER_EIGHT_HOUR)
   }
 
   public async getHistory(trader: string, page: number, limit: number, orderType?: string, symbol?: string): Promise<IBaseHistoryResponse> {
@@ -542,53 +547,53 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
   }
 
   // Private helper methods
-  private calcFundingFeeRate(model: IUSDZFundingFeeModel, pnlPerRate: number, elapsed: number): number {
+  private static calcFundingFeeRate(model: IUSDZFundingFeeModel, 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: IUSDZSymbolInfo, model: IUSDZFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number): number {
+  private static calcAccFundingFeeRate(symbol: IUSDZSymbolInfo, model: IUSDZFundingFeeModel, 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 = USDZDataAPI.calcDeltaSize(symbol, price)
         const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount
-        return symbol.accFundingRate + this.calcFundingFeeRate(model, pnlPerLp, elapsed)
+        return symbol.accFundingRate + USDZDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed)
       }
     }
     return symbol.accFundingRate
   }
 
-  private calculateSymbolFundingFee(symbol: IUSDZSymbolInfo, model: IUSDZFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number): number {
-    const accFundingRate = this.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp)
+  private static calculateSymbolFundingFee(symbol: IUSDZSymbolInfo, model: IUSDZFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number): number {
+    const accFundingRate = USDZDataAPI.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp)
     return symbol.unrealisedFundingFeeValue + (accFundingRate - symbol.accFundingRate) * symbol.openingSize
   }
 
-  private calculatePositionReserveFee(position: IUSDZPositionInfo, vault: IUSDZVaultInfo, model: IUSDZReservingFeeModel, timestamp: number): number {
-    const accReservingRate = this.calcAccReservingFeeRate(vault, model, timestamp)
+  private static calculatePositionReserveFee(position: IUSDZPositionInfo, vault: IUSDZVaultInfo, model: IUSDZReservingFeeModel, timestamp: number): number {
+    const accReservingRate = USDZDataAPI.calcAccReservingFeeRate(vault, model, timestamp)
     return position.reservingFeeAmount + (accReservingRate - vault.accReservingRate) * position.collateralAmount
   }
 
-  private calcAccReservingFeeRate(vault: IUSDZVaultInfo, model: IUSDZReservingFeeModel, timestamp: number): number {
+  private static calcAccReservingFeeRate(vault: IUSDZVaultInfo, model: IUSDZReservingFeeModel, 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 = USDZDataAPI.vaultUtilization(vault)
+        return vault.accReservingRate + USDZDataAPI.calcReservingFeeRate(model, utilization, elapsed)
       }
     }
     return vault.accReservingRate
   }
 
-  private calcRebaseFeeRate(model: IUSDZRebaseFeeModel, increase: boolean, ratio: number, targetRatio: number): number {
+  private static calcRebaseFeeRate(model: IUSDZRebaseFeeModel, 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: IUSDZVaultInfo): number {
+  private static vaultUtilization(vault: IUSDZVaultInfo): number {
     const supplyAmount = vault.liquidity + vault.reservedAmount + vault.unrealisedReservingFeeAmount
     if (supplyAmount === 0) {
       return 0
@@ -596,16 +601,16 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     return vault.reservedAmount / supplyAmount
   }
 
-  private calcReservingFeeRate(model: IUSDZReservingFeeModel, utilization: number, elapsed: number): number {
+  private static calcReservingFeeRate(model: IUSDZReservingFeeModel, utilization: number, elapsed: number): number {
     return model.multiplier * utilization * elapsed / SECONDS_PER_EIGHT_HOUR
   }
 
-  private calcDeltaSize(symbol: IUSDZSymbolInfo, price: number): number {
+  private static calcDeltaSize(symbol: IUSDZSymbolInfo, price: number): number {
     const latestSize = symbol.openingAmount / symbol.priceConfig.precision * price
     return symbol.long ? symbol.openingSize - latestSize : latestSize - symbol.openingSize
   }
 
-  private parseMarketInfo(raw: any): IUSDZMarketInfo {
+  private static parseMarketInfo(raw: any): IUSDZMarketInfo {
     const content = raw.data.content.fields
 
     return {
@@ -629,7 +634,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
         showContent: true,
       },
     })
-    const reservingFeeModel = this.parseReservingFeeModel(reservingFeeModelRaw)
+    const reservingFeeModel = USDZDataAPI.parseReservingFeeModel(reservingFeeModelRaw)
 
     return {
       liquidity: parseValue(vaultFields.liquidity),
@@ -660,7 +665,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
         showContent: true,
       },
     })
-    const fundingFeeModel = this.parseFundingFeeModel(fundingFeeModelRaw)
+    const fundingFeeModel = USDZDataAPI.parseFundingFeeModel(fundingFeeModelRaw)
 
     return {
       openingSize: parseValue(fields.opening_size),
@@ -683,7 +688,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     }
   }
 
-  private parsePositionConfig(raw: any): IUSDZPositionConfig {
+  private static parsePositionConfig(raw: any): IUSDZPositionConfig {
     const positionConfigFields = raw.data.content.fields.inner.fields
 
     return {
@@ -723,18 +728,18 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
       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 = USDZDataAPI.calculatePositionReserveFee(positionInfo, await this.getVaultInfo(positionInfo.collateralToken), (await this.getVaultInfo(positionInfo.collateralToken)).reservingFeeModel, Date.now() / 1000)
+    positionInfo.fundingFeeValue = USDZDataAPI.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: IUSDZPositionInfo, symbol: IUSDZSymbolInfo, model: IUSDZFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number): number {
-    const accFundingRate = this.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp)
+  private static calculatePositionFundingFee(position: IUSDZPositionInfo, symbol: IUSDZSymbolInfo, model: IUSDZFundingFeeModel, price: number, lpSupplyAmount: number, timestamp: number): number {
+    const accFundingRate = USDZDataAPI.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp)
     return position.fundingFeeValue + (accFundingRate - symbol.accFundingRate) * 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 {
@@ -743,14 +748,14 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     }
   }
 
-  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),
@@ -813,14 +818,14 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     return Number.parseFloat(await res.text() || '0')
   }
 
-  private calculateVaultReservingFee(
+  private static calculateVaultReservingFee(
     vaultInfo: IUSDZVaultInfo,
     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
   }
-}
+}