@zofai/zo-sdk 0.1.92

package/src/abstract/BaseAPI.ts

@@ -0,0 +1,575 @@
+/**
+ * Abstract base class for all API implementations
+ * Extends BaseDataAPI with trading functionality
+ */
+/* eslint-disable class-methods-use-this -- base class helpers used by subclasses */
+
+import type { KioskClient, KioskOwnerCap } from '@mysten/kiosk'
+import type { SuiClient } from '@mysten/sui/client'
+import { Transaction } from '@mysten/sui/transactions'
+import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui/utils'
+
+import type { LPToken, Network } from '../consts'
+import { ALLOW_TRADE_CAN_TRADE, ALLOW_TRADE_MUST_TRADE, ALLOW_TRADE_NO_TRADE } from '../consts'
+import type {
+  IBaseDataAPI,
+  IBaseAPI,
+  IBaseCredential,
+  IBaseHistoryResponse,
+  IBaseMarketInfo,
+  IBaseMarketValuationInfo,
+  IBaseOrderCapInfo,
+  IBaseOrderInfo,
+  IBasePositionCapInfo,
+  IBasePositionConfig,
+  IBasePositionInfo,
+  IBaseRebaseFeeModel,
+  IBaseStaked,
+  IBaseStakePool,
+  IBaseSymbolInfo,
+  IBaseVaultInfo,
+} from '../interfaces'
+import { BaseDataAPI } from './BaseDataAPI'
+
+export abstract class BaseAPI extends BaseDataAPI implements IBaseAPI {
+  /** Subclasses must provide their DataAPI instance; data methods delegate to it. */
+  protected abstract get dataAPI(): IBaseDataAPI
+
+  /* eslint-disable-next-line @typescript-eslint/no-useless-constructor -- passes params to super */
+  constructor(
+    network: Network,
+    provider: SuiClient,
+    apiEndpoint: string,
+    connectionURL: string,
+    lpToken: LPToken,
+  ) {
+    super(network, provider, apiEndpoint, connectionURL, lpToken)
+  }
+
+  // Delegate BaseDataAPI methods to this.dataAPI so subclasses don't need stub implementations
+  public valuateVaults(tx: Transaction) {
+    return this.dataAPI.valuateVaults(tx)
+  }
+
+  public valuateSymbols(tx: Transaction) {
+    return this.dataAPI.valuateSymbols(tx)
+  }
+
+  public valuate(tx: Transaction): { vaultsValuation: any, symbolsValuation: any } {
+    return this.dataAPI.valuate(tx)
+  }
+
+  public valuateMarket(): Promise<IBaseMarketValuationInfo> {
+    return this.dataAPI.valuateMarket()
+  }
+
+  public fundingFeeRate(indexToken: string, long: boolean, sender?: string): Promise<number> {
+    return this.dataAPI.fundingFeeRate(indexToken, long, sender)
+  }
+
+  public rebaseFeeRate(collateralToken: string, increase: boolean, amount: number, sender?: string): Promise<number> {
+    return this.dataAPI.rebaseFeeRate(collateralToken, increase, amount, sender)
+  }
+
+  public reservingFeeRate(collateralToken: string, amount: number, sender?: string): Promise<number> {
+    return this.dataAPI.reservingFeeRate(collateralToken, amount, sender)
+  }
+
+  public getMarketInfo(): Promise<IBaseMarketInfo> {
+    return this.dataAPI.getMarketInfo()
+  }
+
+  public getVaultInfo(vault: string): Promise<IBaseVaultInfo> {
+    return this.dataAPI.getVaultInfo(vault)
+  }
+
+  public getSymbolInfo(tokenId: string, long: boolean): Promise<IBaseSymbolInfo> {
+    return this.dataAPI.getSymbolInfo(tokenId, long)
+  }
+
+  public getPositionConfig(indexToken: string, long: boolean): Promise<IBasePositionConfig> {
+    return this.dataAPI.getPositionConfig(indexToken, long)
+  }
+
+  public getRebaseFeeModel(): Promise<IBaseRebaseFeeModel> {
+    return this.dataAPI.getRebaseFeeModel()
+  }
+
+  public getOpenPositions(batchSize: number, symbol: string): Promise<IBasePositionInfo[]> {
+    return this.dataAPI.getOpenPositions(batchSize, symbol)
+  }
+
+  public getPositionCapInfoList(owner: string): Promise<IBasePositionCapInfo[]> {
+    return this.dataAPI.getPositionCapInfoList(owner)
+  }
+
+  public getPositionInfoList(positionCapInfoList: IBasePositionCapInfo[], owner: string, batchSize?: number): Promise<IBasePositionInfo[]> {
+    return this.dataAPI.getPositionInfoList(positionCapInfoList, owner, batchSize)
+  }
+
+  public getOrderCapInfoList(owner: string): Promise<IBaseOrderCapInfo[]> {
+    return this.dataAPI.getOrderCapInfoList(owner)
+  }
+
+  public getOrderInfoList(orderCapInfoList: IBaseOrderCapInfo[], owner: string, batchSize?: number): Promise<IBaseOrderInfo[]> {
+    return this.dataAPI.getOrderInfoList(orderCapInfoList, owner, batchSize)
+  }
+
+  public getHistory(trader: string, page: number, limit: number, orderType?: string, symbol?: string): Promise<IBaseHistoryResponse> {
+    return this.dataAPI.getHistory(trader, page, limit, orderType, symbol)
+  }
+
+  public getStaked(owner: string): Promise<IBaseStaked> {
+    return this.dataAPI.getStaked(owner)
+  }
+
+  public getStakePool(): Promise<IBaseStakePool> {
+    return this.dataAPI.getStakePool()
+  }
+
+  public hasReferral(referree: string): Promise<boolean> {
+    return this.dataAPI.hasReferral(referree)
+  }
+
+  public getReferralData(referree: string): Promise<any> {
+    return this.dataAPI.getReferralData(referree)
+  }
+
+  /**
+   * Processes coin objects for transactions
+   * Handles SUI gas coin and merges multiple coin objects if needed
+   */
+  protected processCoins(tx: Transaction, coin: string, coinObjects: string[], sponsoredTx = false) {
+    if (coin === 'sui' && !sponsoredTx) {
+      return tx.gas
+    }
+    if (coinObjects.length > 1) {
+      tx.mergeCoins(
+        tx.object(coinObjects[0]),
+        coinObjects.slice(1).map(coinObject => tx.object(coinObject)),
+      )
+    }
+    return tx.object(coinObjects[0])
+  }
+
+  protected processCoinSplitting(tx: Transaction, token: string, coinObjects: string[], amounts: any[], sponsoredTx?: boolean, suiCoinObject?: any) {
+    if (sponsoredTx) {
+      const sourceObject = token === 'sui'
+        ? suiCoinObject
+        : this.processCoins(tx, token, coinObjects, true)
+      return tx.splitCoins(sourceObject, amounts)
+    }
+    const coinObject = this.processCoins(tx, token, coinObjects)
+    return tx.splitCoins(coinObject, amounts)
+  }
+
+  /**
+   * Processes slippage for price calculations
+   */
+  protected processSlippage(indexPrice: number, long: boolean, slippage: number): bigint {
+    const raw = long ? indexPrice * (1 + slippage) : indexPrice * (1 - slippage)
+    return BigInt(Math.round(raw * 1e18))
+  }
+
+  /**
+   * Processes slippage for price calculations
+   */
+  protected processPriceThreshold(indexPrice: number, slippage: number): bigint {
+    const raw = indexPrice * slippage
+    return BigInt(Math.round(raw * 1e18))
+  }
+
+  /**
+   * Determines trade allowance based on order type
+   */
+  protected getTradeAllowance(isLimitOrder: boolean, isIocOrder: boolean): number {
+    if (isLimitOrder) {
+      return isIocOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+    }
+    return ALLOW_TRADE_MUST_TRADE
+  }
+
+  // Abstract methods for trading functionality
+
+  // LP operations
+  public abstract deposit(
+    coin: string,
+    coinObjects: string[],
+    amount: number,
+    minAmountOut?: number,
+    referralAddress?: string,
+    sender?: string,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction>
+
+  public abstract withdraw(
+    coin: string,
+    lpCoinObjects: string[],
+    amount: number,
+    minAmountOut?: number,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction>
+
+  public abstract swap(
+    fromToken: string,
+    toToken: string,
+    fromAmount: bigint,
+    fromCoinObjects: string[],
+  ): Promise<Transaction>
+
+  // Staking operations
+  public abstract stake(
+    lpCoinObjects: string[],
+    amount: bigint,
+    pool: string,
+    tx?: Transaction
+  ): Transaction
+
+  public abstract unstake(
+    credentials: IBaseCredential[],
+    amount: bigint,
+    pool: string,
+    tx?: Transaction
+  ): Transaction
+
+  // Trading operations
+  public abstract openPosition(
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    collateralAmount: bigint,
+    coinObjects: string[],
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    referralAddress?: string,
+    sender?: string,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction>
+
+  public abstract decreasePosition(
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: bigint,
+    long: boolean,
+    indexPrice: number,
+    collateralPrice: number,
+    isTriggerOrder?: boolean,
+    isTakeProfitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    coinObjects?: string[],
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction>
+
+  public abstract decreaseMultiPositions(
+    positions: Array<{
+      pcpId: string
+      collateralToken: string
+      indexToken: string
+      amount: bigint
+      long: boolean
+      indexPrice: number
+      collateralPrice: number
+      isTriggerOrder?: boolean
+      isTakeProfitOrder?: boolean
+      isIocOrder?: boolean
+      pricesSlippage?: number
+      collateralSlippage?: number
+      relayerFee?: bigint
+      coinObjects?: string[]
+    }>, tx?: Transaction
+  ): Promise<Transaction>
+
+  public abstract pledgeInPosition(
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: number,
+    coinObjects: string[],
+    long: boolean,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction>
+
+  public abstract redeemFromPosition(
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: number,
+    long: boolean,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction>
+
+  public abstract cancelOrder(
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    type: string,
+    isV11Order?: boolean
+  ): Transaction
+
+  public abstract cancelMultiOrders(
+    orders: Array<{
+      orderCapId: string
+      collateralToken: string
+      indexToken: string
+      long: boolean
+      type: string
+      isV11Order?: boolean
+    }>, tx?: Transaction
+  ): Transaction
+
+  public abstract clearClosedPosition(
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+  ): void
+
+  public abstract clearOpenPositionOrder(
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+    isV11Order?: boolean
+  ): void
+
+  public abstract clearDecreasePositionOrder(
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+    isV11Order?: boolean
+  ): void
+
+  // S Card operations
+  public abstract openPositionWithSCard(
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    collateralAmount: bigint,
+    coinObjects: string[],
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    referralAddress?: string,
+    sender?: string,
+  ): Promise<Transaction>
+
+  public abstract decreasePositionWithSCard(
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: bigint,
+    long: boolean,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    isTriggerOrder?: boolean,
+    isTakeProfitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    coinObjects?: string[]
+  ): Promise<Transaction>
+
+  public abstract decreaseMultiPositionsWithSCard(
+    positions: Array<{
+      pcpId: string
+      collateralToken: string
+      indexToken: string
+      amount: bigint
+      long: boolean
+      indexPrice: number
+      collateralPrice: number
+      isTriggerOrder?: boolean
+      isTakeProfitOrder?: boolean
+      isIocOrder?: boolean
+      pricesSlippage?: number
+      collateralSlippage?: number
+      relayerFee?: bigint
+      coinObjects?: string[]
+    }>,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    tx?: Transaction
+  ): Promise<Transaction>
+
+  /**
+   * Default: not supported. Override in subclasses that support S Card claim (e.g. SLP).
+   */
+  public claimTokenFromSCard(
+    _token: string,
+    _coinObjects: string[],
+    _kioskClient: KioskClient,
+    _kioskCap: KioskOwnerCap,
+    _scard: string,
+  ): Transaction {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
+  }
+
+  // Miscellaneous
+  public abstract addReferral(
+    referrer: string,
+    tx?: Transaction
+  ): Transaction
+
+  // Admin operations
+  public abstract adminUpdatePriceFeed(
+    collateralToken: string,
+    indexToken: string
+  ): Promise<Transaction>
+
+  public abstract adminSettlePosition(
+    positionId: string,
+    owner: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean
+  ): Transaction
+
+  public abstract adminDecreasePosition(
+    positionId: string,
+    owner: string,
+    collateralToken: string,
+    indexToken: string,
+    positionAmount: number,
+    amount: bigint,
+    long: boolean,
+    collateralPrice?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint
+  ): Transaction
+
+  public abstract adminClearClosedPosition(
+    positionId: string,
+    owner: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction
+  ): void
+
+  /**
+   * Helper method to initialize oracle transaction block
+   * This is commonly used across all LP token implementations
+   */
+  protected async initOracleTransaction(tokens: string[], tx?: Transaction): Promise<Transaction> {
+    const txToUse = tx ?? new Transaction()
+    return await this.initOracleTxb(tokens, txToUse)
+  }
+
+  /**
+   * Helper method to add clock object to transaction
+   */
+  protected addClockToTransaction(tx: Transaction) {
+    return tx.object(SUI_CLOCK_OBJECT_ID)
+  }
+
+  /**
+   * Helper method to create move call arguments array
+   */
+  protected createMoveCallArgs(tx: Transaction, args: any[]): any[] {
+    return args.map((arg) => {
+      if (typeof arg === 'string' && arg.startsWith('0x')) {
+        return tx.object(arg)
+      }
+      if (typeof arg === 'number') {
+        return tx.pure.u64(arg)
+      }
+      if (typeof arg === 'bigint') {
+        return tx.pure.u256(arg)
+      }
+      return arg
+    })
+  }
+
+  /**
+   * Helper method to validate transaction parameters
+   */
+  protected validateTransactionParams(params: {
+    coin?: string
+    coinObjects?: string[]
+    amount?: number
+    minAmountOut?: number
+  }): void {
+    const { coin, coinObjects, amount, minAmountOut } = params
+
+    if (coin && !this.consts.coins[coin]) {
+      throw new Error(`Unsupported coin: ${coin}`)
+    }
+
+    if (coinObjects && coinObjects.length === 0) {
+      throw new Error('At least one coin object is required')
+    }
+
+    if (amount !== undefined && amount <= 0) {
+      throw new Error('Amount must be greater than 0')
+    }
+
+    if (minAmountOut !== undefined && minAmountOut < 0) {
+      throw new Error('Minimum amount out cannot be negative')
+    }
+  }
+
+  /**
+   * Helper method to validate position parameters
+   */
+  protected validatePositionParams(params: {
+    collateralToken: string
+    indexToken: string
+    size: bigint
+    collateralAmount: bigint
+    long: boolean
+  }): void {
+    const { collateralToken, indexToken, size, collateralAmount } = params
+
+    if (!this.consts.coins[collateralToken]) {
+      throw new Error(`Unsupported collateral token: ${collateralToken}`)
+    }
+
+    if (!this.consts.coins[indexToken]) {
+      throw new Error(`Unsupported index token: ${indexToken}`)
+    }
+
+    if (size <= 0n) {
+      throw new Error('Position size must be greater than 0')
+    }
+
+    if (collateralAmount <= 0n) {
+      throw new Error('Collateral amount must be greater than 0')
+    }
+  }
+}