@zofai/zo-sdk 0.1.92

package/src/implementations/ZLPAPI.ts

@@ -0,0 +1,2888 @@
+/**
+ * ZLP API implementation
+ * 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 type { TransactionObjectArgument } from '@mysten/sui/transactions'
+import { Transaction } from '@mysten/sui/transactions'
+import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui/utils'
+
+import { BaseAPI } from '../abstract'
+import type { Network } from '../consts'
+import { ALLOW_TRADE_CAN_TRADE, ALLOW_TRADE_MUST_TRADE, ALLOW_TRADE_NO_TRADE, LPToken } from '../consts'
+import type {
+  IBasePositionInfo,
+  IZLPAPI,
+  IZLPCredential,
+} from '../interfaces'
+import { joinSymbol } from '../utils'
+import { ZLPDataAPI } from './ZLPDataAPI'
+
+export class ZLPAPI extends BaseAPI implements IZLPAPI {
+  public dataAPI: ZLPDataAPI
+
+  constructor(
+    network: Network,
+    provider: SuiClient,
+    apiEndpoint: string,
+    connectionURL: string,
+  ) {
+    super(network, provider, apiEndpoint, connectionURL, LPToken.ZLP)
+    this.dataAPI = new ZLPDataAPI(network, provider, apiEndpoint, connectionURL)
+  }
+
+  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 in ${this.constructor.name}.`)
+  }
+
+  /**
+   * Deposits collateral into ZLP vault
+   */
+  public async deposit(
+    coin: string,
+    coinObjects: string[],
+    amount: number,
+    minAmountOut = 0,
+    referralAddress?: string,
+    sender?: string,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    let tx = new Transaction()
+
+    // Add referral if needed
+    if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+
+    // 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 = coin === 'sui'
+        ? 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.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
+    }
+
+    // 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.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
+  }
+
+  /**
+   * Deposits collateral into ZLP vault and returns a coin
+   */
+  public async depositPtb(
+    coin: string,
+    coinObjects: string[],
+    amount: number,
+    minAmountOut = 0,
+    referralAddress?: string,
+    sender?: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<TransactionObjectArgument> {
+    if (!tx) {
+      tx = new Transaction()
+    }
+
+    // Add referral if needed
+    if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+
+    // 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 = coin === 'sui'
+        ? 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)
+
+      const [mintedCoin] = tx.moveCall({
+        target: `${this.consts.zoCore.upgradedPackage}::market::deposit_ptb`,
+        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 mintedCoin
+    }
+
+    // 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)
+
+    const [mintedCoin] = tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::deposit_ptb`,
+      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 mintedCoin
+  }
+
+  public async depositWithPtb(
+    coin: string,
+    depositObject: TransactionObjectArgument,
+    minAmountOut = 0,
+    referralAddress?: string,
+    sender?: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    if (!tx) {
+      tx = new Transaction()
+    }
+
+    // Add referral if needed
+    if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+
+    // 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)
+
+      const { vaultsValuation, symbolsValuation } = this.dataAPI.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
+    }
+
+    // Handle non-sponsored transaction case
+    tx = await this.initOracleTxb(pythFeederKeys, tx)
+
+    const { vaultsValuation, symbolsValuation } = this.dataAPI.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
+  }
+
+  /**
+   * Withdraws collateral from ZLP vault
+   */
+  public async withdraw(
+    coin: string,
+    lpCoinObjects: string[],
+    amount: number,
+    minAmountOut = 0,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    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.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
+  }
+
+  /**
+   * Withdraws LP coin object from ZLP vault
+   */
+  public async withdrawLpCoinObject(
+    coin: string,
+    lpCoinObject: TransactionObjectArgument,
+    minAmountOut = 0,
+    tx?: Transaction,
+  ): Promise<Transaction> {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    // Initialize oracle transaction
+    const pythFeederKeys = Object.keys(this.consts.pythFeeder.feeder)
+
+    tx = await this.initOracleTxb(pythFeederKeys, tx)
+    const { vaultsValuation, symbolsValuation } = this.dataAPI.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),
+        lpCoinObject,
+        tx.pure.u64(minAmountOut),
+        vaultsValuation,
+        symbolsValuation,
+      ],
+    })
+    return tx
+  }
+
+  public async withdrawPtb(
+    coin: string,
+    lpCoinObjects: string[],
+    amount: number,
+    minAmountOut = 0,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<TransactionObjectArgument> {
+    if (!tx) {
+      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)
+
+    const [withdrawCoin] = tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::withdraw_ptb`,
+      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 withdrawCoin
+  }
+
+  /**
+   * Stakes ZLP tokens in ZO staking pools
+   */
+  public stake(
+    lpCoinObjects: string[],
+    amount: bigint,
+    pool: string,
+    tx?: Transaction,
+  ): Transaction {
+    if (!tx) {
+      tx = new Transaction()
+    }
+
+    const coinObject = this.processCoins(tx, 'zlp', lpCoinObjects)
+    const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)])
+
+    tx.moveCall({
+      target: `${this.sharedConfig.zoStaking.upgradedPackage}::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
+  }
+
+  /**
+   * Stakes ZLP tokens using coin object only (PTB)
+   */
+  public stakeCoinObject(
+    coinObject: TransactionObjectArgument,
+    pool: string,
+    tx?: Transaction,
+  ): Transaction {
+    if (!tx) {
+      tx = new Transaction()
+    }
+
+    tx.moveCall({
+      target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::deposit`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        `${this.consts.coins.sui.module}`,
+      ],
+      arguments: [
+        tx.object(pool),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        coinObject,
+      ],
+    })
+    return tx
+  }
+
+  /**
+   * Unstakes ZLP tokens from ZO staking pools
+   */
+  public unstake(
+    credentials: IZLPCredential[],
+    amount: bigint,
+    pool: string,
+    tx?: Transaction,
+  ): Transaction {
+    let unstakeAmount = amount
+    if (!tx) {
+      tx = new Transaction()
+    }
+    for (const credential of credentials) {
+      const withdrawAmount = (() => {
+        const min = (a: bigint, b: bigint) => a < b ? a : b
+        return min(unstakeAmount, credential.amount)
+      })()
+      unstakeAmount -= withdrawAmount
+      tx.moveCall({
+        target: `${this.sharedConfig.zoStaking.upgradedPackage}::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.sharedConfig.zoStaking.upgradedPackage}::pool::clear_empty_credential`,
+          typeArguments: [
+            `${this.consts.zoCore.package}::zlp::ZLP`,
+            `${this.consts.coins.sui.module}`,
+          ],
+          arguments: [tx.object(credential.id)],
+        })
+      }
+    }
+    return tx
+  }
+
+  /**
+   * Unstakes ZLP tokens from ZO staking pools and return Coins
+   */
+  public unstakeToCoins(
+    credentials: IZLPCredential[],
+    amount: bigint,
+    pool: string,
+    tx: Transaction,
+  ): TransactionObjectArgument[] {
+    let unstakeAmount = amount
+    const withdrawnCoinObjects = []
+    for (const credential of credentials) {
+      const withdrawAmount = (() => {
+        const min = (a: bigint, b: bigint) => a < b ? a : b
+        return min(unstakeAmount, credential.amount)
+      })()
+      unstakeAmount -= withdrawAmount
+      const [withdrawnCoin] = tx.moveCall({
+        target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::withdraw_ptb`,
+        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),
+        ],
+      })
+      withdrawnCoinObjects.push(withdrawnCoin)
+      if (credential.amount === BigInt(0)) {
+        tx.moveCall({
+          target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::clear_empty_credential`,
+          typeArguments: [
+          `${this.consts.zoCore.package}::zlp::ZLP`,
+          `${this.consts.coins.sui.module}`,
+          ],
+          arguments: [tx.object(credential.id)],
+        })
+      }
+    }
+    return withdrawnCoinObjects
+  }
+
+  /**
+   * Withdraws ZLP tokens from a staking pool credential (PTB)
+   * Returns the withdrawn coin object for use in programmable transaction blocks
+   */
+  public withdrawFromVaultPtb(
+    pool: string,
+    credential: string,
+    withdrawAmount: bigint,
+    tx: Transaction,
+  ): TransactionObjectArgument {
+    const [withdrawnCoin] = tx.moveCall({
+      target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::withdraw_ptb`,
+      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),
+        tx.pure.u64(withdrawAmount),
+      ],
+    })
+    return withdrawnCoin
+  }
+
+  /**
+   * Claims rewards from a staking pool credential (PTB)
+   * Returns the reward coin object for use in programmable transaction blocks
+   */
+  public claimRewardsPtb(
+    pool: string,
+    credential: string,
+    tx: Transaction,
+  ): TransactionObjectArgument {
+    const [rewardCoin] = tx.moveCall({
+      target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::claim_rewards_ptb`,
+      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),
+      ],
+    })
+    return rewardCoin
+  }
+
+  public async swap(
+    fromToken: string,
+    toToken: string,
+    fromAmount: bigint,
+    fromCoinObjects: string[],
+    minAmountOut?: number,
+  ): Promise<Transaction> {
+    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.dataAPI.valuateVaults(tx)
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::swap_v2`,
+      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,
+        tx.pure.u64(minAmountOut || 0),
+        vaultsValuation,
+        tx.object(this.consts.pythFeeder.feeder[fromToken]),
+        tx.object(this.consts.pythFeeder.feeder[toToken]),
+      ],
+    })
+    return tx
+  }
+
+  /**
+   * Opens a new position in ZLP
+   */
+  public async openPosition(
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    collateralAmount: bigint,
+    coinObjects: string[],
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    referralAddress?: string,
+    sender?: string,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    let tx = new Transaction()
+    if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+
+    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
+    }
+
+    // Handle oracle initialization and coin processing
+    let suiCoinObject
+    if (sponsoredTx) {
+      suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
+    }
+    else {
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    }
+
+    // Process coin splitting
+    const [depositObject, feeObject] = this.processCoinSplitting(
+      tx,
+      collateralToken,
+      coinObjects,
+      [tx.pure.u64(collateralAmount), tx.pure.u64(relayerFee)],
+      sponsoredTx,
+      suiCoinObject,
+    )
+
+    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
+  }
+
+  /**
+   * Opens a new position in ZLP
+   */
+  public async openPositionV2(
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    collateralAmount: bigint,
+    coinObjects: string[],
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    referralAddress?: string,
+    sender?: string,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    let tx = new Transaction()
+    if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+    const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage)
+    const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage)
+    const indexPriceThreshold = this.processPriceThreshold(indexPrice, pricesSlippage)
+
+    let allowTrade = ALLOW_TRADE_MUST_TRADE
+    if (isLimitOrder) {
+      allowTrade = isIocOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+    }
+
+    // Handle oracle initialization and coin processing
+    let suiCoinObject
+    if (sponsoredTx) {
+      suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
+    }
+    else {
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    }
+
+    // Process coin splitting
+    const [depositObject, feeObject] = this.processCoinSplitting(
+      tx,
+      collateralToken,
+      coinObjects,
+      [tx.pure.u64(collateralAmount), tx.pure.u64(relayerFee)],
+      sponsoredTx,
+      suiCoinObject,
+    )
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::open_position_v2`,
+      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.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.u256(indexPriceThreshold),
+      ],
+    })
+
+    return tx
+  }
+
+  /**
+   * Opens a new position with Coin in ZLP
+   */
+  public async openPositionWithCoin(
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    coinObj: TransactionObjectArgument,
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    referralAddress?: string,
+    sender?: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+
+    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
+    }
+
+    // Handle oracle initialization and coin processing
+    let suiCoinObject
+    if (sponsoredTx) {
+      suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
+    }
+    else {
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    }
+
+    // Process coin splitting
+    const [feeObject] = tx.splitCoins(coinObj, [tx.pure.u64(relayerFee)])
+
+    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]),
+        coinObj,
+        feeObject,
+        tx.pure.u8(allowTrade),
+        tx.pure.u64(size),
+        tx.pure.u64(reserveAmount),
+        tx.pure.u256(adjustCollateralPrice),
+        tx.pure.u256(adjustPrice),
+      ],
+    })
+
+    return tx
+  }
+
+  /**
+   * Opens a new position with Coin in ZLP (V2)
+   */
+  public async openPositionWithCoinV2(
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    coinObj: TransactionObjectArgument,
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    referralAddress?: string,
+    sender?: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+    const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage)
+    const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage)
+    const indexPriceThreshold = this.processPriceThreshold(indexPrice, pricesSlippage)
+
+    let allowTrade = ALLOW_TRADE_MUST_TRADE
+    if (isLimitOrder) {
+      allowTrade = isIocOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+    }
+
+    // Handle oracle initialization and coin processing
+    let suiCoinObject
+    if (sponsoredTx) {
+      suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
+    }
+    else {
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    }
+
+    // Process coin splitting
+    const [feeObject] = tx.splitCoins(coinObj, [tx.pure.u64(relayerFee)])
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::open_position_v2`,
+      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.symbols[symbol].positionConfig),
+        tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+        tx.object(this.consts.pythFeeder.feeder[indexToken]),
+        coinObj,
+        feeObject,
+        tx.pure.u8(allowTrade),
+        tx.pure.u64(size),
+        tx.pure.u64(reserveAmount),
+        tx.pure.u256(adjustCollateralPrice),
+        tx.pure.u256(adjustPrice),
+        tx.pure.u256(indexPriceThreshold),
+      ],
+    })
+
+    return tx
+  }
+
+  /**
+   * Decreases an existing position in ZLP
+   */
+  public async decreasePosition(
+    pcpId: string,
+    collateralToken: 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),
+    coinObjects?: string[],
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    if (!coinObjects) {
+      throw new Error(`${this.constructor.name}: coinObjects is required`)
+    }
+
+    let tx = new Transaction()
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+
+    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
+    }
+
+    // Handle oracle initialization and coin processing
+    let suiCoinObject
+    if (sponsoredTx) {
+      suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
+    }
+    else {
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    }
+
+    // Process coin splitting
+    const [feeObject] = this.processCoinSplitting(
+      tx,
+      collateralToken,
+      coinObjects,
+      [tx.pure.u64(relayerFee)],
+      sponsoredTx,
+      suiCoinObject,
+    )
+
+    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
+  }
+
+  /**
+   * Decreases an existing position in ZLP
+   */
+  public async decreasePositionV2(
+    pcpId: string,
+    collateralToken: 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),
+    coinObjects?: string[],
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    if (!coinObjects) {
+      throw new Error(`${this.constructor.name}: coinObjects is required`)
+    }
+
+    let tx = new Transaction()
+
+    const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage)
+    const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage)
+    const indexPriceThreshold = this.processPriceThreshold(indexPrice, pricesSlippage)
+
+    let allowTrade = ALLOW_TRADE_MUST_TRADE
+    if (isTriggerOrder) {
+      allowTrade = isIocOrder || !isTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+    }
+    else {
+      isTakeProfitOrder = true
+    }
+
+    // Handle oracle initialization and coin processing
+    let suiCoinObject
+    if (sponsoredTx) {
+      suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
+    }
+    else {
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    }
+
+    // Process coin splitting
+    const [feeObject] = this.processCoinSplitting(
+      tx,
+      collateralToken,
+      coinObjects,
+      [tx.pure.u64(relayerFee)],
+      sponsoredTx,
+      suiCoinObject,
+    )
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::decrease_position_v2`,
+      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.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.u256(indexPriceThreshold),
+      ],
+    })
+
+    return tx
+  }
+
+  public async decreaseMultiPositions(positions: Array<{
+    pcpId: string
+    collateralToken: string
+    indexToken: string
+    amount: bigint
+    long: boolean
+    indexPrice: number
+    collateralPrice: number
+    isTriggerOrder?: boolean
+    isTakeProfitOrder?: boolean
+    isIocOrder?: boolean
+    pricesSlippage?: number
+    collateralSlippage?: number
+    relayerFee?: bigint
+    coinObjects?: string[]
+  }>, tx?: Transaction, sponsoredTx?: boolean, suiCoinObjectsForPythUpdate?: string[]): Promise<Transaction> {
+    if (!tx) {
+      tx = new Transaction()
+    }
+
+    // Handle oracle initialization and coin processing
+    let suiCoinObject
+    if (sponsoredTx) {
+      suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb(positions.flatMap(position => [position.collateralToken, position.indexToken]), tx, true, suiCoinObject)
+    }
+    else {
+      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 = 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 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 {
+        innerIsTakeProfitOrder = true
+      }
+
+      // Process coin splitting
+      const [feeObject] = this.processCoinSplitting(
+        tx,
+        collateralToken,
+        coinObjects,
+        [tx.pure.u64(relayerFee)],
+        sponsoredTx,
+        suiCoinObject,
+      )
+
+      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
+  }
+
+  public async decreaseMultiPositionsV2(positions: Array<{
+    pcpId: string
+    collateralToken: string
+    indexToken: string
+    amount: bigint
+    long: boolean
+    indexPrice: number
+    collateralPrice: number
+    isTriggerOrder?: boolean
+    isTakeProfitOrder?: boolean
+    isIocOrder?: boolean
+    pricesSlippage?: number
+    collateralSlippage?: number
+    relayerFee?: bigint
+    coinObjects?: string[]
+  }>, tx?: Transaction, sponsoredTx?: boolean, suiCoinObjectsForPythUpdate?: string[], feeObjects?: TransactionObjectArgument[]): Promise<Transaction> {
+    const transaction = tx ?? new Transaction()
+
+    // Handle oracle initialization and coin processing
+    const tokens = positions.flatMap(position => [position.collateralToken, position.indexToken])
+    const suiCoinObject = sponsoredTx
+      ? this.processCoins(transaction, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      : undefined
+    await this.initOracleTxb(tokens, transaction, !!sponsoredTx, suiCoinObject)
+
+    if (!feeObjects || feeObjects.length !== positions.length) {
+      throw new Error('feeObjects must be provided (pre-processed via buildFeeCoinObjects) and match positions length')
+    }
+
+    for (const [i, position] of positions.entries()) {
+      const feeObject = feeObjects[i]
+      const {
+        pcpId,
+        collateralToken,
+        indexToken,
+        amount,
+        long,
+        indexPrice,
+        collateralPrice,
+        isTriggerOrder = false,
+        isTakeProfitOrder = true,
+        isIocOrder = false,
+        pricesSlippage = 0.003,
+        collateralSlippage = 0.5,
+      } = position
+      let innerIsTakeProfitOrder = isTakeProfitOrder
+
+      const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage)
+      const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage)
+      const indexPriceThreshold = this.processPriceThreshold(indexPrice, pricesSlippage)
+
+      let allowTrade = ALLOW_TRADE_MUST_TRADE
+      if (isTriggerOrder) {
+        allowTrade = isIocOrder || !innerIsTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+      }
+      else {
+        innerIsTakeProfitOrder = true
+      }
+
+      transaction.moveCall({
+        target: `${this.consts.zoCore.upgradedPackage}::market::decrease_position_v2`,
+        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: [
+          transaction.object(SUI_CLOCK_OBJECT_ID),
+          transaction.object(this.consts.zoCore.market),
+          transaction.object(pcpId),
+          transaction.object(this.consts.pythFeeder.feeder[collateralToken]),
+          transaction.object(this.consts.pythFeeder.feeder[indexToken]),
+          feeObject,
+          transaction.pure.u8(allowTrade),
+          transaction.pure.bool(innerIsTakeProfitOrder),
+          transaction.pure.u64(amount),
+          transaction.pure.u256(adjustCollateralPrice),
+          transaction.pure.u256(adjustPrice),
+          transaction.pure.u256(indexPriceThreshold),
+        ],
+      })
+    }
+    return transaction
+  }
+
+  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?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    referralAddress?: string,
+    sender?: string,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    let tx = new Transaction()
+    if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+
+    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,
+    })
+
+    // Handle oracle initialization and coin processing
+    let suiCoinObject
+    if (sponsoredTx) {
+      suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
+    }
+    else {
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    }
+
+    // Process coin splitting
+    const [depositObject, feeObject] = this.processCoinSplitting(
+      tx,
+      collateralToken,
+      coinObjects,
+      [tx.pure.u64(collateralAmount), tx.pure.u64(relayerFee)],
+      sponsoredTx,
+      suiCoinObject,
+    )
+
+    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
+  }
+
+  public async openPositionWithSCardV2(
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    collateralAmount: bigint,
+    coinObjects: string[],
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    referralAddress?: string,
+    sender?: string,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    let tx = new Transaction()
+    if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+    const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage)
+    const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage)
+    const indexPriceThreshold = this.processPriceThreshold(indexPrice, pricesSlippage)
+
+    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,
+    })
+
+    // Handle oracle initialization and coin processing
+    let suiCoinObject
+    if (sponsoredTx) {
+      suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
+    }
+    else {
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    }
+
+    // Process coin splitting
+    const [depositObject, feeObject] = this.processCoinSplitting(
+      tx,
+      collateralToken,
+      coinObjects,
+      [tx.pure.u64(collateralAmount), tx.pure.u64(relayerFee)],
+      sponsoredTx,
+      suiCoinObject,
+    )
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::open_position_with_scard_v2`,
+      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.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.u256(indexPriceThreshold),
+        sudoCard,
+      ],
+    })
+
+    kioskTx
+      .return({
+        itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+        item: sudoCard,
+        promise,
+      })
+      .finalize()
+
+    return tx
+  }
+
+  public async openPositionWithCoinAndSCard(
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    coinObj: TransactionObjectArgument,
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    referralAddress?: string,
+    sender?: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+
+    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,
+    })
+
+    // Handle oracle initialization and coin processing
+    let suiCoinObject
+    if (sponsoredTx) {
+      suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
+    }
+    else {
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    }
+
+    // Process coin splitting
+    const [feeObject] = tx.splitCoins(coinObj, [tx.pure.u64(relayerFee)])
+
+    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]),
+        coinObj,
+        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
+  }
+
+  public async openPositionWithCoinAndSCardV2(
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    coinObj: TransactionObjectArgument,
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    referralAddress?: string,
+    sender?: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+    const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage)
+    const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage)
+    const indexPriceThreshold = this.processPriceThreshold(indexPrice, pricesSlippage)
+
+    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,
+    })
+
+    // Handle oracle initialization and coin processing
+    let suiCoinObject
+    if (sponsoredTx) {
+      suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
+    }
+    else {
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    }
+
+    // Process coin splitting
+    const [feeObject] = tx.splitCoins(coinObj, [tx.pure.u64(relayerFee)])
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::open_position_with_scard_v2`,
+      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.symbols[symbol].positionConfig),
+        tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+        tx.object(this.consts.pythFeeder.feeder[indexToken]),
+        coinObj,
+        feeObject,
+        tx.pure.u8(allowTrade),
+        tx.pure.u64(size),
+        tx.pure.u64(reserveAmount),
+        tx.pure.u256(adjustCollateralPrice),
+        tx.pure.u256(adjustPrice),
+        tx.pure.u256(indexPriceThreshold),
+        sudoCard,
+      ],
+    })
+
+    kioskTx
+      .return({
+        itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+        item: sudoCard,
+        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 = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    coinObjects?: string[],
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    if (!coinObjects) {
+      throw new Error(`${this.constructor.name}: coinObjects is required`)
+    }
+
+    let tx = new Transaction()
+
+    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 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
+    }
+
+    // Handle oracle initialization and coin processing
+    let suiCoinObject
+    if (sponsoredTx) {
+      suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
+    }
+    else {
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    }
+
+    // Process coin splitting
+    const [feeObject] = this.processCoinSplitting(
+      tx,
+      collateralToken,
+      coinObjects,
+      [tx.pure.u64(relayerFee)],
+      sponsoredTx,
+      suiCoinObject,
+    )
+
+    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
+  }
+
+  public async decreasePositionWithSCardV2(
+    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 = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    coinObjects?: string[],
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    if (!coinObjects) {
+      throw new Error(`${this.constructor.name}: coinObjects is required`)
+    }
+
+    let tx = new Transaction()
+
+    const kioskTx = new KioskTransaction({
+      transaction: tx,
+      kioskClient,
+      cap: kioskCap,
+    })
+
+    const [sudoCard, promise] = kioskTx.borrow({
+      itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+      itemId: scard,
+    })
+
+    const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage)
+    const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage)
+    const indexPriceThreshold = this.processPriceThreshold(indexPrice, pricesSlippage)
+
+    let allowTrade = ALLOW_TRADE_MUST_TRADE
+    if (isTriggerOrder) {
+      allowTrade = isIocOrder || !isTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+    }
+    else {
+      isTakeProfitOrder = true
+    }
+
+    // Handle oracle initialization and coin processing
+    let suiCoinObject
+    if (sponsoredTx) {
+      suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
+    }
+    else {
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    }
+
+    // Process coin splitting
+    const [feeObject] = this.processCoinSplitting(
+      tx,
+      collateralToken,
+      coinObjects,
+      [tx.pure.u64(relayerFee)],
+      sponsoredTx,
+      suiCoinObject,
+    )
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::decrease_position_with_scard_v2`,
+      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.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.u256(indexPriceThreshold),
+        sudoCard,
+      ],
+    })
+
+    kioskTx
+      .return({
+        itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+        item: sudoCard,
+        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
+      pricesSlippage?: number
+      collateralSlippage?: number
+      relayerFee?: bigint
+      coinObjects?: string[]
+    }>,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    if (!tx) {
+      tx = new Transaction()
+    }
+
+    // Handle oracle initialization and coin processing
+    let suiCoinObject
+    if (sponsoredTx) {
+      suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb(positions.flatMap(position => [position.collateralToken, position.indexToken]), tx, true, suiCoinObject)
+    }
+    else {
+      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,
+        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 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 {
+        innerIsTakeProfitOrder = true
+      }
+
+      // Process coin splitting
+      const [feeObject] = this.processCoinSplitting(
+        tx,
+        collateralToken,
+        coinObjects,
+        [tx.pure.u64(relayerFee)],
+        sponsoredTx,
+        suiCoinObject,
+      )
+
+      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
+  }
+
+  public async decreaseMultiPositionsWithSCardV2(
+    positions: Array<{
+      pcpId: string
+      collateralToken: string
+      indexToken: string
+      amount: bigint
+      long: boolean
+      indexPrice: number
+      collateralPrice: number
+      isTriggerOrder?: boolean
+      isTakeProfitOrder?: boolean
+      isIocOrder?: boolean
+      pricesSlippage?: number
+      collateralSlippage?: number
+      relayerFee?: bigint
+      coinObjects?: string[]
+    }>,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+    feeObjects?: TransactionObjectArgument[],
+  ): Promise<Transaction> {
+    const transaction = tx ?? new Transaction()
+
+    // Handle oracle initialization and coin processing
+    const tokens = positions.flatMap(position => [position.collateralToken, position.indexToken])
+    const suiCoinObject = sponsoredTx
+      ? this.processCoins(transaction, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      : undefined
+    await this.initOracleTxb(tokens, transaction, !!sponsoredTx, suiCoinObject)
+
+    if (!feeObjects || feeObjects.length !== positions.length) {
+      throw new Error('feeObjects must be provided (pre-processed via buildFeeCoinObjects) and match positions length')
+    }
+
+    const kioskTx = new KioskTransaction({
+      transaction,
+      kioskClient,
+      cap: kioskCap,
+    })
+
+    const [sudoCard, promise] = kioskTx.borrow({
+      itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+      itemId: scard,
+    })
+
+    for (const [i, position] of positions.entries()) {
+      const feeObject = feeObjects[i]
+      const {
+        pcpId,
+        collateralToken,
+        indexToken,
+        amount,
+        long,
+        indexPrice,
+        collateralPrice,
+        isTriggerOrder = false,
+        isTakeProfitOrder = true,
+        isIocOrder = false,
+        pricesSlippage = 0.003,
+        collateralSlippage = 0.5,
+      } = position
+      let innerIsTakeProfitOrder = isTakeProfitOrder
+
+      const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage)
+      const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage)
+      const indexPriceThreshold = this.processPriceThreshold(indexPrice, pricesSlippage)
+
+      let allowTrade = ALLOW_TRADE_MUST_TRADE
+      if (isTriggerOrder) {
+        allowTrade = isIocOrder || !innerIsTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+      }
+      else {
+        innerIsTakeProfitOrder = true
+      }
+
+      transaction.moveCall({
+        target: `${this.consts.zoCore.upgradedPackage}::market::decrease_position_with_scard_v2`,
+        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: [
+          transaction.object(SUI_CLOCK_OBJECT_ID),
+          transaction.object(this.consts.zoCore.market),
+          transaction.object(pcpId),
+          transaction.object(this.consts.pythFeeder.feeder[collateralToken]),
+          transaction.object(this.consts.pythFeeder.feeder[indexToken]),
+          feeObject,
+          transaction.pure.u8(allowTrade),
+          transaction.pure.bool(innerIsTakeProfitOrder),
+          transaction.pure.u64(amount),
+          transaction.pure.u256(adjustCollateralPrice),
+          transaction.pure.u256(adjustPrice),
+          transaction.pure.u256(indexPriceThreshold),
+          sudoCard,
+        ],
+      })
+    }
+
+    kioskTx
+      .return({
+        itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+        item: sudoCard,
+        promise,
+      })
+      .finalize()
+    return transaction
+  }
+
+  /**
+   * Pledges in position (ZLP-specific functionality)
+   */
+  public async pledgeInPosition(
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: number,
+    coinObjects: string[],
+    long: boolean,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    let tx = new Transaction()
+    // Handle oracle initialization and coin processing
+    let suiCoinObject
+    if (sponsoredTx) {
+      suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
+    }
+    else {
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    }
+
+    // Process coin splitting
+    const [depositObject] = this.processCoinSplitting(
+      tx,
+      collateralToken,
+      coinObjects,
+      [tx.pure.u64(amount)],
+      sponsoredTx,
+      suiCoinObject,
+    )
+
+    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
+  }
+
+  public async redeemFromPosition(
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: number,
+    long: boolean,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<Transaction> {
+    let tx = new Transaction()
+    // Handle oracle initialization and coin processing
+    let suiCoinObject
+    if (sponsoredTx) {
+      suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
+    }
+    else {
+      tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    }
+    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
+  }
+
+  public cancelOrder(
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    type: string,
+    isV11Order?: boolean,
+  ): Transaction {
+    const tx = new Transaction()
+    let functionName = ''
+    switch (type) {
+      case 'OPEN_POSITION': {
+        functionName = isV11Order ? 'clear_open_position_order' : 'clear_open_position_order'
+        break
+      }
+      case 'OPEN_MARKET': {
+        functionName = 'clear_open_market_order'
+        break
+      }
+      case 'DECREASE_POSITION': {
+        functionName = isV11Order
+          ? 'clear_decrease_position_order'
+          : 'clear_decrease_position_order'
+        break
+      }
+      case 'DECREASE_MARKET': {
+        functionName = 'clear_decrease_market_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
+  }
+
+  public cancelMultiOrders(
+    orders: Array<{
+      orderCapId: string
+      collateralToken: string
+      indexToken: string
+      long: boolean
+      type: string
+      isV11Order?: boolean
+    }>,
+    tx?: Transaction,
+  ): 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 'OPEN_MARKET': {
+          functionName = 'clear_open_market_order'
+          break
+        }
+        case 'DECREASE_POSITION': {
+          functionName = isV11Order
+            ? 'clear_decrease_position_order'
+            : 'clear_decrease_position_order'
+          break
+        }
+        case 'DECREASE_MARKET': {
+          functionName = 'clear_decrease_market_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
+  }
+
+  public clearClosedPosition(
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+  ): void {
+    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)],
+    })
+  }
+
+  public clearOpenPositionOrder(
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+    isV11Order?: boolean,
+  ): void {
+    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)],
+    })
+  }
+
+  public clearOpenMarketOrder(
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+    _isV11Order?: boolean,
+  ): void {
+    const funcName = 'clear_open_market_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)],
+    })
+  }
+
+  public clearDecreasePositionOrder(
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+    isV11Order?: boolean,
+  ): void {
+    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)],
+    })
+  }
+
+  public clearDecreaseMarketOrder(
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+    _isV11Order?: boolean,
+  ): void {
+    const funcName = 'clear_decrease_market_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)],
+    })
+  }
+
+  public addReferral(
+    referralAddress: string,
+    tx?: Transaction,
+  ): Transaction {
+    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.pure.address(referralAddress)],
+    })
+
+    return tx
+  }
+
+  public async adminUpdatePriceFeed(
+    collateralToken: string,
+    indexToken: string,
+  ): Promise<Transaction> {
+    const tx = await this.initOracleTxb([collateralToken, indexToken])
+    return tx
+  }
+
+  public adminSettlePosition(
+    positionId: string,
+    owner: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+  ): Transaction {
+    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
+  }
+
+  public adminDecreasePosition(
+    positionId: string,
+    owner: string,
+    collateralToken: string,
+    indexToken: string,
+    positionAmount: number,
+    amount: bigint,
+    long: boolean,
+  ): Transaction {
+    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
+  }
+
+  public adminClearClosedPosition(
+    positionId: string,
+    owner: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+  ): void {
+    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),
+      ],
+    })
+  }
+
+  public adminIssueLootbox(
+    coin: string,
+    tiers: number[],
+    beneficiaries: string[],
+    amounts: number[],
+    tx: Transaction,
+  ): void {
+    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.sharedConfig.zoLootbox.package}::lootbox::admin_issue_lootbox`,
+        typeArguments: [module],
+        arguments: [
+          tx.object(this.sharedConfig.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.sharedConfig.zoLootbox.lootboxSettings}`),
+        ],
+      })
+    }
+  }
+
+  public depositToPrizePool(
+    coin: string,
+    coinObjects: string[],
+    amount: number,
+  ): 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`
+    if (coin !== 'zlp') {
+      module = this.consts.coins[coin].module
+    }
+
+    tx.moveCall({
+      target: `${this.sharedConfig.zoLootbox.package}::lootbox::deposit`,
+      typeArguments: [module],
+      arguments: [
+        tx.object(this.sharedConfig.zoLootbox.adminCap),
+        tx.object(this.sharedConfig.zoLootbox.lootboxTreasury),
+        depositObject,
+      ],
+    })
+    return tx
+  }
+
+  public withdrawFromPricePool(
+    coin: string,
+    amount: number,
+  ): Transaction {
+    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.sharedConfig.zoLootbox.package}::lootbox::withdraw`,
+      typeArguments: [module],
+      arguments: [
+        tx.object(this.sharedConfig.zoLootbox.adminCap),
+        tx.object(this.sharedConfig.zoLootbox.lootboxTreasury),
+        tx.object(metadata),
+        tx.pure.u64(amount),
+      ],
+    })
+    return tx
+  }
+
+  public openLootbox(
+    coin: string,
+    lootbox: string,
+  ): Transaction {
+    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.sharedConfig.zoLootbox.upgradedPackage}::lootbox::open_lootbox`,
+      typeArguments: [module],
+      arguments: [
+        tx.object(`${this.sharedConfig.zoLootbox.lootboxTreasury}`),
+        tx.object(lootbox),
+        tx.object(metadata),
+        tx.object(`${this.sharedConfig.zoLootbox.lootboxSettings}`),
+      ],
+    })
+
+    return tx
+  }
+
+  // V2 Lootbox Methods for new contract
+  public adminIssueLootboxV2(
+    coin: string,
+    tiers: number[],
+    beneficiaries: string[],
+    amounts: number[],
+    titles: string[],
+    descriptions: string[],
+    tx: Transaction,
+  ): void {
+    let module = `${this.consts.zoCore.package}::zlp::ZLP`
+    if (coin !== 'zlp') {
+      module = this.consts.coins[coin].module
+    }
+
+    for (const [i, beneficiary] of beneficiaries.entries()) {
+      const moveCallArgs = {
+        target: `${this.sharedConfig.zoLootboxV2.upgradedPackage}::lootbox::admin_issue_lootbox`,
+        typeArguments: [module],
+        arguments: [
+          tx.object(this.sharedConfig.zoLootboxV2.adminCap),
+          tx.object(this.sharedConfig.zoLootboxV2.lootboxTreasury),
+          tx.pure.u8(tiers[i]),
+          tx.pure.address(beneficiary),
+          tx.pure.u64(amounts[i]),
+          tx.pure.bool(amounts[i] > 0),
+          tx.pure.string(titles[i]),
+          tx.pure.string(descriptions[i]),
+          tx.object(`${this.sharedConfig.zoLootboxV2.lootboxSettings}`),
+        ],
+      }
+
+      tx.moveCall(moveCallArgs)
+    }
+  }
+
+  public openLootboxV2(
+    coin: string,
+    lootbox: string,
+  ): Transaction {
+    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.sharedConfig.zoLootboxV2.upgradedPackage}::lootbox::open_lootbox`,
+      typeArguments: [module],
+      arguments: [
+        tx.object(this.sharedConfig.zoLootboxV2.lootboxTreasury),
+        tx.object(lootbox),
+        tx.object(metadata),
+        tx.object(this.sharedConfig.zoLootboxV2.lootboxSettings),
+      ],
+    })
+
+    return tx
+  }
+
+  // Vesting Lootbox Methods (V2)
+  public adminIssueVestingLootboxV2(
+    _coin: string,
+    beneficiaries: string[],
+    unlockedAmounts: number[],
+    lockedAmounts: number[],
+    lockDurationsMs: number[],
+    tx: Transaction,
+  ): void {
+    const module = `${this.consts.zoCore.package}::zlp::ZLP`
+
+    for (const [i, beneficiary] of beneficiaries.entries()) {
+      tx.moveCall({
+        target: `${this.sharedConfig.zoLootboxV2.upgradedPackage}::lootbox::admin_issue_vesting_lootbox_precision`,
+        typeArguments: [module],
+        arguments: [
+          tx.object(this.sharedConfig.zoLootboxV2.adminCap),
+          tx.object(this.sharedConfig.zoLootboxV2.lootboxTreasury),
+          tx.object(SUI_CLOCK_OBJECT_ID),
+          tx.pure.u64(unlockedAmounts[i]),
+          tx.pure.u64(lockedAmounts[i]),
+          tx.pure.u64(lockDurationsMs[i]),
+          tx.pure.address(beneficiary),
+        ],
+      })
+    }
+  }
+
+  public claimUnlockedV2(
+    coin: string,
+    vestingLootbox: string,
+  ): Transaction {
+    const tx = new Transaction()
+
+    let module = `${this.consts.zoCore.package}::zlp::ZLP`
+    if (coin !== 'zlp') {
+      module = this.consts.coins[coin].module
+    }
+
+    tx.moveCall({
+      target: `${this.sharedConfig.zoLootboxV2.upgradedPackage}::lootbox::claim_unlocked`,
+      typeArguments: [module],
+      arguments: [
+        tx.object(this.sharedConfig.zoLootboxV2.lootboxTreasury),
+        tx.object(vestingLootbox),
+      ],
+    })
+
+    return tx
+  }
+
+  public claimVestedV2(
+    coin: string,
+    vestingLootbox: string,
+  ): Transaction {
+    const tx = new Transaction()
+
+    let module = `${this.consts.zoCore.package}::zlp::ZLP`
+    if (coin !== 'zlp') {
+      module = this.consts.coins[coin].module
+    }
+
+    tx.moveCall({
+      target: `${this.sharedConfig.zoLootboxV2.upgradedPackage}::lootbox::claim_vested`,
+      typeArguments: [module],
+      arguments: [
+        tx.object(this.sharedConfig.zoLootboxV2.lootboxTreasury),
+        tx.object(vestingLootbox),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+      ],
+    })
+
+    return tx
+  }
+
+  public destroyVestingLootboxV2(
+    coin: string,
+    vestingLootbox: string,
+  ): Transaction {
+    const tx = new Transaction()
+
+    let module = `${this.consts.zoCore.package}::zlp::ZLP`
+    if (coin !== 'zlp') {
+      module = this.consts.coins[coin].module
+    }
+
+    tx.moveCall({
+      target: `${this.sharedConfig.zoLootboxV2.upgradedPackage}::lootbox::destroy_vesting_lootbox`,
+      typeArguments: [module],
+      arguments: [tx.object(vestingLootbox)],
+    })
+
+    return tx
+  }
+}