@zofai/zo-sdk 0.1.92

package/src/api.ts

@@ -0,0 +1,1100 @@
+/* eslint-disable no-param-reassign */
+/* eslint-disable class-methods-use-this */
+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 type { Network } from './consts'
+import { ALLOW_TRADE_CAN_TRADE, ALLOW_TRADE_MUST_TRADE, ALLOW_TRADE_NO_TRADE } from './consts'
+import type { ICredential } from './data'
+import { DataAPI } from './data'
+import { joinSymbol } from './utils'
+
+export class API extends DataAPI {
+  private static instance: API
+
+  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+  constructor(
+    network: Network,
+    provider: SuiClient | null,
+    apiEndpoint: string,
+    connectionURL: string,
+  ) {
+    super(network, provider, apiEndpoint, connectionURL)
+  }
+
+  public static getInstance(
+    network: Network,
+    provider: SuiClient | null,
+    apiEndpoint: string,
+    connectionURL: string,
+  ): API {
+    if (!API.instance) {
+      API.instance = new API(network, provider, apiEndpoint, connectionURL)
+    }
+    return API.instance
+  }
+
+  #processCoins = (tx: Transaction, coin: string, coinObjects: string[]) => {
+    if (coin === 'sui') {
+      return tx.gas
+    }
+    if (coinObjects.length > 1) {
+      tx.mergeCoins(
+        tx.object(coinObjects[0]),
+        coinObjects.slice(1).map(coinObject => tx.object(coinObject)),
+      )
+    }
+    return tx.object(coinObjects[0])
+  }
+
+  #processSlippage(indexPrice: number, long: boolean, slippage: number) {
+    const raw = long ? indexPrice * (1 + slippage) : indexPrice * (1 - slippage)
+    return BigInt(Math.round(raw * 1e18))
+  }
+
+  deposit = async (
+    coin: string,
+    coinObjects: string[],
+    amount: number,
+    minAmountOut = 0,
+    referralAddress = '',
+    sender = '',
+  ) => {
+    let tx = new Transaction()
+    tx = await this.initOracleTxb(Object.keys(this.consts.pythFeeder.feeder), tx)
+    if (referralAddress && !(await this.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+
+    const coinObject = this.#processCoins(tx, coin, coinObjects)
+    const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)])
+
+    const { vaultsValuation, symbolsValuation } = this.valuate(tx)
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::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
+  }
+
+  withdraw = async (coin: string, zlpCoinObjects: string[], amount: number, minAmountOut = 0) => {
+    const tx = await this.initOracleTxb(Object.keys(this.consts.pythFeeder.feeder))
+    const zlpCoinObject = this.#processCoins(tx, 'zlp', zlpCoinObjects)
+    const [withdrawObject] = tx.splitCoins(zlpCoinObject, [tx.pure.u64(amount)])
+
+    const { vaultsValuation, symbolsValuation } = this.valuate(tx)
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::withdraw`,
+      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),
+        vaultsValuation,
+        symbolsValuation,
+      ],
+    })
+    return tx
+  }
+
+  openPosition = async (
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    collateralAmount: bigint,
+    coinObjects: string[],
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    isLimitOrder = false,
+    isIocOrder = false,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    referralAddress = '',
+    sender = '',
+  ) => {
+    let tx = new Transaction()
+    if (referralAddress && !(await this.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+    tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    const coinObject = this.#processCoins(tx, collateralToken, coinObjects)
+    const [depositObject, feeObject] = tx.splitCoins(coinObject, [
+      tx.pure.u64(collateralAmount),
+      tx.pure.u64(relayerFee),
+    ])
+
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+    const adjustPrice = this.#processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage)
+    const adjustCollateralPrice = this.#processSlippage(collateralPrice, false, collateralSlippage)
+
+    let allowTrade = ALLOW_TRADE_MUST_TRADE
+    if (isLimitOrder) {
+      allowTrade = isIocOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+    }
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::open_position`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins[collateralToken].module,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.zoCore.market),
+        tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+        tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+        tx.object(this.consts.zoCore.symbols[symbol].positionConfig),
+        tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+        tx.object(this.consts.pythFeeder.feeder[indexToken]),
+        depositObject,
+        feeObject,
+        tx.pure.u8(allowTrade),
+        tx.pure.u64(size),
+        tx.pure.u64(reserveAmount),
+        tx.pure.u256(adjustCollateralPrice),
+        tx.pure.u256(adjustPrice),
+      ],
+    })
+    return tx
+  }
+
+  openPositionWithSCard = async (
+    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 = false,
+    isIocOrder = false,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    referralAddress = '',
+    sender = '',
+  ) => {
+    let tx = new Transaction()
+    if (referralAddress && !(await this.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+    tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    const coinObject = this.#processCoins(tx, collateralToken, coinObjects)
+    const [depositObject, feeObject] = tx.splitCoins(coinObject, [
+      tx.pure.u64(collateralAmount),
+      tx.pure.u64(relayerFee),
+    ])
+
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+    const adjustPrice = this.#processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage)
+    const adjustCollateralPrice = this.#processSlippage(collateralPrice, false, collateralSlippage)
+
+    let allowTrade = ALLOW_TRADE_MUST_TRADE
+    if (isLimitOrder) {
+      allowTrade = isIocOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+    }
+
+    const kioskTx = new KioskTransaction({
+      transaction: tx,
+      kioskClient,
+      cap: kioskCap,
+    })
+
+    const [sudoCard, promise] = kioskTx.borrow({
+      itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+      itemId: scard,
+    })
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::open_position_with_scard`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins[collateralToken].module,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.zoCore.market),
+        tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+        tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+        tx.object(this.consts.zoCore.symbols[symbol].positionConfig),
+        tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+        tx.object(this.consts.pythFeeder.feeder[indexToken]),
+        depositObject,
+        feeObject,
+        tx.pure.u8(allowTrade),
+        tx.pure.u64(size),
+        tx.pure.u64(reserveAmount),
+        tx.pure.u256(adjustCollateralPrice),
+        tx.pure.u256(adjustPrice),
+        sudoCard,
+      ],
+    })
+
+    kioskTx
+      .return({
+        itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+        item: sudoCard,
+        promise,
+      })
+      .finalize()
+    return tx
+  }
+
+  pledgeInPosition = async (
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: number,
+    coinObjects: string[],
+    long: boolean,
+  ) => {
+    const tx = await this.initOracleTxb([collateralToken, indexToken])
+    const coinObject = this.#processCoins(tx, collateralToken, coinObjects)
+    const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)])
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::pledge_in_position`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+      ],
+      arguments: [tx.object(this.consts.zoCore.market), tx.object(pcpId), depositObject],
+    })
+    return tx
+  }
+
+  redeemFromPosition = async (
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: number,
+    long: boolean,
+  ) => {
+    const tx = await this.initOracleTxb([collateralToken, indexToken])
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::redeem_from_position`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.zoCore.market),
+        tx.object(pcpId),
+        tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+        tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+        tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+        tx.object(this.consts.pythFeeder.feeder[indexToken]),
+        tx.pure.u64(amount),
+      ],
+    })
+
+    return tx
+  }
+
+  decreasePosition = async (
+    pcpId: string,
+    collateralToken: string,
+    coinObjects: string[],
+    indexToken: string,
+    amount: bigint,
+    long: boolean,
+    indexPrice: number,
+    collateralPrice: number,
+    isTriggerOrder = false,
+    isTakeProfitOrder = true,
+    isIocOrder = false,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+  ) => {
+    const tx = await this.initOracleTxb([collateralToken, indexToken])
+    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 : pricesSlippage)
+    const adjustCollateralPrice = this.#processSlippage(collateralPrice, false, collateralSlippage)
+
+    let allowTrade = ALLOW_TRADE_MUST_TRADE
+    if (isTriggerOrder) {
+      allowTrade = isIocOrder || !isTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+    }
+    else {
+      isTakeProfitOrder = true
+    }
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::decrease_position`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins[collateralToken].module,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.zoCore.market),
+        tx.object(pcpId),
+        tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+        tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+        tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+        tx.object(this.consts.pythFeeder.feeder[indexToken]),
+        feeObject,
+        tx.pure.u8(allowTrade),
+        tx.pure.bool(isTakeProfitOrder),
+        tx.pure.u64(amount),
+        tx.pure.u256(adjustCollateralPrice),
+        tx.pure.u256(adjustPrice),
+      ],
+    })
+
+    return tx
+  }
+
+  decreasePositionWithSCard = async (
+    pcpId: string,
+    collateralToken: string,
+    coinObjects: string[],
+    indexToken: string,
+    amount: bigint,
+    long: boolean,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    isTriggerOrder = false,
+    isTakeProfitOrder = true,
+    isIocOrder = false,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+  ) => {
+    const tx = await this.initOracleTxb([collateralToken, indexToken])
+
+    const kioskTx = new KioskTransaction({
+      transaction: tx,
+      kioskClient,
+      cap: kioskCap,
+    })
+
+    const [sudoCard, promise] = kioskTx.borrow({
+      itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+      itemId: scard,
+    })
+
+    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 : pricesSlippage)
+    const adjustCollateralPrice = this.#processSlippage(collateralPrice, false, collateralSlippage)
+
+    let allowTrade = ALLOW_TRADE_MUST_TRADE
+    if (isTriggerOrder) {
+      allowTrade = isIocOrder || !isTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+    }
+    else {
+      isTakeProfitOrder = true
+    }
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::decrease_position_with_scard`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins[collateralToken].module,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.zoCore.market),
+        tx.object(pcpId),
+        tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+        tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+        tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+        tx.object(this.consts.pythFeeder.feeder[indexToken]),
+        feeObject,
+        tx.pure.u8(allowTrade),
+        tx.pure.bool(isTakeProfitOrder),
+        tx.pure.u64(amount),
+        tx.pure.u256(adjustCollateralPrice),
+        tx.pure.u256(adjustPrice),
+        sudoCard,
+      ],
+    })
+
+    kioskTx
+      .return({
+        itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+        item: sudoCard,
+        promise,
+      })
+      .finalize()
+    return tx
+  }
+
+  decreaseMultiPositions = async (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) => {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    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,
+      } = 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)
+
+      let allowTrade = ALLOW_TRADE_MUST_TRADE
+      if (isTriggerOrder) {
+        allowTrade = isIocOrder || !innerIsTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+      }
+      else {
+        innerIsTakeProfitOrder = true
+      }
+
+      tx.moveCall({
+        target: `${this.consts.zoCore.upgradedPackage}::market::decrease_position`,
+        typeArguments: [
+          `${this.consts.zoCore.package}::zlp::ZLP`,
+          this.consts.coins[collateralToken].module,
+          this.consts.coins[indexToken].module,
+          `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+          this.consts.coins[collateralToken].module,
+        ],
+        arguments: [
+          tx.object(SUI_CLOCK_OBJECT_ID),
+          tx.object(this.consts.zoCore.market),
+          tx.object(pcpId),
+          tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+          tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+          tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+          tx.object(this.consts.pythFeeder.feeder[indexToken]),
+          feeObject,
+          tx.pure.u8(allowTrade),
+          tx.pure.bool(innerIsTakeProfitOrder),
+          tx.pure.u64(amount),
+          tx.pure.u256(adjustCollateralPrice),
+          tx.pure.u256(adjustPrice),
+        ],
+      })
+    }
+    return tx
+  }
+
+  decreaseMultiPositionsWithSCard = async (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
+  }>, kioskClient: KioskClient, kioskCap: KioskOwnerCap, scard: string, tx?: Transaction) => {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    tx = await this.initOracleTxb(positions.flatMap(position => [position.collateralToken, position.indexToken]), tx)
+
+    const kioskTx = new KioskTransaction({
+      transaction: tx,
+      kioskClient,
+      cap: kioskCap,
+    })
+
+    const [sudoCard, promise] = kioskTx.borrow({
+      itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+      itemId: scard,
+    })
+
+    for (const position of positions) {
+      const {
+        pcpId,
+        collateralToken,
+        coinObjects,
+        indexToken,
+        amount,
+        long,
+        indexPrice,
+        collateralPrice,
+        isTriggerOrder,
+        isTakeProfitOrder,
+        isIocOrder,
+        slippage,
+        relayerFee,
+      } = 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)
+
+      let allowTrade = ALLOW_TRADE_MUST_TRADE
+      if (isTriggerOrder) {
+        allowTrade = isIocOrder || !innerIsTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+      }
+      else {
+        innerIsTakeProfitOrder = true
+      }
+
+      tx.moveCall({
+        target: `${this.consts.zoCore.upgradedPackage}::market::decrease_position_with_scard`,
+        typeArguments: [
+          `${this.consts.zoCore.package}::zlp::ZLP`,
+          this.consts.coins[collateralToken].module,
+          this.consts.coins[indexToken].module,
+          `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+          this.consts.coins[collateralToken].module,
+        ],
+        arguments: [
+          tx.object(SUI_CLOCK_OBJECT_ID),
+          tx.object(this.consts.zoCore.market),
+          tx.object(pcpId),
+          tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+          tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+          tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+          tx.object(this.consts.pythFeeder.feeder[indexToken]),
+          feeObject,
+          tx.pure.u8(allowTrade),
+          tx.pure.bool(innerIsTakeProfitOrder),
+          tx.pure.u64(amount),
+          tx.pure.u256(adjustCollateralPrice),
+          tx.pure.u256(adjustPrice),
+          sudoCard,
+        ],
+      })
+    }
+
+    kioskTx
+      .return({
+        itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+        item: sudoCard,
+        promise,
+      })
+      .finalize()
+    return tx
+  }
+
+  cancelOrder = (
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    type: string,
+    isV11Order = false,
+  ) => {
+    const tx = new Transaction()
+    let functionName = ''
+    switch (type) {
+      case 'OPEN_POSITION': {
+        functionName = isV11Order ? 'clear_open_position_order' : 'clear_open_position_order'
+        break
+      }
+      case 'DECREASE_POSITION': {
+        functionName = isV11Order
+          ? 'clear_decrease_position_order'
+          : 'clear_decrease_position_order'
+        break
+      }
+      default: {
+        throw new Error('invalid order type')
+      }
+    }
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::${functionName}`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins[collateralToken].module,
+      ],
+      arguments: [tx.object(this.consts.zoCore.market), tx.object(orderCapId)],
+    })
+    return tx
+  }
+
+  cancelMultiOrder = (orders: Array<{
+    orderCapId: string
+    collateralToken: string
+    indexToken: string
+    long: boolean
+    type: string
+    isV11Order: boolean
+  }>, tx?: Transaction) => {
+    if (!tx) {
+      tx = new Transaction()
+    }
+
+    for (const order of orders) {
+      const { orderCapId, collateralToken, indexToken, long, type, isV11Order } = order
+      let functionName = ''
+      switch (type) {
+        case 'OPEN_POSITION': {
+          functionName = isV11Order ? 'clear_open_position_order' : 'clear_open_position_order'
+          break
+        }
+        case 'DECREASE_POSITION': {
+          functionName = isV11Order
+            ? 'clear_decrease_position_order'
+            : 'clear_decrease_position_order'
+          break
+        }
+        default: {
+          throw new Error('invalid order type')
+        }
+      }
+
+      tx.moveCall({
+        target: `${this.consts.zoCore.upgradedPackage}::market::${functionName}`,
+        typeArguments: [
+          `${this.consts.zoCore.package}::zlp::ZLP`,
+          this.consts.coins[collateralToken].module,
+          this.consts.coins[indexToken].module,
+          `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+          this.consts.coins[collateralToken].module,
+        ],
+        arguments: [tx.object(this.consts.zoCore.market), tx.object(orderCapId)],
+      })
+    }
+    return tx
+  }
+
+  swap = async (
+    fromToken: string,
+    toToken: string,
+    fromAmount: bigint,
+    fromCoinObjects: string[],
+  ) => {
+    const tx = await this.initOracleTxb(Object.keys(this.consts.zoCore.vaults))
+    const fromCoinObject = this.#processCoins(tx, fromToken, fromCoinObjects)
+    const [fromDepositObject] = tx.splitCoins(fromCoinObject, [tx.pure.u64(fromAmount)])
+    const vaultsValuation = this.valuateVaults(tx)
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::swap`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[fromToken].module,
+        this.consts.coins[toToken].module,
+      ],
+      arguments: [
+        tx.object(this.consts.zoCore.market),
+        tx.object(this.consts.zoCore.rebaseFeeModel),
+        fromDepositObject,
+        // FIXME: minAmountOut
+        tx.pure.u64(0),
+        vaultsValuation,
+      ],
+    })
+    return tx
+  }
+
+  clearClosedPosition = (
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+  ) => {
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::clear_closed_position`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+      ],
+      arguments: [tx.object(this.consts.zoCore.market), tx.object(pcpId)],
+    })
+  }
+
+  clearOpenPositionOrder = (
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+    isV11Order = false,
+  ) => {
+    const funcName = isV11Order ? 'clear_open_position_order' : 'clear_open_position_order'
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::${funcName}`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins[collateralToken].module,
+      ],
+      arguments: [tx.object(this.consts.zoCore.market), tx.object(orderCapId)],
+    })
+  }
+
+  clearDecreasePositionOrder = (
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+    isV11Order = false,
+  ) => {
+    const funcName = isV11Order ? 'clear_decrease_position_order' : 'clear_decrease_position_order'
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::${funcName}`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins[collateralToken].module,
+      ],
+      arguments: [tx.object(this.consts.zoCore.market), tx.object(orderCapId)],
+    })
+  }
+
+  stake = (coinObjects: string[], amount: bigint, pool: string, tx?: Transaction | undefined) => {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    const coinObject = this.#processCoins(tx, 'zlp', coinObjects)
+    const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)])
+
+    tx.moveCall({
+      target: `${this.consts.zoStaking.package}::pool::deposit`,
+      typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`, this.consts.coins.sui.module],
+      arguments: [tx.object(pool), tx.object(SUI_CLOCK_OBJECT_ID), depositObject],
+    })
+
+    return tx
+  }
+
+  unstake = (
+    credentials: ICredential[],
+    amount: bigint,
+    pool: string,
+    tx?: Transaction | undefined,
+  ) => {
+    if (!tx) {
+      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
+      amount -= withdrawAmount
+      tx.moveCall({
+        target: `0xdb353cb79a88d5ee83b7c0ca0249662a1facab17ba62879080ea3d61b9d21112::pool::withdraw`,
+        typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`, this.consts.coins.sui.module],
+        arguments: [
+          tx.object(pool),
+          tx.object(SUI_CLOCK_OBJECT_ID),
+          tx.object(credential.id),
+          tx.pure.u64(withdrawAmount),
+        ],
+      })
+      if (credential.amount === BigInt(0)) {
+        tx.moveCall({
+          target: `${this.consts.zoStaking.package}::pool::clear_empty_credential`,
+          typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`, this.consts.coins.sui.module],
+          arguments: [tx.object(credential.id)],
+        })
+      }
+    }
+
+    return tx
+  }
+
+  addReferral = (referrer: string, tx?: Transaction | undefined) => {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::add_new_referral`,
+      typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`],
+      arguments: [tx.object(this.consts.zoCore.market), tx.object(referrer)],
+    })
+
+    return tx
+  }
+
+  // admin methods
+  adminUpdatePriceFeed = async (collateralToken: string, indexToken: string) => {
+    const tx = await this.initOracleTxb([collateralToken, indexToken])
+    return tx
+  }
+
+  adminSettlePosition = (
+    positionId: string,
+    owner: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+  ) => {
+    const tx = new Transaction()
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::force_settle_position`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+      ],
+      arguments: [
+        tx.object(this.consts.zoCore.adminCap),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.zoCore.market),
+        tx.object(owner),
+        tx.object(positionId),
+      ],
+    })
+
+    this.adminClearClosedPosition(positionId, owner, collateralToken, indexToken, long, tx)
+
+    return tx
+  }
+
+  adminDecreasePosition = (
+    positionId: string,
+    owner: string,
+    collateralToken: string,
+    indexToken: string,
+    positionAmount: number,
+    amount: bigint,
+    long: boolean,
+  ) => {
+    const tx = new Transaction()
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::force_close_position`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+      ],
+      arguments: [
+        tx.object(this.consts.zoCore.adminCap),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.zoCore.market),
+        tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+        tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+        tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+        tx.object(this.consts.pythFeeder.feeder[indexToken]),
+        tx.object(owner),
+        tx.object(positionId),
+      ],
+    })
+
+    if (amount === BigInt(positionAmount)) {
+      this.adminClearClosedPosition(positionId, owner, collateralToken, indexToken, long, tx)
+    }
+
+    return tx
+  }
+
+  adminClearClosedPosition = (
+    positionId: string,
+    owner: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+  ) => {
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::force_clear_closed_position`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+      ],
+      arguments: [
+        tx.object(this.consts.zoCore.adminCap),
+        tx.object(this.consts.zoCore.market),
+        tx.object(positionId),
+        tx.object(owner),
+      ],
+    })
+  }
+
+  // ZO Lootbox
+  adminIssueLootbox = (
+    coin: string,
+    tiers: number[],
+    beneficiaries: string[],
+    amounts: number[],
+    tx: Transaction,
+  ) => {
+    let module = `${this.consts.zoCore.package}::zlp::ZLP`
+    if (coin !== 'zlp') {
+      module = this.consts.coins[coin].module
+    }
+    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(beneficiary),
+          tx.pure.u64(amounts[i]),
+          tx.pure.bool(amounts[i] > 0),
+          tx.object(`${this.consts.zoLootbox.lootboxSettings}`),
+        ],
+      })
+    }
+  }
+
+  depositToPrizePool = (
+    coin: string,
+    coinObjects: string[],
+    amount: number,
+  ) => {
+    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`
+    if (coin !== 'zlp') {
+      module = this.consts.coins[coin].module
+    }
+
+    tx.moveCall({
+      target: `${this.consts.zoLootbox.package}::lootbox::deposit`,
+      typeArguments: [module],
+      arguments: [
+        tx.object(this.consts.zoLootbox.adminCap),
+        tx.object(this.consts.zoLootbox.lootboxTreasury),
+        depositObject,
+      ],
+    })
+    return tx
+  }
+
+  withdrawFromPricePool = (coin: string, amount: number) => {
+    const tx = new Transaction()
+
+    let module = `${this.consts.zoCore.package}::zlp::ZLP`
+    let metadata = this.consts.zoCore.zlpMetadata
+    if (coin !== 'zlp') {
+      module = this.consts.coins[coin].module
+      metadata = this.consts.coins[coin].metadata
+    }
+
+    tx.moveCall({
+      target: `${this.consts.zoLootbox.package}::lootbox::withdraw`,
+      typeArguments: [module],
+      arguments: [
+        tx.object(this.consts.zoLootbox.adminCap),
+        tx.object(this.consts.zoLootbox.lootboxTreasury),
+        tx.object(metadata),
+        tx.pure.u64(amount),
+      ],
+    })
+    return tx
+  }
+
+  openLootbox = (coin: string, lootbox: string) => {
+    const tx = new Transaction()
+
+    let module = `${this.consts.zoCore.package}::zlp::ZLP`
+    let metadata = this.consts.zoCore.zlpMetadata
+    if (coin !== 'zlp') {
+      module = this.consts.coins[coin].module
+      metadata = this.consts.coins[coin].metadata
+    }
+
+    tx.moveCall({
+      target: `${this.consts.zoLootbox.package}::lootbox::open_lootbox`,
+      typeArguments: [module],
+      arguments: [
+        tx.object(`${this.consts.zoLootbox.lootboxTreasury}`),
+        tx.object(lootbox),
+        tx.object(metadata),
+        tx.object(`${this.consts.zoLootbox.lootboxSettings}`),
+      ],
+    })
+
+    return tx
+  }
+}