zo-sdk 0.1.62 → 0.1.64

package/src/implementations/SLPAPI.ts

@@ -907,6 +907,175 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     return tx
   }
 
+  /**
+   * Opens a new position in SLP (V2 - uses v3 contract)
+   */
+  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.sudoCore.upgradedPackage}::market::open_position_v3`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins[collateralToken].module,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+        tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+        tx.object(this.consts.pythFeeder.feeder[indexToken]),
+        depositObject,
+        feeObject,
+        tx.pure.u8(allowTrade),
+        tx.pure.u64(size),
+        tx.pure.u64(reserveAmount),
+        tx.pure.u256(adjustCollateralPrice),
+        tx.pure.u256(adjustPrice),
+        tx.pure.u256(indexPriceThreshold),
+      ],
+    })
+
+    return tx
+  }
+
+  /**
+   * Opens a new position with Coin in SLP (V2 - uses v3 contract)
+   */
+  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.sudoCore.upgradedPackage}::market::open_position_v3`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins[collateralToken].module,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(this.consts.sudoCore.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 SLP using Sudo SDK approach
    */
@@ -1004,6 +1173,93 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     return tx
   }
 
+  /**
+   * Decreases an existing position in SLP (V2 - uses v3 contract)
+   */
+  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.sudoCore.upgradedPackage}::market::decrease_position_v3`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins[collateralToken].module,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.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
@@ -1057,10 +1313,112 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         relayerFee = BigInt(0.5),
       } = position
       let innerIsTakeProfitOrder = isTakeProfitOrder
-      const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+      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.sudoCore.upgradedPackage}::market::decrease_position_v2_1`,
+        typeArguments: [
+          `${this.consts.sudoCore.package}::slp::SLP`,
+          this.consts.coins[collateralToken].module,
+          this.consts.coins[indexToken].module,
+          `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+          this.consts.coins[collateralToken].module,
+        ],
+        arguments: [
+          tx.object(SUI_CLOCK_OBJECT_ID),
+          tx.object(this.consts.sudoCore.market),
+          tx.object(pcpId),
+          tx.object(
+            this.consts.sudoCore.vaults[collateralToken].reservingFeeModel,
+          ),
+          tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+          tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+          tx.object(this.consts.pythFeeder.feeder[indexToken]),
+          feeObject,
+          tx.pure.u8(allowTrade),
+          tx.pure.bool(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[]): 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 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) {
@@ -1081,7 +1439,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
       )
 
       tx.moveCall({
-        target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v2_1`,
+        target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v3`,
         typeArguments: [
           `${this.consts.sudoCore.package}::slp::SLP`,
           this.consts.coins[collateralToken].module,
@@ -1093,10 +1451,6 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
           tx.object(SUI_CLOCK_OBJECT_ID),
           tx.object(this.consts.sudoCore.market),
           tx.object(pcpId),
-          tx.object(
-            this.consts.sudoCore.vaults[collateralToken].reservingFeeModel,
-          ),
-          tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
           tx.object(this.consts.pythFeeder.feeder[collateralToken]),
           tx.object(this.consts.pythFeeder.feeder[indexToken]),
           feeObject,
@@ -1105,6 +1459,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
           tx.pure.u64(amount),
           tx.pure.u256(adjustCollateralPrice),
           tx.pure.u256(adjustPrice),
+          tx.pure.u256(indexPriceThreshold),
         ],
       })
     }
@@ -1221,10 +1576,18 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         functionName = 'clear_open_position_order_unified'
         break
       }
+      case 'OPEN_MARKET': {
+        functionName = 'clear_open_market_order'
+        break
+      }
       case 'DECREASE_POSITION': {
         functionName = 'clear_decrease_position_order_unified'
         break
       }
+      case 'DECREASE_MARKET': {
+        functionName = 'clear_decrease_market_order'
+        break
+      }
       default: {
         throw new Error('invalid order type')
       }
@@ -1269,10 +1632,18 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
           functionName = 'clear_open_position_order_unified'
           break
         }
+        case 'OPEN_MARKET': {
+          functionName = 'clear_open_market_order'
+          break
+        }
         case 'DECREASE_POSITION': {
           functionName = 'clear_decrease_position_order_unified'
           break
         }
+        case 'DECREASE_MARKET': {
+          functionName = 'clear_decrease_market_order'
+          break
+        }
         default: {
           throw new Error('invalid order type')
         }
@@ -1360,7 +1731,262 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     })
   }
 
-  public async openPositionWithSCard(
+  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.sudoCore.upgradedPackage}::market::${funcName}`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins[collateralToken].module,
+      ],
+      arguments: [tx.object(this.consts.sudoCore.market), tx.object(orderCapId)],
+    })
+  }
+
+  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.sudoCore.upgradedPackage}::market::${funcName}`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins[collateralToken].module,
+      ],
+      arguments: [tx.object(this.consts.sudoCore.market), tx.object(orderCapId)],
+    })
+  }
+
+  public async openPositionWithSCard(
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    collateralAmount: bigint,
+    coinObjects: string[],
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    isLimitOrder = false,
+    isIocOrder = false,
+    pricesSlippage = 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 || 0.003)
+    const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage || 0.5)
+
+    let allowTrade = ALLOW_TRADE_MUST_TRADE
+    if (isLimitOrder) {
+      allowTrade = isIocOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+    }
+
+    const kioskTx = new KioskTransaction({
+      transaction: tx,
+      kioskClient,
+      cap: kioskCap,
+    })
+
+    const [sudoCard, promise] = kioskTx.borrow({
+      itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+      itemId: scard,
+    })
+
+    // 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.sudoCore.upgradedPackage}::market::open_position_with_scard_v1`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins[collateralToken].module,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(
+          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel,
+        ),
+        tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+        tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+        tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+        tx.object(this.consts.pythFeeder.feeder[indexToken]),
+        depositObject,
+        feeObject,
+        tx.pure.u8(allowTrade),
+        tx.pure.u64(size),
+        tx.pure.u64(reserveAmount),
+        tx.pure.u256(adjustCollateralPrice),
+        tx.pure.u256(adjustPrice),
+        sudoCard,
+      ],
+    })
+
+    kioskTx
+      .return({
+        itemType: `${this.consts.sudoNft.package}::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 = false,
+    isIocOrder = false,
+    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 || 0.003)
+    const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage || 0.5)
+
+    let allowTrade = ALLOW_TRADE_MUST_TRADE
+    if (isLimitOrder) {
+      allowTrade = isIocOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+    }
+
+    const kioskTx = new KioskTransaction({
+      transaction: tx,
+      kioskClient,
+      cap: kioskCap,
+    })
+
+    const [sudoCard, promise] = kioskTx.borrow({
+      itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+      itemId: scard,
+    })
+
+    // 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.sudoCore.upgradedPackage}::market::open_position_with_scard_v1`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins[collateralToken].module,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(
+          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel,
+        ),
+        tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+        tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+        tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+        tx.object(this.consts.pythFeeder.feeder[indexToken]),
+        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: `${this.consts.sudoNft.package}::card::SudoCard`,
+        item: sudoCard,
+        promise,
+      })
+      .finalize()
+    return tx
+  }
+
+  public async openPositionWithSCardV2(
     collateralToken: string,
     indexToken: string,
     size: bigint,
@@ -1373,8 +1999,8 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     kioskClient: KioskClient,
     kioskCap: KioskOwnerCap,
     scard: string,
-    isLimitOrder = false,
-    isIocOrder = false,
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
     pricesSlippage = 0.003,
     collateralSlippage = 0.5,
     relayerFee = BigInt(0.5),
@@ -1389,8 +2015,9 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     }
 
     const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
-    const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage || 0.003)
-    const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage || 0.5)
+    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) {
@@ -1429,7 +2056,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     )
 
     tx.moveCall({
-      target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_with_scard_v1`,
+      target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_with_scard_v2`,
       typeArguments: [
         `${this.consts.sudoCore.package}::slp::SLP`,
         this.consts.coins[collateralToken].module,
@@ -1440,10 +2067,6 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
       arguments: [
         tx.object(SUI_CLOCK_OBJECT_ID),
         tx.object(this.consts.sudoCore.market),
-        tx.object(
-          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel,
-        ),
-        tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
         tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
         tx.object(this.consts.pythFeeder.feeder[collateralToken]),
         tx.object(this.consts.pythFeeder.feeder[indexToken]),
@@ -1454,6 +2077,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         tx.pure.u64(reserveAmount),
         tx.pure.u256(adjustCollateralPrice),
         tx.pure.u256(adjustPrice),
+        tx.pure.u256(indexPriceThreshold),
         sudoCard,
       ],
     })
@@ -1465,10 +2089,12 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         promise,
       })
       .finalize()
+
     return tx
   }
 
-  public async openPositionWithCoinAndSCard(
+  // S Card operations
+  public async openPositionWithCoinAndSCardV2(
     collateralToken: string,
     indexToken: string,
     size: bigint,
@@ -1480,8 +2106,8 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     kioskClient: KioskClient,
     kioskCap: KioskOwnerCap,
     scard: string,
-    isLimitOrder = false,
-    isIocOrder = false,
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
     pricesSlippage = 0.003,
     collateralSlippage = 0.5,
     relayerFee = BigInt(0.5),
@@ -1499,8 +2125,9 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     }
 
     const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
-    const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage || 0.003)
-    const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage || 0.5)
+    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) {
@@ -1532,7 +2159,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     const [feeObject] = tx.splitCoins(coinObj, [tx.pure.u64(relayerFee)])
 
     tx.moveCall({
-      target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_with_scard_v1`,
+      target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_with_scard_v2`,
       typeArguments: [
         `${this.consts.sudoCore.package}::slp::SLP`,
         this.consts.coins[collateralToken].module,
@@ -1543,10 +2170,6 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
       arguments: [
         tx.object(SUI_CLOCK_OBJECT_ID),
         tx.object(this.consts.sudoCore.market),
-        tx.object(
-          this.consts.sudoCore.vaults[collateralToken].reservingFeeModel,
-        ),
-        tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
         tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
         tx.object(this.consts.pythFeeder.feeder[collateralToken]),
         tx.object(this.consts.pythFeeder.feeder[indexToken]),
@@ -1557,6 +2180,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         tx.pure.u64(reserveAmount),
         tx.pure.u256(adjustCollateralPrice),
         tx.pure.u256(adjustPrice),
+        tx.pure.u256(indexPriceThreshold),
         sudoCard,
       ],
     })
@@ -1568,6 +2192,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         promise,
       })
       .finalize()
+
     return tx
   }
 
@@ -1688,6 +2313,112 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     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: `${this.consts.sudoNft.package}::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.sudoCore.upgradedPackage}::market::decrease_position_with_scard_v2`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins[collateralToken].module,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.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: `${this.consts.sudoNft.package}::card::SudoCard`,
+        item: sudoCard,
+        promise,
+      })
+      .finalize()
+    return tx
+  }
+
   public async decreaseMultiPositionsWithSCard(
     positions: Array<{
       pcpId: string
@@ -1818,6 +2549,133 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     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[],
+  ): 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: `${this.consts.sudoNft.package}::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 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
+      }
+
+      // Process coin splitting
+      const [feeObject] = this.processCoinSplitting(
+        tx,
+        collateralToken,
+        coinObjects,
+        [tx.pure.u64(relayerFee)],
+        sponsoredTx,
+        suiCoinObject,
+      )
+
+      tx.moveCall({
+        target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_with_scard_v2`,
+        typeArguments: [
+          `${this.consts.sudoCore.package}::slp::SLP`,
+          this.consts.coins[collateralToken].module,
+          this.consts.coins[indexToken].module,
+          `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+          this.consts.coins[collateralToken].module,
+        ],
+        arguments: [
+          tx.object(SUI_CLOCK_OBJECT_ID),
+          tx.object(this.consts.sudoCore.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(innerIsTakeProfitOrder),
+          tx.pure.u64(amount),
+          tx.pure.u256(adjustCollateralPrice),
+          tx.pure.u256(adjustPrice),
+          tx.pure.u256(indexPriceThreshold),
+          sudoCard,
+        ],
+      })
+    }
+
+    kioskTx
+      .return({
+        itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+        item: sudoCard,
+        promise,
+      })
+      .finalize()
+    return tx
+  }
+
   public addReferral(
     referrer: string,
     tx?: Transaction,