zo-sdk 0.1.2 → 0.1.4

package/src/implementations/ZLPAPI.ts

@@ -3,13 +3,16 @@
  * Implements ZLP-specific trading and transaction methods
  */
 
+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 {
-  IZLPAPI,
+import type {
   IBaseCredential,
   IBaseHistoryResponse,
   IBaseMarketInfo,
@@ -19,16 +22,15 @@ import {
   IBasePositionCapInfo,
   IBasePositionConfig,
   IBasePositionInfo,
+  IBaseRebaseFeeModel,
   IBaseStaked,
+  IBaseStakePool,
   IBaseSymbolInfo,
   IBaseVaultInfo,
-  IBaseRebaseFeeModel,
-  IBaseStakePool
+  IZLPAPI,
 } from '../interfaces'
-import { BaseAPI } from '../abstract'
-import { ZLPDataAPI } from './ZLPDataAPI'
 import { joinSymbol } from '../utils'
-import { KioskClient, KioskOwnerCap, KioskTransaction } from '@mysten/kiosk'
+import { ZLPDataAPI } from './ZLPDataAPI'
 
 export class ZLPAPI extends BaseAPI implements IZLPAPI {
   public dataAPI: ZLPDataAPI
@@ -37,92 +39,118 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     network: Network,
     provider: SuiClient,
     apiEndpoint: string,
-    connectionURL: string
+    connectionURL: string,
   ) {
     super(network, provider, apiEndpoint, connectionURL, LPToken.ZLP)
     this.dataAPI = new ZLPDataAPI(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 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}.`)
   }
 
   /**
@@ -132,27 +160,70 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     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}::zlp::ZLP`, 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}::zlp::ZLP`, this.consts.coins[coin].module],
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        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,
       ],
@@ -167,22 +238,37 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     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 zlpCoinObject = this.processCoins(tx, 'zlp', lpCoinObjects)
-    const [withdrawObject] = tx.splitCoins(zlpCoinObject, [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 zlpCoinObject = this.processCoins(tx, 'zlp', lpCoinObjects, false)
+    const [withdrawObject] = tx.splitCoins(zlpCoinObject, [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}::zlp::ZLP`, this.consts.coins[coin].module],
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        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,
       ],
@@ -190,13 +276,12 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     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)
@@ -236,11 +321,11 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     collateralPrice: number,
     isLimitOrder?: boolean,
     isIocOrder?: boolean,
-    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 || ''))) {
@@ -305,11 +390,14 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     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 || [])
@@ -321,7 +409,8 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     let allowTrade = ALLOW_TRADE_MUST_TRADE
     if (isTriggerOrder) {
       allowTrade = isIocOrder || !isTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
-    } else {
+    }
+    else {
       isTakeProfitOrder = true
     }
 
@@ -355,43 +444,56 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
   }
 
   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
       }
 
@@ -439,11 +541,12 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     scard: string,
     isLimitOrder?: boolean,
     isIocOrder?: boolean,
-    pricesSlippage: number = 0.003,
-    collateralSlippage: number = 0.5,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
     relayerFee = BigInt(0.5),
     referralAddress?: string,
-    sender?: string): Promise<Transaction> {
+    sender?: string,
+  ): Promise<Transaction> {
     let tx = new Transaction()
     if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
       tx = await this.addReferral(referralAddress, tx)
@@ -468,7 +571,7 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
       transaction: tx,
       kioskClient,
       cap: kioskCap,
-    });
+    })
 
     const [sudoCard, promise] = kioskTx.borrow({
       itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
@@ -507,7 +610,7 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
       .return({
         itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
         item: sudoCard,
-        promise: promise,
+        promise,
       })
       .finalize()
     return tx
@@ -527,10 +630,14 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     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> {
+    coinObjects?: string[],
+  ): Promise<Transaction> {
+    if (!coinObjects) {
+      throw new Error(`${this.constructor.name}: coinObjects is required`)
+    }
     const tx = await this.initOracleTxb([collateralToken, indexToken])
 
     const kioskTx = new KioskTransaction({
@@ -554,7 +661,8 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     let allowTrade = ALLOW_TRADE_MUST_TRADE
     if (isTriggerOrder) {
       allowTrade = isIocOrder || !isTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
-    } else {
+    }
+    else {
       isTakeProfitOrder = true
     }
 
@@ -589,7 +697,7 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
       .return({
         itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
         item: sudoCard,
-        promise: promise,
+        promise,
       })
       .finalize()
     return tx
@@ -597,28 +705,30 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
 
   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): Promise<Transaction> {
+    tx?: Transaction,
+  ): Promise<Transaction> {
     if (!tx) {
-      tx = new Transaction();
+      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,
@@ -635,20 +745,32 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
       const {
         pcpId,
         collateralToken,
-        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),
+        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 || BigInt(0.5))])
 
-      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
       }
 
@@ -684,7 +806,7 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
       .return({
         itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
         item: sudoCard,
-        promise: promise,
+        promise,
       })
       .finalize()
     return tx
@@ -699,7 +821,7 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     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)
@@ -751,14 +873,14 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     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) {
@@ -790,16 +912,17 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     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()
     }
@@ -838,13 +961,13 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     return tx
   }
 
-
   public clearClosedPosition(
     pcpId: string,
     collateralToken: string,
     indexToken: string,
     long: boolean,
-    tx: Transaction): void {
+    tx: Transaction,
+  ): void {
     tx.moveCall({
       target: `${this.consts.zoCore.package}::market::clear_closed_position`,
       typeArguments: [
@@ -863,7 +986,8 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     indexToken: string,
     long: boolean,
     tx: Transaction,
-    isV11Order?: boolean): void {
+    isV11Order?: boolean,
+  ): void {
     const funcName = isV11Order ? 'clear_open_position_order' : 'clear_open_position_order'
     tx.moveCall({
       target: `${this.consts.zoCore.package}::market::${funcName}`,
@@ -884,7 +1008,8 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     indexToken: string,
     long: boolean,
     tx: Transaction,
-    isV11Order?: boolean): void {
+    isV11Order?: boolean,
+  ): void {
     const funcName = isV11Order ? 'clear_decrease_position_order' : 'clear_decrease_position_order'
     tx.moveCall({
       target: `${this.consts.zoCore.package}::market::${funcName}`,
@@ -901,7 +1026,7 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
 
   public addReferral(
     referralAddress: string,
-    tx?: Transaction
+    tx?: Transaction,
   ): Transaction {
     if (!tx) {
       tx = new Transaction()
@@ -917,19 +1042,19 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
 
   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({
@@ -954,7 +1079,7 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     return tx
   }
 
-  public async adminDecreasePosition(
+  public adminDecreasePosition(
     positionId: string,
     owner: string,
     collateralToken: string,
@@ -962,10 +1087,7 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     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)
 
@@ -997,14 +1119,14 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     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: [
@@ -1022,25 +1144,25 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     })
   }
 
-  public async adminIssueLootbox(
+  public adminIssueLootbox(
     coin: string,
     tiers: number[],
     beneficiaries: string[],
     amounts: number[],
     tx: Transaction,
-  ): Promise<void> {
-    let module = this.consts.zoCore.package + '::zlp::ZLP'
+  ): void {
+    let module = `${this.consts.zoCore.package}::zlp::ZLP`
     if (coin !== 'zlp') {
       module = this.consts.coins[coin].module
     }
-    for (let i = 0; i < beneficiaries.length; i++) {
+    for (const [i, beneficiary] of beneficiaries.entries()) {
       tx.moveCall({
         target: `${this.consts.zoLootbox.package}::lootbox::admin_issue_lootbox`,
         typeArguments: [module],
         arguments: [
           tx.object(this.consts.zoLootbox.adminCap),
           tx.pure.u8(tiers[i]),
-          tx.pure.address(beneficiaries[i]),
+          tx.pure.address(beneficiary),
           tx.pure.u64(amounts[i]),
           tx.pure.bool(amounts[i] > 0),
           tx.object(`${this.consts.zoLootbox.lootboxSettings}`),
@@ -1049,16 +1171,16 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     }
   }
 
-  public async depositToPrizePool(
+  public depositToPrizePool(
     coin: string,
     coinObjects: string[],
     amount: number,
-  ): Promise<Transaction> {
+  ): Transaction {
     const tx = new Transaction()
     const coinObject = this.processCoins(tx, coin, coinObjects)
     const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)])
 
-    let module = this.consts.zoCore.package + '::zlp::ZLP'
+    let module = `${this.consts.zoCore.package}::zlp::ZLP`
     if (coin !== 'zlp') {
       module = this.consts.coins[coin].module
     }
@@ -1075,13 +1197,13 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     return tx
   }
 
-  public async withdrawFromPricePool(
+  public withdrawFromPricePool(
     coin: string,
-    amount: number
-  ): Promise<Transaction> {
+    amount: number,
+  ): Transaction {
     const tx = new Transaction()
 
-    let module = this.consts.zoCore.package + '::zlp::ZLP'
+    let module = `${this.consts.zoCore.package}::zlp::ZLP`
     let metadata = this.consts.zoCore.zlpMetadata
     if (coin !== 'zlp') {
       module = this.consts.coins[coin].module
@@ -1101,13 +1223,13 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     return tx
   }
 
-  public async openLootbox(
+  public openLootbox(
     coin: string,
-    lootbox: string
-  ): Promise<Transaction> {
+    lootbox: string,
+  ): Transaction {
     const tx = new Transaction()
 
-    let module = this.consts.zoCore.package + '::zlp::ZLP'
+    let module = `${this.consts.zoCore.package}::zlp::ZLP`
     let metadata = this.consts.zoCore.zlpMetadata
     if (coin !== 'zlp') {
       module = this.consts.coins[coin].module
@@ -1127,4 +1249,4 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
 
     return tx
   }
-}
+}