@zofai/zo-sdk 0.1.92

package/src/abstract/BaseDataAPI.ts

@@ -0,0 +1,207 @@
+/**
+ * Abstract base class for all DataAPI implementations
+ * Provides common functionality and enforces interface contracts
+ */
+/* eslint-disable class-methods-use-this -- base class helpers used by subclasses */
+
+import type { SuiClient } from '@mysten/sui/client'
+import type { Transaction } from '@mysten/sui/transactions'
+
+import type { LPToken, Network } from '../consts'
+import type {
+  IBaseDataAPI,
+  IBaseHistoryResponse,
+  IBaseMarketInfo,
+  IBaseMarketValuationInfo,
+  IBaseOrderCapInfo,
+  IBaseOrderInfo,
+  IBasePositionCapInfo,
+  IBasePositionConfig,
+  IBasePositionInfo,
+  IBaseRebaseFeeModel,
+  IBaseStaked,
+  IBaseStakePool,
+  IBaseSymbolInfo,
+  IBaseVaultInfo,
+} from '../interfaces'
+import { OracleAPI } from '../oracle'
+
+export abstract class BaseDataAPI extends OracleAPI implements IBaseDataAPI {
+  public readonly provider: SuiClient
+  public readonly apiEndpoint: string
+  public readonly connectionURL: string
+  public readonly lpToken: LPToken
+
+  // Cache management
+  protected vaultInfoCache: Record<string, IBaseVaultInfo> = {}
+  protected symbolInfoCache: Record<string, IBaseSymbolInfo> = {}
+  protected marketInfoCache: IBaseMarketInfo | null = null
+  protected positionConfigCache: Record<string, IBasePositionConfig> = {}
+  protected rebaseFeeModelCache: IBaseRebaseFeeModel | null = null
+  protected lastUpdate = 0
+  protected readonly CACHE_DURATION = 1000 * 60 * 3 // 3 minutes
+
+  constructor(
+    network: Network,
+    provider: SuiClient,
+    apiEndpoint: string,
+    connectionURL: string,
+    lpToken: LPToken,
+  ) {
+    super(network, provider, connectionURL, lpToken)
+    this.provider = provider
+    this.apiEndpoint = apiEndpoint
+    this.connectionURL = connectionURL
+    this.lpToken = lpToken
+  }
+
+  /**
+   * Validates and clears cache if expired
+   */
+  public validateCache(): void {
+    super.validateCache()
+    if (this.lastUpdate + this.CACHE_DURATION < Date.now()) {
+      this.clearCache()
+    }
+  }
+
+  /**
+   * Clears all cached data
+   */
+  protected clearCache(): void {
+    this.lastUpdate = Date.now()
+    this.vaultInfoCache = {}
+    this.symbolInfoCache = {}
+    this.marketInfoCache = null
+    this.positionConfigCache = {}
+    this.rebaseFeeModelCache = null
+  }
+
+  /**
+   * Gets cached vault info or fetches if not cached
+   */
+  protected async getCachedVaultInfo(vault: string): Promise<IBaseVaultInfo> {
+    this.validateCache()
+    if (!this.vaultInfoCache[vault]) {
+      this.vaultInfoCache[vault] = await this.getVaultInfo(vault)
+    }
+    return this.vaultInfoCache[vault]
+  }
+
+  /**
+   * Gets cached symbol info or fetches if not cached
+   */
+  protected async getCachedSymbolInfo(tokenId: string, long: boolean): Promise<IBaseSymbolInfo> {
+    this.validateCache()
+    const key = `${tokenId}_${long}`
+    if (!this.symbolInfoCache[key]) {
+      this.symbolInfoCache[key] = await this.getSymbolInfo(tokenId, long)
+    }
+    return this.symbolInfoCache[key]
+  }
+
+  /**
+   * Gets cached market info or fetches if not cached
+   */
+  protected async getCachedMarketInfo(): Promise<IBaseMarketInfo> {
+    this.validateCache()
+    if (!this.marketInfoCache) {
+      this.marketInfoCache = await this.getMarketInfo()
+    }
+    return this.marketInfoCache
+  }
+
+  /**
+   * Gets cached position config or fetches if not cached
+   */
+  protected async getCachedPositionConfig(indexToken: string, long: boolean): Promise<IBasePositionConfig> {
+    this.validateCache()
+    const key = `${indexToken}_${long}`
+    if (!this.positionConfigCache[key]) {
+      this.positionConfigCache[key] = await this.getPositionConfig(indexToken, long)
+    }
+    return this.positionConfigCache[key]
+  }
+
+  /**
+   * Gets cached rebase fee model or fetches if not cached
+   */
+  protected async getCachedRebaseFeeModel(): Promise<IBaseRebaseFeeModel> {
+    this.validateCache()
+    if (!this.rebaseFeeModelCache) {
+      this.rebaseFeeModelCache = await this.getRebaseFeeModel()
+    }
+    return this.rebaseFeeModelCache
+  }
+
+  // Abstract methods that must be implemented by concrete classes
+  public abstract valuateVaults(tx: Transaction): any
+  public abstract valuateSymbols(tx: Transaction): any
+  public abstract valuate(tx: Transaction): { vaultsValuation: any, symbolsValuation: any }
+  public abstract valuateMarket(): Promise<IBaseMarketValuationInfo>
+
+  public abstract fundingFeeRate(indexToken: string, long: boolean, sender?: string): Promise<number>
+  public abstract rebaseFeeRate(collateralToken: string, increase: boolean, amount: number, sender?: string): Promise<number>
+  public abstract reservingFeeRate(collateralToken: string, amount: number, sender?: string): Promise<number>
+
+  public abstract getMarketInfo(): Promise<IBaseMarketInfo>
+  public abstract getVaultInfo(vault: string): Promise<IBaseVaultInfo>
+  public abstract getSymbolInfo(tokenId: string, long: boolean): Promise<IBaseSymbolInfo>
+  public abstract getPositionConfig(indexToken: string, long: boolean): Promise<IBasePositionConfig>
+  public abstract getRebaseFeeModel(): Promise<IBaseRebaseFeeModel>
+  public abstract getOpenPositions(batchSize: number, symbol: string): Promise<IBasePositionInfo[]>
+
+  public abstract getPositionCapInfoList(owner: string): Promise<IBasePositionCapInfo[]>
+  public abstract getPositionInfoList(positionCapInfoList: IBasePositionCapInfo[], owner: string, batchSize?: number): Promise<IBasePositionInfo[]>
+  public abstract getOrderCapInfoList(owner: string): Promise<IBaseOrderCapInfo[]>
+  public abstract getOrderInfoList(orderCapInfoList: IBaseOrderCapInfo[], owner: string, batchSize?: number): Promise<IBaseOrderInfo[]>
+  public abstract getHistory(trader: string, page: number, limit: number, orderType?: string, symbol?: string): Promise<IBaseHistoryResponse>
+
+  public abstract getStaked(owner: string): Promise<IBaseStaked>
+  public abstract getStakePool(): Promise<IBaseStakePool>
+
+  public abstract hasReferral(referree: string): Promise<boolean>
+  public abstract getReferralData(referree: string): Promise<any>
+  /**
+   * Helper method to handle API requests with error handling
+   */
+  protected async makeAPIRequest<T>(endpoint: string): Promise<T> {
+    try {
+      const response = await fetch(`${this.apiEndpoint}${endpoint}`)
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`)
+      }
+      return await response.json()
+    }
+    catch (error) {
+      console.error(`Error fetching data from ${endpoint}:`, error)
+      throw error
+    }
+  }
+
+  /**
+   * Helper method to parse numeric values from API responses
+   */
+  protected parseNumericValue(value: any, decimals = 0): number {
+    if (typeof value === 'string') {
+      return Number(value) / 10 ** decimals
+    }
+    if (typeof value === 'bigint') {
+      return Number(value) / 10 ** decimals
+    }
+    return Number(value) || 0
+  }
+
+  /**
+   * Helper method to parse bigint values from API responses
+   */
+  protected parseBigIntValue(value: any): bigint {
+    if (typeof value === 'string') {
+      return BigInt(value)
+    }
+    if (typeof value === 'bigint') {
+      return value
+    }
+    return BigInt(Number(value) || 0)
+  }
+}

package/src/abstract/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Abstract base classes for SDK implementations
+ * Provides common functionality and enforces interface contracts
+ */
+
+export { BaseAPI } from './BaseAPI'
+export { BaseDataAPI } from './BaseDataAPI'