zo-sdk 0.1.2 → 0.1.3

package/src/implementations/SLPAPI.ts

@@ -3,32 +3,34 @@
  * Implements SLP-specific trading and transaction methods for Sudo SDK
  */
 
+import type { KioskClient, KioskOwnerCap } from '@mysten/kiosk'
+import { KioskTransaction } 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 { BaseAPI } from '../abstract'
 import type { Network } from '../consts'
 import { ALLOW_TRADE_CAN_TRADE, ALLOW_TRADE_MUST_TRADE, ALLOW_TRADE_NO_TRADE, LPToken } from '../consts'
 import type {
-  ISLPAPI,
-  ISLPCredential,
+  IBaseHistoryResponse,
+  IBaseMarketInfo,
+  IBaseMarketValuationInfo,
   IBaseOrderCapInfo,
   IBaseOrderInfo,
   IBasePositionCapInfo,
   IBasePositionConfig,
   IBasePositionInfo,
+  IBaseRebaseFeeModel,
   IBaseStaked,
-  IBaseHistoryResponse,
-  IBaseMarketInfo,
-  IBaseMarketValuationInfo,
+  IBaseStakePool,
   IBaseSymbolInfo,
   IBaseVaultInfo,
-  IBaseRebaseFeeModel,
-  IBaseStakePool
+  ISLPAPI,
+  ISLPCredential,
 } from '../interfaces'
-import { BaseAPI } from '../abstract'
-import { SLPDataAPI } from './SLPDataAPI'
 import { joinSymbol } from '../utils'
-import { KioskClient, KioskOwnerCap, KioskTransaction } from '@mysten/kiosk'
+import { SLPDataAPI } from './SLPDataAPI'
 
 export class SLPAPI extends BaseAPI implements ISLPAPI {
   public dataAPI: SLPDataAPI
@@ -37,83 +39,106 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     network: Network,
     provider: SuiClient,
     apiEndpoint: string,
-    connectionURL: string
+    connectionURL: string,
   ) {
     super(network, provider, apiEndpoint, connectionURL, LPToken.SLP)
     this.dataAPI = new SLPDataAPI(network, provider, apiEndpoint, connectionURL)
   }
 
-  public valuateVaults(tx: Transaction) {
-    throw new Error('Method not implemented.')
+  public valuateVaults(_tx: Transaction) {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public valuateSymbols(tx: Transaction) {
-    throw new Error('Method not implemented.')
+
+  public valuateSymbols(_tx: Transaction) {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public valuate(tx: Transaction): { vaultsValuation: any; symbolsValuation: any } {
-    throw new Error('Method not implemented.')
+
+  public valuate(_tx: Transaction): { vaultsValuation: any, symbolsValuation: any } {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
+
   public valuateMarket(): Promise<IBaseMarketValuationInfo> {
-    throw new Error('Method not implemented.')
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public fundingFeeRate(indexToken: string, long: boolean, sender?: string): Promise<number> {
-    throw new Error('Method not implemented.')
+
+  public fundingFeeRate(_indexToken: string, _long: boolean, _sender?: string): Promise<number> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public rebaseFeeRate(collateralToken: string, increase: boolean, amount: number, sender?: string): Promise<number> {
-    throw new Error('Method not implemented.')
+
+  public rebaseFeeRate(_collateralToken: string, _increase: boolean, _amount: number, _sender?: string): Promise<number> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public reservingFeeRate(collateralToken: string, amount: number, sender?: string): Promise<number> {
-    throw new Error('Method not implemented.')
+
+  public reservingFeeRate(_collateralToken: string, _amount: number, _sender?: string): Promise<number> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public calcPositionReserveFeeAmount(position: IBasePositionInfo): Promise<number> {
-    throw new Error('Method not implemented.')
+
+  public calcPositionReserveFeeAmount(_position: IBasePositionInfo): Promise<number> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public calcPositionFundingFeeValue(position: IBasePositionInfo): Promise<number> {
-    throw new Error('Method not implemented.')
+
+  public calcPositionFundingFeeValue(_position: IBasePositionInfo): Promise<number> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
+
   public getMarketInfo(): Promise<IBaseMarketInfo> {
-    throw new Error('Method not implemented.')
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public getVaultInfo(vault: string): Promise<IBaseVaultInfo> {
-    throw new Error('Method not implemented.')
+
+  public getVaultInfo(_vault: string): Promise<IBaseVaultInfo> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public getSymbolInfo(tokenId: string, long: boolean): Promise<IBaseSymbolInfo> {
-    throw new Error('Method not implemented.')
+
+  public getSymbolInfo(_tokenId: string, _long: boolean): Promise<IBaseSymbolInfo> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public getPositionConfig(indexToken: string, long: boolean): Promise<IBasePositionConfig> {
-    throw new Error('Method not implemented.')
+
+  public getPositionConfig(_indexToken: string, _long: boolean): Promise<IBasePositionConfig> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
+
   public getRebaseFeeModel(): Promise<IBaseRebaseFeeModel> {
-    throw new Error('Method not implemented.')
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
+
   public getOpenPositions(): Promise<IBasePositionInfo[]> {
-    throw new Error('Method not implemented.')
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public getPositionCapInfoList(owner: string): Promise<IBasePositionCapInfo[]> {
-    throw new Error('Method not implemented.')
+
+  public getPositionCapInfoList(_owner: string): Promise<IBasePositionCapInfo[]> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public getPositionInfoList(positionCapInfoList: IBasePositionCapInfo[], owner: string): Promise<IBasePositionInfo[]> {
-    throw new Error('Method not implemented.')
+
+  public getPositionInfoList(_positionCapInfoList: IBasePositionCapInfo[], _owner: string): Promise<IBasePositionInfo[]> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public getOrderCapInfoList(owner: string): Promise<IBaseOrderCapInfo[]> {
-    throw new Error('Method not implemented.')
+
+  public getOrderCapInfoList(_owner: string): Promise<IBaseOrderCapInfo[]> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public getOrderInfoList(orderCapInfoList: IBaseOrderCapInfo[], owner: string): Promise<IBaseOrderInfo[]> {
-    throw new Error('Method not implemented.')
+
+  public getOrderInfoList(_orderCapInfoList: IBaseOrderCapInfo[], _owner: string): Promise<IBaseOrderInfo[]> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public getHistory(trader: string, page: number, limit: number, orderType?: string, symbol?: string): Promise<IBaseHistoryResponse> {
-    throw new Error('Method not implemented.')
+
+  public getHistory(_trader: string, _page: number, _limit: number, _orderType?: string, _symbol?: string): Promise<IBaseHistoryResponse> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public getStaked(owner: string): Promise<IBaseStaked> {
-    throw new Error('Method not implemented.')
+
+  public getStaked(_owner: string): Promise<IBaseStaked> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
+
   public getStakePool(): Promise<IBaseStakePool> {
-    throw new Error('Method not implemented.')
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public hasReferral(referree: string): Promise<boolean> {
-    throw new Error('Method not implemented.')
+
+  public hasReferral(_referree: string): Promise<boolean> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public getReferralData(referree: string): Promise<any> {
-    throw new Error('Method not implemented.')
+
+  public getReferralData(_referree: string): Promise<any> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
 
   /**
@@ -123,19 +148,59 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     coin: string,
     coinObjects: string[],
     amount: number,
-    minAmountOut?: number,
+    minAmountOut = 0,
     referralAddress?: string,
-    sender?: string
+    sender?: string,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+    isDepositingSui?: boolean,
   ): Promise<Transaction> {
     let tx = new Transaction()
+
+    // Add referral if needed
     if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
       tx = await this.addReferral(referralAddress, tx)
     }
-    tx = await this.initOracleTxb(
-      Object.keys(this.consts.pythFeeder.feeder),
-    )
-    const coinObject = this.processCoins(tx, coin, coinObjects)
-    const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)])
+
+    // Initialize oracle transaction
+    const pythFeederKeys = Object.keys(this.consts.pythFeeder.feeder)
+
+    // Handle sponsored transaction case
+    if (sponsoredTx) {
+      const suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb(pythFeederKeys, tx, true, suiCoinObject)
+
+      // Process deposit coins
+      const depositObject = isDepositingSui
+        ? tx.splitCoins(suiCoinObject, [tx.pure.u64(amount)])[0]
+        : tx.splitCoins(this.processCoins(tx, coin, coinObjects, true), [tx.pure.u64(amount)])[0]
+
+      const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx)
+
+      tx.moveCall({
+        target: `${this.consts.sudoCore.upgradedPackage}::market::deposit`,
+        typeArguments: [
+          `${this.consts.sudoCore.package}::slp::SLP`,
+          this.consts.coins[coin].module,
+        ],
+        arguments: [
+          tx.object(this.consts.sudoCore.market),
+          tx.object(this.consts.sudoCore.rebaseFeeModel),
+          depositObject,
+          tx.pure.u64(minAmountOut),
+          vaultsValuation,
+          symbolsValuation,
+        ],
+      })
+      return tx
+    }
+
+    // Handle non-sponsored transaction case
+    tx = await this.initOracleTxb(pythFeederKeys, tx)
+    const depositObject = tx.splitCoins(
+      this.processCoins(tx, coin, coinObjects, false),
+      [tx.pure.u64(amount)],
+    )[0]
 
     const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx)
 
@@ -149,7 +214,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         tx.object(this.consts.sudoCore.market),
         tx.object(this.consts.sudoCore.rebaseFeeModel),
         depositObject,
-        tx.pure.u64(minAmountOut || 0),
+        tx.pure.u64(minAmountOut),
         vaultsValuation,
         symbolsValuation,
       ],
@@ -164,13 +229,25 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     coin: string,
     lpCoinObjects: string[],
     amount: number,
-    minAmountOut?: number
+    minAmountOut = 0,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
   ): Promise<Transaction> {
-    const tx = await this.initOracleTxb(
-      Object.keys(this.consts.pythFeeder.feeder),
-    )
-    const lpCoinObject = this.processCoins(tx, `${this.consts.sudoCore.package}::slp::SLP`, lpCoinObjects)
-    const [withdrawObject] = tx.splitCoins(lpCoinObject, [tx.pure.u64(amount)])
+    let tx = new Transaction()
+
+    // Initialize oracle transaction
+    const pythFeederKeys = Object.keys(this.consts.pythFeeder.feeder)
+
+    if (sponsoredTx) {
+      const suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb(pythFeederKeys, tx, true, suiCoinObject)
+    }
+    else {
+      tx = await this.initOracleTxb(pythFeederKeys, tx)
+    }
+
+    const slpCoinObject = this.processCoins(tx, 'slp', lpCoinObjects, false)
+    const [withdrawObject] = tx.splitCoins(slpCoinObject, [tx.pure.u64(amount)])
     const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx)
 
     tx.moveCall({
@@ -183,7 +260,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         tx.object(this.consts.sudoCore.market),
         tx.object(this.consts.sudoCore.rebaseFeeModel),
         withdrawObject,
-        tx.pure.u64(minAmountOut || 0),
+        tx.pure.u64(minAmountOut),
         vaultsValuation,
         symbolsValuation,
       ],
@@ -196,10 +273,10 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     toToken: string,
     fromAmount: bigint,
     fromCoinObjects: string[],
-    minAmountOut?: number
+    minAmountOut?: number,
   ): Promise<Transaction> {
     const tx = await this.initOracleTxb(
-      Object.keys(this.consts.sudoCore.vaults)
+      Object.keys(this.consts.sudoCore.vaults),
     )
     const fromCoinObject = this.processCoins(tx, fromToken, fromCoinObjects)
     const [fromDepositObject] = tx.splitCoins(fromCoinObject, [
@@ -228,11 +305,11 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
   /**
    * Stakes SLP tokens in Sudo staking pools
    */
-  public async stake(
+  public stake(
     lpCoinObjects: string[],
     amount: bigint,
-    pool: string
-  ): Promise<Transaction> {
+    pool: string,
+  ): Transaction {
     if (!this.consts.sudoStaking) {
       throw new Error('Sudo staking configuration not found')
     }
@@ -259,11 +336,11 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
   /**
    * Unstakes SLP tokens from Sudo staking pools
    */
-  public async unstake(
+  public unstake(
     credentials: ISLPCredential[],
     amount: bigint,
-    pool: string
-  ): Promise<Transaction> {
+    pool: string,
+  ): Transaction {
     if (!this.consts.sudoStaking) {
       throw new Error('Sudo staking configuration not found')
     }
@@ -271,9 +348,10 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     const tx = new Transaction()
 
     for (const credential of credentials) {
-      // eslint-disable-next-line unicorn/prefer-math-min-max
-      const withdrawAmount =
-        amount < credential.amount ? amount : credential.amount
+      const withdrawAmount = (() => {
+        const min = (a: bigint, b: bigint) => a < b ? a : b
+        return min(amount, credential.amount)
+      })()
       amount -= withdrawAmount
       tx.moveCall({
         target: `${this.consts.sudoStaking.package}::pool::withdraw`,
@@ -317,11 +395,11 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     collateralPrice: number,
     isLimitOrder = false,
     isIocOrder = false,
-    pricesSlippage: number = 0.003,
-    collateralSlippage: number = 0.5,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
     relayerFee = BigInt(0.5),
     referralAddress?: string,
-    sender?: string
+    sender?: string,
   ): Promise<Transaction> {
     let tx = new Transaction()
     if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
@@ -350,13 +428,13 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         this.consts.coins[collateralToken].module,
         this.consts.coins[indexToken].module,
         `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-        this.consts.coins['sui'].module,
+        this.consts.coins.sui.module,
       ],
       arguments: [
         tx.object(SUI_CLOCK_OBJECT_ID),
         tx.object(this.consts.sudoCore.market),
         tx.object(
-          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel
+          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel,
         ),
         tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
         tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
@@ -389,10 +467,9 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     isTriggerOrder = false,
     isTakeProfitOrder = true,
     isIocOrder = false,
-    pricesSlippage: number = 0.003,
-    collateralSlippage: number = 0.5,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
     relayerFee = BigInt(0.5),
-    coinObjects?: string[]
   ): Promise<Transaction> {
     const tx = await this.initOracleTxb([collateralToken, indexToken])
     const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
@@ -401,22 +478,19 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     const adjustPrice = this.processSlippage(
       indexPrice,
       !long,
-      isTriggerOrder ? 0 : pricesSlippage
+      isTriggerOrder ? 0 : pricesSlippage,
     )
     const adjustCollateralPrice = this.processSlippage(
       collateralPrice,
       false,
-      collateralSlippage
+      collateralSlippage,
     )
 
     let allowTrade = ALLOW_TRADE_MUST_TRADE
     if (isTriggerOrder) {
-      if (isIocOrder || !isTakeProfitOrder) {
-        allowTrade = ALLOW_TRADE_NO_TRADE
-      } else {
-        allowTrade = ALLOW_TRADE_CAN_TRADE
-      }
-    } else {
+      allowTrade = isIocOrder || !isTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+    }
+    else {
       isTakeProfitOrder = true
     }
 
@@ -427,14 +501,14 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         this.consts.coins[collateralToken].module,
         this.consts.coins[indexToken].module,
         `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-        this.consts.coins['sui'].module,
+        this.consts.coins.sui.module,
       ],
       arguments: [
         tx.object(SUI_CLOCK_OBJECT_ID),
         tx.object(this.consts.sudoCore.market),
         tx.object(pcpId),
         tx.object(
-          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel
+          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel,
         ),
         tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
         tx.object(this.consts.pythFeeder.feeder[collateralToken]),
@@ -454,44 +528,58 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
 
   public async decreaseMultiPositions(
     positions: Array<{
-      pcpId: string,
-      collateralToken: string,
-      coinObjects: string[],
-      indexToken: string,
-      amount: bigint,
-      long: boolean,
-      indexPrice: number,
-      collateralPrice: number,
-      isTriggerOrder: boolean,
-      isTakeProfitOrder: boolean,
-      isIocOrder: boolean,
-      slippage: number,
-      relayerFee: bigint,
-    }>, tx?: Transaction
+      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> {
     if (!tx) {
       tx = new Transaction()
     }
-    tx = await this.initOracleTxb(positions.map(position => [position.collateralToken, position.indexToken]).flat(), tx)
+    tx = await this.initOracleTxb(positions.flatMap(position => [position.collateralToken, position.indexToken]), tx)
 
     for (const position of positions) {
       const {
         pcpId,
         collateralToken,
-        coinObjects, indexToken, amount, long, indexPrice, collateralPrice, isTriggerOrder, isTakeProfitOrder, isIocOrder, slippage, relayerFee
+        coinObjects = [],
+        indexToken,
+        amount,
+        long,
+        indexPrice,
+        collateralPrice,
+        isTriggerOrder = false,
+        isTakeProfitOrder = true,
+        isIocOrder = false,
+        pricesSlippage = 0.003,
+        collateralSlippage = 0.5,
+        relayerFee = BigInt(0.5),
       } = position
       let innerIsTakeProfitOrder = isTakeProfitOrder
       const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
       const coinObject = this.processCoins(tx, collateralToken, coinObjects)
       const feeObject = tx.splitCoins(coinObject, [tx.pure.u64(relayerFee)])
 
-      const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : slippage)
-      const adjustCollateralPrice = this.processSlippage(collateralPrice, false, 0.5)
+      const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage)
+      const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage)
 
       let allowTrade = ALLOW_TRADE_MUST_TRADE
       if (isTriggerOrder) {
         allowTrade = isIocOrder || !innerIsTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
-      } else {
+      }
+      else {
         innerIsTakeProfitOrder = true
       }
 
@@ -502,14 +590,14 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
           this.consts.coins[collateralToken].module,
           this.consts.coins[indexToken].module,
           `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-          this.consts.coins['sui'].module,
+          this.consts.coins.sui.module,
         ],
         arguments: [
           tx.object(SUI_CLOCK_OBJECT_ID),
           tx.object(this.consts.sudoCore.market),
           tx.object(pcpId),
           tx.object(
-            this.consts.sudoCore.vaults[collateralToken].reservingFeeModel
+            this.consts.sudoCore.vaults[collateralToken].reservingFeeModel,
           ),
           tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
           tx.object(this.consts.pythFeeder.feeder[collateralToken]),
@@ -533,7 +621,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     indexToken: string,
     amount: number,
     coinObjects: string[],
-    long: boolean
+    long: boolean,
   ): Promise<Transaction> {
     const tx = await this.initOracleTxb([collateralToken, indexToken])
     const coinObject = this.processCoins(tx, collateralToken, coinObjects)
@@ -561,7 +649,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     collateralToken: string,
     indexToken: string,
     amount: number,
-    long: boolean
+    long: boolean,
   ): Promise<Transaction> {
     const tx = await this.initOracleTxb([collateralToken, indexToken])
     const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
@@ -579,7 +667,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         tx.object(this.consts.sudoCore.market),
         tx.object(pcpId),
         tx.object(
-          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel
+          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel,
         ),
         tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
         tx.object(this.consts.pythFeeder.feeder[collateralToken]),
@@ -591,25 +679,27 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     return tx
   }
 
-  public async cancelOrder(
+  public cancelOrder(
     orderCapId: string,
     collateralToken: string,
     indexToken: string,
     long: boolean,
     type: string,
-    isV11Order?: boolean
-  ): Promise<Transaction> {
+  ): Transaction {
     const tx = new Transaction()
     let functionName = ''
     switch (type) {
-      case 'OPEN_POSITION':
+      case 'OPEN_POSITION': {
         functionName = 'clear_open_position_order_v1_1'
         break
-      case 'DECREASE_POSITION':
+      }
+      case 'DECREASE_POSITION': {
         functionName = 'clear_decrease_position_order_v1_1'
         break
-      default:
+      }
+      default: {
         throw new Error('invalid order type')
+      }
     }
     tx.moveCall({
       target: `${this.consts.sudoCore.upgradedPackage}::market::${functionName}`,
@@ -618,7 +708,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         this.consts.coins[collateralToken].module,
         this.consts.coins[indexToken].module,
         `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-        this.consts.coins['sui'].module,
+        this.consts.coins.sui.module,
       ],
       arguments: [
         tx.object(this.consts.sudoCore.market),
@@ -628,16 +718,17 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     return tx
   }
 
-  public async cancelMultiOrders(
+  public cancelMultiOrders(
     orders: Array<{
-      orderCapId: string,
-      collateralToken: string,
-      indexToken: string,
-      long: boolean,
-      type: string,
+      orderCapId: string
+      collateralToken: string
+      indexToken: string
+      long: boolean
+      type: string
       isV11Order?: boolean
-    }>, tx?: Transaction
-  ): Promise<Transaction> {
+    }>,
+    tx?: Transaction,
+  ): Transaction {
     if (!tx) {
       tx = new Transaction()
     }
@@ -701,7 +792,6 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     indexToken: string,
     long: boolean,
     tx: Transaction,
-    isV11Order?: boolean
   ): void {
     tx.moveCall({
       target: `${this.consts.sudoCore.upgradedPackage}::market::clear_open_position_order_v1_1`,
@@ -710,7 +800,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         this.consts.coins[collateralToken].module,
         this.consts.coins[indexToken].module,
         `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-        this.consts.coins['sui'].module,
+        this.consts.coins.sui.module,
       ],
       arguments: [
         tx.object(this.consts.sudoCore.market),
@@ -724,7 +814,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     collateralToken: string,
     indexToken: string,
     long: boolean,
-    tx: Transaction
+    tx: Transaction,
   ): void {
     tx.moveCall({
       target: `${this.consts.sudoCore.upgradedPackage}::market::clear_decrease_position_order_v1_1`,
@@ -733,7 +823,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         this.consts.coins[collateralToken].module,
         this.consts.coins[indexToken].module,
         `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-        this.consts.coins['sui'].module,
+        this.consts.coins.sui.module,
       ],
       arguments: [
         tx.object(this.consts.sudoCore.market),
@@ -801,13 +891,13 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         this.consts.coins[collateralToken].module,
         this.consts.coins[indexToken].module,
         `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-        this.consts.coins['sui'].module,
+        this.consts.coins.sui.module,
       ],
       arguments: [
         tx.object(SUI_CLOCK_OBJECT_ID),
         tx.object(this.consts.sudoCore.market),
         tx.object(
-          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel
+          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel,
         ),
         tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
         tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
@@ -829,7 +919,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
       .return({
         itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
         item: sudoCard,
-        promise: promise,
+        promise,
       })
       .finalize()
     return tx
@@ -849,10 +939,9 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     isTriggerOrder = false,
     isTakeProfitOrder = true,
     isIocOrder = false,
-    pricesSlippage: number = 0.003,
-    collateralSlippage: number = 0.5,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
     relayerFee = BigInt(0.5),
-    coinObjects?: string[]
   ): Promise<Transaction> {
     const tx = await this.initOracleTxb([collateralToken, indexToken])
     const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
@@ -861,22 +950,19 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     const adjustPrice = this.processSlippage(
       indexPrice,
       !long,
-      isTriggerOrder ? 0 : pricesSlippage
+      isTriggerOrder ? 0 : pricesSlippage,
     )
     const adjustCollateralPrice = this.processSlippage(
       collateralPrice,
       false,
-      collateralSlippage
+      collateralSlippage,
     )
 
     let allowTrade = ALLOW_TRADE_MUST_TRADE
     if (isTriggerOrder) {
-      if (isIocOrder || !isTakeProfitOrder) {
-        allowTrade = ALLOW_TRADE_NO_TRADE
-      } else {
-        allowTrade = ALLOW_TRADE_CAN_TRADE
-      }
-    } else {
+      allowTrade = isIocOrder || !isTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+    }
+    else {
       isTakeProfitOrder = true
     }
 
@@ -898,14 +984,14 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         this.consts.coins[collateralToken].module,
         this.consts.coins[indexToken].module,
         `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-        this.consts.coins['sui'].module,
+        this.consts.coins.sui.module,
       ],
       arguments: [
         tx.object(SUI_CLOCK_OBJECT_ID),
         tx.object(this.consts.sudoCore.market),
         tx.object(pcpId),
         tx.object(
-          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel
+          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel,
         ),
         tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
         tx.object(this.consts.pythFeeder.feeder[collateralToken]),
@@ -925,7 +1011,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
       .return({
         itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
         item: sudoCard,
-        promise: promise,
+        promise,
       })
       .finalize()
     return tx
@@ -933,29 +1019,30 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
 
   public async decreaseMultiPositionsWithSCard(
     positions: Array<{
-      pcpId: string,
-      collateralToken: string,
-      indexToken: string,
-      amount: bigint,
-      long: boolean,
-      indexPrice: number,
-      collateralPrice: number,
-      isTriggerOrder: boolean,
-      isTakeProfitOrder: boolean,
-      isIocOrder: boolean,
-      slippage: number,
-      relayerFee: bigint,
-      coinObjects: string[]
+      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
+    tx?: Transaction,
   ): Promise<Transaction> {
     if (!tx) {
       tx = new Transaction()
     }
-    tx = await this.initOracleTxb(positions.map(position => [position.collateralToken, position.indexToken]).flat(), tx)
+    tx = await this.initOracleTxb(positions.flatMap(position => [position.collateralToken, position.indexToken]), tx)
 
     const kioskTx = new KioskTransaction({
       transaction: tx,
@@ -977,25 +1064,27 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         long,
         indexPrice,
         collateralPrice,
-        isTriggerOrder,
-        isTakeProfitOrder,
-        isIocOrder,
-        slippage,
-        relayerFee,
-        coinObjects,
+        isTriggerOrder = false,
+        isTakeProfitOrder = true,
+        isIocOrder = false,
+        pricesSlippage = 0.003,
+        collateralSlippage = 0.5,
+        relayerFee = BigInt(0.5),
+        coinObjects = [],
       } = position
       let innerIsTakeProfitOrder = isTakeProfitOrder
       const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
       const coinObject = this.processCoins(tx, collateralToken, coinObjects)
       const feeObject = tx.splitCoins(coinObject, [tx.pure.u64(relayerFee)])
 
-      const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : slippage)
-      const adjustCollateralPrice = this.processSlippage(collateralPrice, false, 0.5)
+      const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage)
+      const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage)
 
       let allowTrade = ALLOW_TRADE_MUST_TRADE
       if (isTriggerOrder) {
         allowTrade = isIocOrder || !innerIsTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
-      } else {
+      }
+      else {
         innerIsTakeProfitOrder = true
       }
 
@@ -1006,14 +1095,14 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
           this.consts.coins[collateralToken].module,
           this.consts.coins[indexToken].module,
           `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-          this.consts.coins['sui'].module,
+          this.consts.coins.sui.module,
         ],
         arguments: [
           tx.object(SUI_CLOCK_OBJECT_ID),
           tx.object(this.consts.sudoCore.market),
           tx.object(pcpId),
           tx.object(
-            this.consts.sudoCore.vaults[collateralToken].reservingFeeModel
+            this.consts.sudoCore.vaults[collateralToken].reservingFeeModel,
           ),
           tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
           tx.object(this.consts.pythFeeder.feeder[collateralToken]),
@@ -1034,7 +1123,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
       .return({
         itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
         item: sudoCard,
-        promise: promise,
+        promise,
       })
       .finalize()
     return tx
@@ -1042,7 +1131,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
 
   public addReferral(
     referrer: string,
-    tx?: Transaction
+    tx?: Transaction,
   ): Transaction {
     if (!tx) {
       tx = new Transaction()
@@ -1058,24 +1147,24 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
 
   public async adminUpdatePriceFeed(
     collateralToken: string,
-    indexToken: string
+    indexToken: string,
   ): Promise<Transaction> {
     const tx = await this.initOracleTxb([collateralToken, indexToken])
     return tx
   }
 
-  public async adminSettlePosition(
-    positionId: string,
-    owner: string,
-    collateralToken: string,
-    indexToken: string,
-    long: boolean
-  ): Promise<Transaction> {
+  public adminSettlePosition(
+    _positionId: string,
+    _owner: string,
+    _collateralToken: string,
+    _indexToken: string,
+    _long: boolean,
+  ): Transaction {
     // SLP does not support this operation
-    throw new Error('Method not implemented.')
+    throw new Error(`Method not implemented for ${this.constructor.name}`)
   }
 
-  public async adminDecreasePosition(
+  public adminDecreasePosition(
     positionId: string,
     owner: string,
     collateralToken: string,
@@ -1085,9 +1174,9 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     long: boolean,
     collateralPrice?: number,
     collateralSlippage?: number,
-    relayerFee?: bigint
-  ): Promise<Transaction> {
-    const tx = await this.initOracleTxb([collateralToken, indexToken])
+    relayerFee?: bigint,
+  ): Transaction {
+    const tx = new Transaction()
     const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
     const feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee || BigInt(1))])
 
@@ -1097,7 +1186,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
       collateralSlippage || 0.5,
     )
 
-    let allowTrade = ALLOW_TRADE_MUST_TRADE
+    const allowTrade = ALLOW_TRADE_MUST_TRADE
 
     tx.moveCall({
       target: `${this.consts.sudoCore.upgradedPackage}::market::admin_decrease_position_v1_3`,
@@ -1106,7 +1195,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         this.consts.coins[collateralToken].module,
         this.consts.coins[indexToken].module,
         `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-        this.consts.coins['sui'].module,
+        this.consts.coins.sui.module,
       ],
       arguments: [
         tx.object(this.consts.sudoCore.adminCap),
@@ -1141,14 +1230,14 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     return tx
   }
 
-  public async adminClearClosedPosition(
+  public adminClearClosedPosition(
     positionId: string,
     owner: string,
     collateralToken: string,
     indexToken: string,
     long: boolean,
-    tx: Transaction
-  ): Promise<void> {
+    tx: Transaction,
+  ): void {
     tx.moveCall({
       target: `${this.consts.sudoCore.upgradedPackage}::market::admin_clear_closed_position_v1_1`,
       typeArguments: [
@@ -1167,13 +1256,13 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
   }
 
   // SLP Specific APIs
-  public async claimTokenFromSCard(
+  public claimTokenFromSCard(
     token: string,
     coinObjects: string[],
     kioskClient: KioskClient,
     kioskCap: KioskOwnerCap,
-    scard: string
-  ): Promise<Transaction> {
+    scard: string,
+  ): Transaction {
     const tx = new Transaction()
     const kioskTx = new KioskTransaction({
       transaction: tx,
@@ -1187,7 +1276,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     })
 
     // claim tokens
-    coinObjects.forEach(coinObject => {
+    coinObjects.forEach((coinObject) => {
       return tx.moveCall({
         target: `${this.consts.sudoNft.upgradedPackage}::card::claim_token`,
         typeArguments: [`${this.consts.coins[token].module}`],
@@ -1199,9 +1288,9 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
       .return({
         itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
         item: sudoCard,
-        promise: promise,
+        promise,
       })
       .finalize()
     return tx
   }
-}
+}