zo-sdk 0.1.2 → 0.1.4

package/src/implementations/USDZAPI.ts

@@ -3,13 +3,15 @@
  * Implements USDZ-specific trading and transaction methods
  */
 
+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 { 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 {
-  IUSDZAPI,
+import type {
   IBaseCredential,
   IBaseHistoryResponse,
   IBaseMarketInfo,
@@ -19,16 +21,15 @@ import {
   IBasePositionCapInfo,
   IBasePositionConfig,
   IBasePositionInfo,
+  IBaseRebaseFeeModel,
   IBaseStaked,
+  IBaseStakePool,
   IBaseSymbolInfo,
   IBaseVaultInfo,
-  IBaseRebaseFeeModel,
-  IBaseStakePool
+  IUSDZAPI,
 } from '../interfaces'
-import { BaseAPI } from '../abstract'
-import { USDZDataAPI } from './USDZDataAPI'
 import { joinSymbol } from '../utils'
-import { KioskClient, KioskOwnerCap } from '@mysten/kiosk'
+import { USDZDataAPI } from './USDZDataAPI'
 
 export class USDZAPI extends BaseAPI implements IUSDZAPI {
   public dataAPI: USDZDataAPI
@@ -37,110 +38,142 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     network: Network,
     provider: SuiClient,
     apiEndpoint: string,
-    connectionURL: string
+    connectionURL: string,
   ) {
     super(network, provider, apiEndpoint, connectionURL, LPToken.USDZ)
     this.dataAPI = new USDZDataAPI(network, provider, apiEndpoint, connectionURL)
   }
 
-  public stake(lpCoinObjects: string[], amount: bigint, pool: string, tx?: Transaction): Promise<Transaction> {
-    throw new Error('Method not implemented.')
+  public stake(_lpCoinObjects: string[], _amount: bigint, _pool: string, _tx?: Transaction): Transaction {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public unstake(credentials: IBaseCredential[], amount: bigint, pool: string, tx?: Transaction): Promise<Transaction> {
-    throw new Error('Method not implemented.')
+
+  public unstake(_credentials: IBaseCredential[], _amount: bigint, _pool: string, _tx?: Transaction): Transaction {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public clearClosedPosition(pcpId: string, collateralToken: string, indexToken: string, long: boolean, tx: Transaction): void {
-    throw new Error('Method not implemented.')
+
+  public clearClosedPosition(_pcpId: string, _collateralToken: string, _indexToken: string, _long: boolean, _tx: Transaction): void {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public clearOpenPositionOrder(orderCapId: string, collateralToken: string, indexToken: string, long: boolean, tx: Transaction, isV11Order?: boolean): void {
-    throw new Error('Method not implemented.')
+
+  public clearOpenPositionOrder(_orderCapId: string, _collateralToken: string, _indexToken: string, _long: boolean, _tx: Transaction, _isV11Order?: boolean): void {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public clearDecreasePositionOrder(orderCapId: string, collateralToken: string, indexToken: string, long: boolean, tx: Transaction, isV11Order?: boolean): void {
-    throw new Error('Method not implemented.')
+
+  public clearDecreasePositionOrder(_orderCapId: string, _collateralToken: string, _indexToken: string, _long: boolean, _tx: Transaction, _isV11Order?: boolean): void {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public 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> {
-    throw new Error('Method not implemented.')
+
+  public 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> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public 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> {
-    throw new Error('Method not implemented.')
+
+  public 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> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public 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> {
-    throw new Error('Method not implemented.')
+
+  public 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> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public claimTokenFromSCard(token: string, coinObjects: string[], kioskClient: KioskClient, kioskCap: KioskOwnerCap, scard: string): Promise<Transaction> {
-    throw new Error('Method not implemented.')
+
+  public claimTokenFromSCard(_token: string, _coinObjects: string[], _kioskClient: KioskClient, _kioskCap: KioskOwnerCap, _scard: string): Transaction {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  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): Promise<number> {
-    throw new Error('Method not implemented.')
+
+  public fundingFeeRate(_indexToken: string, _long: boolean): Promise<number> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public rebaseFeeRate(collateralToken: string, increase: boolean, amount: number): Promise<number> {
-    throw new Error('Method not implemented.')
+
+  public rebaseFeeRate(_collateralToken: string, _increase: boolean, _amount: number): Promise<number> {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
-  public reservingFeeRate(collateralToken: string, amount: number): Promise<number> {
-    throw new Error('Method not implemented.')
+
+  public reservingFeeRate(_collateralToken: string, _amount: number): 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}.`)
   }
 
   /**
@@ -150,27 +183,70 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     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 = await this.initOracleTxb(Object.keys(this.consts.pythFeeder.feeder))
+    let tx = new Transaction()
+
+    // Add referral if needed
     if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
       tx = await this.addReferral(referralAddress, tx)
     }
-    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.zoCore.package}::market::deposit`,
+        typeArguments: [`${this.consts.zoCore.package}::usdz::USDZ`, this.consts.coins[coin].module],
+        arguments: [
+          tx.object(this.consts.zoCore.market),
+          tx.object(this.consts.zoCore.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)
 
     tx.moveCall({
       target: `${this.consts.zoCore.package}::market::deposit`,
-      typeArguments: [`${this.consts.zoCore.package}::usdz::USDZ`, this.consts.coins[coin].module],
+      typeArguments: [
+        `${this.consts.zoCore.package}::usdz::USDZ`,
+        this.consts.coins[coin].module,
+      ],
       arguments: [
         tx.object(this.consts.zoCore.market),
         tx.object(this.consts.zoCore.rebaseFeeModel),
         depositObject,
-        tx.pure.u64(minAmountOut || 0),
+        tx.pure.u64(minAmountOut),
         vaultsValuation,
         symbolsValuation,
       ],
@@ -185,22 +261,37 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     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 usdzCoinObject = this.processCoins(tx, 'usdz', lpCoinObjects)
-    const [withdrawObject] = tx.splitCoins(usdzCoinObject, [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 usdzCoinObject = this.processCoins(tx, 'usdz', lpCoinObjects, false)
+    const [withdrawObject] = tx.splitCoins(usdzCoinObject, [tx.pure.u64(amount)])
     const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx)
 
     tx.moveCall({
       target: `${this.consts.zoCore.package}::market::withdraw`,
-      typeArguments: [`${this.consts.zoCore.package}::usdz::USDZ`, this.consts.coins[coin].module],
+      typeArguments: [
+        `${this.consts.zoCore.package}::usdz::USDZ`,
+        this.consts.coins[coin].module,
+      ],
       arguments: [
         tx.object(this.consts.zoCore.market),
         tx.object(this.consts.zoCore.rebaseFeeModel),
         withdrawObject,
-        tx.pure.u64(minAmountOut || 0),
+        tx.pure.u64(minAmountOut),
         vaultsValuation,
         symbolsValuation,
       ],
@@ -208,13 +299,12 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     return tx
   }
 
-
   public async swap(
     fromToken: string,
     toToken: string,
     fromAmount: bigint,
     fromCoinObjects: string[],
-    minAmountOut?: number
+    minAmountOut?: number,
   ): Promise<Transaction> {
     const tx = await this.initOracleTxb(Object.keys(this.consts.zoCore.vaults))
     const fromCoinObject = this.processCoins(tx, fromToken, fromCoinObjects)
@@ -258,7 +348,7 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     collateralSlippage?: number,
     relayerFee?: bigint,
     referralAddress?: string,
-    sender?: string
+    sender?: string,
   ): Promise<Transaction> {
     let tx = new Transaction()
     if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
@@ -323,11 +413,14 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     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[]
+    coinObjects?: string[],
   ): Promise<Transaction> {
+    if (!coinObjects) {
+      throw new Error(`${this.constructor.name}: coinObjects is required`)
+    }
     const tx = await this.initOracleTxb([collateralToken, indexToken])
     const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
     const coinObject = this.processCoins(tx, collateralToken, coinObjects || [])
@@ -339,7 +432,8 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     let allowTrade = ALLOW_TRADE_MUST_TRADE
     if (isTriggerOrder) {
       allowTrade = isIocOrder || !isTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
-    } else {
+    }
+    else {
       isTakeProfitOrder = true
     }
 
@@ -373,43 +467,56 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
   }
 
   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,
+    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
       }
 
@@ -451,7 +558,7 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     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)
@@ -503,14 +610,14 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     return tx
   }
 
-  public async cancelOrder(
+  public cancelOrder(
     orderCapId: string,
     collateralToken: string,
     indexToken: string,
     long: boolean,
     type: string,
-    isV11Order?: boolean
-  ): Promise<Transaction> {
+    isV11Order?: boolean,
+  ): Transaction {
     const tx = new Transaction()
     let functionName = ''
     switch (type) {
@@ -542,16 +649,17 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     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()
     }
@@ -592,7 +700,7 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
 
   public addReferral(
     referralAddress: string,
-    tx?: Transaction
+    tx?: Transaction,
   ): Transaction {
     if (!tx) {
       tx = new Transaction()
@@ -608,19 +716,19 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
 
   public async adminUpdatePriceFeed(
     collateralToken: string,
-    indexToken: string
+    indexToken: string,
   ): Promise<Transaction> {
     const tx = await this.initOracleTxb([collateralToken, indexToken])
     return tx
   }
 
-  public async adminSettlePosition(
+  public adminSettlePosition(
     positionId: string,
     owner: string,
     collateralToken: string,
     indexToken: string,
-    long: boolean
-  ): Promise<Transaction> {
+    long: boolean,
+  ): Transaction {
     const tx = new Transaction()
 
     tx.moveCall({
@@ -645,7 +753,7 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     return tx
   }
 
-  public async adminDecreasePosition(
+  public adminDecreasePosition(
     positionId: string,
     owner: string,
     collateralToken: string,
@@ -653,10 +761,7 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     positionAmount: number,
     amount: bigint,
     long: boolean,
-    collateralPrice?: number,
-    collateralSlippage?: number,
-    relayerFee?: bigint
-  ): Promise<Transaction> {
+  ): Transaction {
     const tx = new Transaction()
     const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
 
@@ -688,14 +793,14 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     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.zoCore.package}::market::force_clear_closed_position`,
       typeArguments: [
@@ -712,4 +817,4 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
       ],
     })
   }
-}
+}