zo-sdk 0.0.50 → 0.1.0

package/src/implementations/SLPAPI.ts

@@ -0,0 +1,1207 @@
+/**
+ * SLP API implementation
+ * Implements SLP-specific trading and transaction methods for Sudo SDK
+ */
+
+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, LPToken } from '../consts'
+import type {
+  ISLPAPI,
+  ISLPCredential,
+  IBaseOrderCapInfo,
+  IBaseOrderInfo,
+  IBasePositionCapInfo,
+  IBasePositionConfig,
+  IBasePositionInfo,
+  IBaseStaked,
+  IBaseHistoryResponse,
+  IBaseMarketInfo,
+  IBaseMarketValuationInfo,
+  IBaseSymbolInfo,
+  IBaseVaultInfo,
+  IBaseRebaseFeeModel,
+  IBaseStakePool
+} from '../interfaces'
+import { BaseAPI } from '../abstract'
+import { SLPDataAPI } from './SLPDataAPI'
+import { joinSymbol } from '../utils'
+import { KioskClient, KioskOwnerCap, KioskTransaction } from '@mysten/kiosk'
+
+export class SLPAPI extends BaseAPI implements ISLPAPI {
+  public dataAPI: SLPDataAPI
+
+  constructor(
+    network: Network,
+    provider: SuiClient,
+    apiEndpoint: string,
+    connectionURL: string
+  ) {
+    super(network, provider, apiEndpoint, connectionURL, LPToken.SLP)
+    this.dataAPI = new SLPDataAPI(network, provider, apiEndpoint, connectionURL)
+  }
+
+  public valuateVaults(tx: Transaction) {
+    throw new Error('Method not implemented.')
+  }
+  public valuateSymbols(tx: Transaction) {
+    throw new Error('Method not implemented.')
+  }
+  public valuate(tx: Transaction): { vaultsValuation: any; symbolsValuation: any } {
+    throw new Error('Method not implemented.')
+  }
+  public valuateMarket(): Promise<IBaseMarketValuationInfo> {
+    throw new Error('Method not implemented.')
+  }
+  public fundingFeeRate(indexToken: string, long: boolean, sender?: string): Promise<number> {
+    throw new Error('Method not implemented.')
+  }
+  public rebaseFeeRate(collateralToken: string, increase: boolean, amount: number, sender?: string): Promise<number> {
+    throw new Error('Method not implemented.')
+  }
+  public reservingFeeRate(collateralToken: string, amount: number, sender?: string): Promise<number> {
+    throw new Error('Method not implemented.')
+  }
+  public calcPositionReserveFeeAmount(position: IBasePositionInfo): Promise<number> {
+    throw new Error('Method not implemented.')
+  }
+  public calcPositionFundingFeeValue(position: IBasePositionInfo): Promise<number> {
+    throw new Error('Method not implemented.')
+  }
+  public getMarketInfo(): Promise<IBaseMarketInfo> {
+    throw new Error('Method not implemented.')
+  }
+  public getVaultInfo(vault: string): Promise<IBaseVaultInfo> {
+    throw new Error('Method not implemented.')
+  }
+  public getSymbolInfo(tokenId: string, long: boolean): Promise<IBaseSymbolInfo> {
+    throw new Error('Method not implemented.')
+  }
+  public getPositionConfig(indexToken: string, long: boolean): Promise<IBasePositionConfig> {
+    throw new Error('Method not implemented.')
+  }
+  public getRebaseFeeModel(): Promise<IBaseRebaseFeeModel> {
+    throw new Error('Method not implemented.')
+  }
+  public getOpenPositions(): Promise<IBasePositionInfo[]> {
+    throw new Error('Method not implemented.')
+  }
+  public getPositionCapInfoList(owner: string): Promise<IBasePositionCapInfo[]> {
+    throw new Error('Method not implemented.')
+  }
+  public getPositionInfoList(positionCapInfoList: IBasePositionCapInfo[], owner: string): Promise<IBasePositionInfo[]> {
+    throw new Error('Method not implemented.')
+  }
+  public getOrderCapInfoList(owner: string): Promise<IBaseOrderCapInfo[]> {
+    throw new Error('Method not implemented.')
+  }
+  public getOrderInfoList(orderCapInfoList: IBaseOrderCapInfo[], owner: string): Promise<IBaseOrderInfo[]> {
+    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.')
+  }
+  public getStaked(owner: string): Promise<IBaseStaked> {
+    throw new Error('Method not implemented.')
+  }
+  public getStakePool(): Promise<IBaseStakePool> {
+    throw new Error('Method not implemented.')
+  }
+  public hasReferral(referree: string): Promise<boolean> {
+    throw new Error('Method not implemented.')
+  }
+  public getReferralData(referree: string): Promise<any> {
+    throw new Error('Method not implemented.')
+  }
+
+  /**
+   * Deposits collateral into SLP vault using Sudo SDK approach
+   */
+  public async deposit(
+    coin: string,
+    coinObjects: string[],
+    amount: number,
+    minAmountOut?: number,
+    referralAddress?: string,
+    sender?: string
+  ): Promise<Transaction> {
+    let tx = new Transaction()
+    if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+    tx = await this.initOracleTxb(
+      Object.keys(this.consts.pythFeeder.feeder),
+    )
+    const coinObject = this.processCoins(tx, coin, coinObjects)
+    const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)])
+
+    const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx)
+
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::deposit`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[coin].module,
+      ],
+      arguments: [
+        tx.object(this.consts.sudoCore.market),
+        tx.object(this.consts.sudoCore.rebaseFeeModel),
+        depositObject,
+        tx.pure.u64(minAmountOut || 0),
+        vaultsValuation,
+        symbolsValuation,
+      ],
+    })
+    return tx
+  }
+
+  /**
+   * Withdraws collateral from SLP vault using Sudo SDK approach
+   */
+  public async withdraw(
+    coin: string,
+    lpCoinObjects: string[],
+    amount: number,
+    minAmountOut?: number
+  ): Promise<Transaction> {
+    const tx = await this.initOracleTxb(
+      Object.keys(this.consts.pythFeeder.feeder),
+    )
+    const lpCoinObject = this.processCoins(tx, `${this.consts.sudoCore.package}::slp::SLP`, lpCoinObjects)
+    const [withdrawObject] = tx.splitCoins(lpCoinObject, [tx.pure.u64(amount)])
+    const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx)
+
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::withdraw`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[coin].module,
+      ],
+      arguments: [
+        tx.object(this.consts.sudoCore.market),
+        tx.object(this.consts.sudoCore.rebaseFeeModel),
+        withdrawObject,
+        tx.pure.u64(minAmountOut || 0),
+        vaultsValuation,
+        symbolsValuation,
+      ],
+    })
+    return tx
+  }
+
+  public async swap(
+    fromToken: string,
+    toToken: string,
+    fromAmount: bigint,
+    fromCoinObjects: string[],
+    minAmountOut?: number
+  ): Promise<Transaction> {
+    const tx = await this.initOracleTxb(
+      Object.keys(this.consts.sudoCore.vaults)
+    )
+    const fromCoinObject = this.processCoins(tx, fromToken, fromCoinObjects)
+    const [fromDepositObject] = tx.splitCoins(fromCoinObject, [
+      tx.pure.u64(fromAmount),
+    ])
+    const vaultsValuation = this.dataAPI.valuateVaults(tx)
+
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::swap`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[fromToken].module,
+        this.consts.coins[toToken].module,
+      ],
+      arguments: [
+        tx.object(this.consts.sudoCore.market),
+        tx.object(this.consts.sudoCore.rebaseFeeModel),
+        fromDepositObject,
+        tx.pure.u64(minAmountOut || 0),
+        vaultsValuation,
+      ],
+    })
+    return tx
+  }
+
+  /**
+   * Stakes SLP tokens in Sudo staking pools
+   */
+  public async stake(
+    lpCoinObjects: string[],
+    amount: bigint,
+    pool: string
+  ): Promise<Transaction> {
+    if (!this.consts.sudoStaking) {
+      throw new Error('Sudo staking configuration not found')
+    }
+
+    const tx = new Transaction()
+    const coinObject = this.processCoins(tx, 'slp', lpCoinObjects)
+    const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)])
+
+    tx.moveCall({
+      target: `${this.consts.sudoStaking.package}::pool::deposit`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        `${this.consts.sudoCore.package}::slp::SLP`,
+      ],
+      arguments: [
+        tx.object(pool),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        depositObject,
+      ],
+    })
+    return tx
+  }
+
+  /**
+   * Unstakes SLP tokens from Sudo staking pools
+   */
+  public async unstake(
+    credentials: ISLPCredential[],
+    amount: bigint,
+    pool: string
+  ): Promise<Transaction> {
+    if (!this.consts.sudoStaking) {
+      throw new Error('Sudo staking configuration not found')
+    }
+
+    const tx = new Transaction()
+
+    for (const credential of credentials) {
+      // eslint-disable-next-line unicorn/prefer-math-min-max
+      const withdrawAmount =
+        amount < credential.amount ? amount : credential.amount
+      amount -= withdrawAmount
+      tx.moveCall({
+        target: `${this.consts.sudoStaking.package}::pool::withdraw`,
+        typeArguments: [
+          `${this.consts.sudoCore.package}::slp::SLP`,
+          `${this.consts.sudoCore.package}::slp::SLP`,
+        ],
+        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.sudoStaking.package}::pool::clear_empty_credential`,
+          typeArguments: [
+            `${this.consts.sudoCore.package}::slp::SLP`,
+            `${this.consts.sudoCore.package}::slp::SLP`,
+          ],
+          arguments: [tx.object(credential.id)],
+        })
+      }
+    }
+    return tx
+  }
+
+  /**
+   * Opens a position using Sudo SDK approach
+   */
+  public async openPosition(
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    collateralAmount: bigint,
+    coinObjects: string[],
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    isLimitOrder = false,
+    isIocOrder = false,
+    pricesSlippage: number = 0.003,
+    collateralSlippage: number = 0.5,
+    relayerFee = BigInt(0.5),
+    referralAddress?: string,
+    sender?: string
+  ): Promise<Transaction> {
+    let tx = new Transaction()
+    if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+    tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    const coinObject = this.processCoins(tx, collateralToken, coinObjects)
+    const [depositObject] = tx.splitCoins(coinObject, [
+      tx.pure.u64(collateralAmount),
+    ])
+    const feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee || BigInt(0.5))]) // Sudo contract requires SUI as fee
+
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+    const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage || 0.003)
+    const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage || 0.5)
+
+    let allowTrade = ALLOW_TRADE_MUST_TRADE
+    if (isLimitOrder) {
+      allowTrade = isIocOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+    }
+
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_v1_2`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins['sui'].module,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(
+          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel
+        ),
+        tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+        tx.object(this.consts.sudoCore.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),
+        tx.pure.bool(isLimitOrder),
+      ],
+    })
+    return tx
+  }
+
+  /**
+   * Decreases an existing position in SLP using Sudo SDK approach
+   */
+  public async decreasePosition(
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: bigint,
+    long: boolean,
+    indexPrice: number,
+    collateralPrice: number,
+    isTriggerOrder = false,
+    isTakeProfitOrder = true,
+    isIocOrder = false,
+    pricesSlippage: number = 0.003,
+    collateralSlippage: number = 0.5,
+    relayerFee = BigInt(0.5),
+    coinObjects?: string[]
+  ): Promise<Transaction> {
+    const tx = await this.initOracleTxb([collateralToken, indexToken])
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+    const feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee)]) // Sudo contract requires SUI as fee
+
+    const adjustPrice = this.processSlippage(
+      indexPrice,
+      !long,
+      isTriggerOrder ? 0 : pricesSlippage
+    )
+    const adjustCollateralPrice = this.processSlippage(
+      collateralPrice,
+      false,
+      collateralSlippage
+    )
+
+    let allowTrade = ALLOW_TRADE_MUST_TRADE
+    if (isTriggerOrder) {
+      if (isIocOrder || !isTakeProfitOrder) {
+        allowTrade = ALLOW_TRADE_NO_TRADE
+      } else {
+        allowTrade = ALLOW_TRADE_CAN_TRADE
+      }
+    } else {
+      isTakeProfitOrder = true
+    }
+
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v1_2`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins['sui'].module,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(pcpId),
+        tx.object(
+          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel
+        ),
+        tx.object(this.consts.sudoCore.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),
+        tx.pure.bool(isTriggerOrder),
+      ],
+    })
+
+    return tx
+  }
+
+  public async decreaseMultiPositions(
+    positions: Array<{
+      pcpId: string,
+      collateralToken: string,
+      coinObjects: string[],
+      indexToken: string,
+      amount: bigint,
+      long: boolean,
+      indexPrice: number,
+      collateralPrice: number,
+      isTriggerOrder: boolean,
+      isTakeProfitOrder: boolean,
+      isIocOrder: boolean,
+      slippage: number,
+      relayerFee: bigint,
+    }>, tx?: Transaction
+  ): Promise<Transaction> {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    tx = await this.initOracleTxb(positions.map(position => [position.collateralToken, position.indexToken]).flat(), 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.sudoCore.upgradedPackage}::market::decrease_position_v1_2`,
+        typeArguments: [
+          `${this.consts.sudoCore.package}::slp::SLP`,
+          this.consts.coins[collateralToken].module,
+          this.consts.coins[indexToken].module,
+          `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+          this.consts.coins['sui'].module,
+        ],
+        arguments: [
+          tx.object(SUI_CLOCK_OBJECT_ID),
+          tx.object(this.consts.sudoCore.market),
+          tx.object(pcpId),
+          tx.object(
+            this.consts.sudoCore.vaults[collateralToken].reservingFeeModel
+          ),
+          tx.object(this.consts.sudoCore.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),
+          tx.pure.bool(isTriggerOrder),
+        ],
+      })
+    }
+    return tx
+  }
+
+  public async pledgeInPosition(
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: number,
+    coinObjects: string[],
+    long: boolean
+  ): Promise<Transaction> {
+    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.sudoCore.upgradedPackage}::market::pledge_in_position`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+      ],
+      arguments: [
+        tx.object(this.consts.sudoCore.market),
+        tx.object(pcpId),
+        depositObject,
+      ],
+    })
+    return tx
+  }
+
+  public async redeemFromPosition(
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: number,
+    long: boolean
+  ): Promise<Transaction> {
+    const tx = await this.initOracleTxb([collateralToken, indexToken])
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::redeem_from_position_v1_1`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(pcpId),
+        tx.object(
+          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel
+        ),
+        tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+        tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+        tx.object(this.consts.pythFeeder.feeder[indexToken]),
+        tx.pure.u64(amount),
+      ],
+    })
+
+    return tx
+  }
+
+  public async cancelOrder(
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    type: string,
+    isV11Order?: boolean
+  ): Promise<Transaction> {
+    const tx = new Transaction()
+    let functionName = ''
+    switch (type) {
+      case 'OPEN_POSITION':
+        functionName = 'clear_open_position_order_v1_1'
+        break
+      case 'DECREASE_POSITION':
+        functionName = 'clear_decrease_position_order_v1_1'
+        break
+      default:
+        throw new Error('invalid order type')
+    }
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::${functionName}`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins['sui'].module,
+      ],
+      arguments: [
+        tx.object(this.consts.sudoCore.market),
+        tx.object(orderCapId),
+      ],
+    })
+    return tx
+  }
+
+  public async cancelMultiOrders(
+    orders: Array<{
+      orderCapId: string,
+      collateralToken: string,
+      indexToken: string,
+      long: boolean,
+      type: string,
+      isV11Order?: boolean
+    }>, tx?: Transaction
+  ): Promise<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_v1_1' : 'clear_open_position_order_v1_1'
+          break
+        }
+        case 'DECREASE_POSITION': {
+          functionName = isV11Order
+            ? 'clear_decrease_position_order_v1_1'
+            : 'clear_decrease_position_order_v1_1'
+          break
+        }
+        default: {
+          throw new Error('invalid order type')
+        }
+      }
+
+      tx.moveCall({
+        target: `${this.consts.sudoCore.upgradedPackage}::market::${functionName}`,
+        typeArguments: [
+          `${this.consts.sudoCore.package}::slp::SLP`,
+          this.consts.coins[collateralToken].module,
+          this.consts.coins[indexToken].module,
+          `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+          this.consts.coins[collateralToken].module,
+        ],
+        arguments: [tx.object(this.consts.sudoCore.market), tx.object(orderCapId)],
+      })
+    }
+    return tx
+  }
+
+  public clearClosedPosition(
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+  ): void {
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::clear_closed_position`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+      ],
+      arguments: [tx.object(this.consts.sudoCore.market), tx.object(pcpId)],
+    })
+  }
+
+  public clearOpenPositionOrder(
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+    isV11Order?: boolean
+  ): void {
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::clear_open_position_order_v1_1`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins['sui'].module,
+      ],
+      arguments: [
+        tx.object(this.consts.sudoCore.market),
+        tx.object(orderCapId),
+      ],
+    })
+  }
+
+  public clearDecreasePositionOrder(
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction
+  ): void {
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::clear_decrease_position_order_v1_1`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins['sui'].module,
+      ],
+      arguments: [
+        tx.object(this.consts.sudoCore.market),
+        tx.object(orderCapId),
+      ],
+    })
+  }
+
+  public async 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 = false,
+    isIocOrder = false,
+    pricesSlippage?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint,
+    referralAddress?: string,
+    sender?: string,
+  ): Promise<Transaction> {
+    let tx = new Transaction()
+    if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+    tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    const coinObject = this.processCoins(tx, collateralToken, coinObjects)
+    const [depositObject] = tx.splitCoins(coinObject, [
+      tx.pure.u64(collateralAmount),
+    ])
+    const feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee || BigInt(0.5))]) // Sudo contract requires SUI as fee
+
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+    const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage || 0.003)
+    const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage || 0.5)
+
+    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: `${this.consts.sudoNft.package}::card::SudoCard`,
+      itemId: scard,
+    })
+
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_v1_3`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins['sui'].module,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(
+          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel
+        ),
+        tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+        tx.object(this.consts.sudoCore.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),
+        tx.pure.bool(isLimitOrder),
+        sudoCard,
+      ],
+    })
+
+    kioskTx
+      .return({
+        itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+        item: sudoCard,
+        promise: promise,
+      })
+      .finalize()
+    return tx
+  }
+
+  public async decreasePositionWithSCard(
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: bigint,
+    long: boolean,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    isTriggerOrder = false,
+    isTakeProfitOrder = true,
+    isIocOrder = false,
+    pricesSlippage: number = 0.003,
+    collateralSlippage: number = 0.5,
+    relayerFee = BigInt(0.5),
+    coinObjects?: string[]
+  ): Promise<Transaction> {
+    const tx = await this.initOracleTxb([collateralToken, indexToken])
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+    const feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee)]) // Sudo contract requires SUI as fee
+
+    const adjustPrice = this.processSlippage(
+      indexPrice,
+      !long,
+      isTriggerOrder ? 0 : pricesSlippage
+    )
+    const adjustCollateralPrice = this.processSlippage(
+      collateralPrice,
+      false,
+      collateralSlippage
+    )
+
+    let allowTrade = ALLOW_TRADE_MUST_TRADE
+    if (isTriggerOrder) {
+      if (isIocOrder || !isTakeProfitOrder) {
+        allowTrade = ALLOW_TRADE_NO_TRADE
+      } else {
+        allowTrade = ALLOW_TRADE_CAN_TRADE
+      }
+    } else {
+      isTakeProfitOrder = true
+    }
+
+    const kioskTx = new KioskTransaction({
+      transaction: tx,
+      kioskClient,
+      cap: kioskCap,
+    })
+
+    const [sudoCard, promise] = kioskTx.borrow({
+      itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+      itemId: scard,
+    })
+
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v1_3`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins['sui'].module,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(pcpId),
+        tx.object(
+          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel
+        ),
+        tx.object(this.consts.sudoCore.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),
+        tx.pure.bool(isTriggerOrder),
+        sudoCard,
+      ],
+    })
+
+    kioskTx
+      .return({
+        itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+        item: sudoCard,
+        promise: promise,
+      })
+      .finalize()
+    return tx
+  }
+
+  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[]
+    }>,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    tx?: Transaction
+  ): Promise<Transaction> {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    tx = await this.initOracleTxb(positions.map(position => [position.collateralToken, position.indexToken]).flat(), tx)
+
+    const kioskTx = new KioskTransaction({
+      transaction: tx,
+      kioskClient,
+      cap: kioskCap,
+    })
+
+    const [sudoCard, promise] = kioskTx.borrow({
+      itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+      itemId: scard,
+    })
+
+    for (const position of positions) {
+      const {
+        pcpId,
+        collateralToken,
+        indexToken,
+        amount,
+        long,
+        indexPrice,
+        collateralPrice,
+        isTriggerOrder,
+        isTakeProfitOrder,
+        isIocOrder,
+        slippage,
+        relayerFee,
+        coinObjects,
+      } = position
+      let innerIsTakeProfitOrder = isTakeProfitOrder
+      const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+      const coinObject = this.processCoins(tx, collateralToken, coinObjects)
+      const feeObject = tx.splitCoins(coinObject, [tx.pure.u64(relayerFee)])
+
+      const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : slippage)
+      const adjustCollateralPrice = this.processSlippage(collateralPrice, false, 0.5)
+
+      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.sudoCore.upgradedPackage}::market::decrease_position_v1_3`,
+        typeArguments: [
+          `${this.consts.sudoCore.package}::slp::SLP`,
+          this.consts.coins[collateralToken].module,
+          this.consts.coins[indexToken].module,
+          `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+          this.consts.coins['sui'].module,
+        ],
+        arguments: [
+          tx.object(SUI_CLOCK_OBJECT_ID),
+          tx.object(this.consts.sudoCore.market),
+          tx.object(pcpId),
+          tx.object(
+            this.consts.sudoCore.vaults[collateralToken].reservingFeeModel
+          ),
+          tx.object(this.consts.sudoCore.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),
+          tx.pure.bool(isTriggerOrder),
+          sudoCard,
+        ],
+      })
+    }
+
+    kioskTx
+      .return({
+        itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+        item: sudoCard,
+        promise: promise,
+      })
+      .finalize()
+    return tx
+  }
+
+  public addReferral(
+    referrer: string,
+    tx?: Transaction
+  ): Transaction {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::add_new_referral`,
+      typeArguments: [`${this.consts.sudoCore.package}::slp::SLP`],
+      arguments: [tx.object(this.consts.sudoCore.market), tx.object(referrer)],
+    })
+
+    return tx
+  }
+
+  public async adminUpdatePriceFeed(
+    collateralToken: string,
+    indexToken: string
+  ): Promise<Transaction> {
+    const tx = await this.initOracleTxb([collateralToken, indexToken])
+    return tx
+  }
+
+  public async adminSettlePosition(
+    positionId: string,
+    owner: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean
+  ): Promise<Transaction> {
+    // SLP does not support this operation
+    throw new Error('Method not implemented.')
+  }
+
+  public async adminDecreasePosition(
+    positionId: string,
+    owner: string,
+    collateralToken: string,
+    indexToken: string,
+    positionAmount: number,
+    amount: bigint,
+    long: boolean,
+    collateralPrice?: number,
+    collateralSlippage?: number,
+    relayerFee?: bigint
+  ): Promise<Transaction> {
+    const tx = await this.initOracleTxb([collateralToken, indexToken])
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+    const feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee || BigInt(1))])
+
+    const adjustCollateralPrice = this.processSlippage(
+      collateralPrice || 0,
+      false,
+      collateralSlippage || 0.5,
+    )
+
+    let allowTrade = ALLOW_TRADE_MUST_TRADE
+
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::admin_decrease_position_v1_3`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins['sui'].module,
+      ],
+      arguments: [
+        tx.object(this.consts.sudoCore.adminCap),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(positionId),
+        tx.object(
+          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel,
+        ),
+        tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+        tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+        tx.object(this.consts.pythFeeder.feeder[indexToken]),
+        feeObject,
+        tx.pure.u8(allowTrade),
+        tx.pure.u64(amount),
+        tx.pure.u256(adjustCollateralPrice),
+        tx.object(owner),
+      ],
+    })
+
+    if (amount === BigInt(positionAmount)) {
+      this.adminClearClosedPosition(
+        positionId,
+        owner,
+        collateralToken,
+        indexToken,
+        long,
+        tx,
+      )
+    }
+
+    return tx
+  }
+
+  public async adminClearClosedPosition(
+    positionId: string,
+    owner: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction
+  ): Promise<void> {
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::admin_clear_closed_position_v1_1`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+      ],
+      arguments: [
+        tx.object(this.consts.sudoCore.adminCap),
+        tx.object(owner),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(positionId),
+      ],
+    })
+  }
+
+  // SLP Specific APIs
+  public async claimTokenFromSCard(
+    token: string,
+    coinObjects: string[],
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string
+  ): Promise<Transaction> {
+    const tx = new Transaction()
+    const kioskTx = new KioskTransaction({
+      transaction: tx,
+      kioskClient,
+      cap: kioskCap,
+    })
+
+    const [sudoCard, promise] = kioskTx.borrow({
+      itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+      itemId: scard,
+    })
+
+    // claim tokens
+    coinObjects.forEach(coinObject => {
+      return tx.moveCall({
+        target: `${this.consts.sudoNft.upgradedPackage}::card::claim_token`,
+        typeArguments: [`${this.consts.coins[token].module}`],
+        arguments: [sudoCard, tx.object(coinObject)],
+      })
+    })
+
+    kioskTx
+      .return({
+        itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+        item: sudoCard,
+        promise: promise,
+      })
+      .finalize()
+    return tx
+  }
+}