zo-sdk 0.1.29 → 0.1.31

package/src/implementations/SLPAPI.ts

@@ -6,6 +6,7 @@
 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'
 
@@ -221,6 +222,76 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     return tx
   }
 
+  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.sudoCore.upgradedPackage}::market::deposit`,
+        typeArguments: [
+          `${this.consts.sudoCore.package}::slp::SLP`,
+          this.consts.coins[coin].module,
+        ],
+        arguments: [
+          tx.object(this.consts.sudoCore.market),
+          tx.object(this.consts.sudoCore.rebaseFeeModel),
+          depositObject,
+          tx.pure.u64(minAmountOut),
+          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.sudoCore.upgradedPackage}::market::deposit`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[coin].module,
+      ],
+      arguments: [
+        tx.object(this.consts.sudoCore.market),
+        tx.object(this.consts.sudoCore.rebaseFeeModel),
+        depositObject,
+        tx.pure.u64(minAmountOut),
+        vaultsValuation,
+        symbolsValuation,
+      ],
+    })
+    return tx
+  }
+
   /**
    * Withdraws collateral from SLP vault using Sudo SDK approach
    */
@@ -267,6 +338,52 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     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 slpCoinObject = this.processCoins(tx, 'slp', lpCoinObjects, false)
+    const [withdrawObject] = tx.splitCoins(slpCoinObject, [tx.pure.u64(amount)])
+    const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx)
+
+    const [withdrawCoin] = tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::withdraw_ptb`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        this.consts.coins[coin].module,
+      ],
+      arguments: [
+        tx.object(this.consts.sudoCore.market),
+        tx.object(this.consts.sudoCore.rebaseFeeModel),
+        withdrawObject,
+        tx.pure.u64(minAmountOut),
+        vaultsValuation,
+        symbolsValuation,
+      ],
+    })
+    return withdrawCoin
+  }
+
   public async swap(
     fromToken: string,
     toToken: string,
@@ -522,35 +639,32 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
 
     // Handle oracle initialization and coin processing
     let suiCoinObject
-    let feeObject
     if (sponsoredTx) {
       suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
-      feeObject = tx.splitCoins(suiCoinObject, [tx.pure.u64(relayerFee)]) // Sudo contract requires SUI as fee
       tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
     }
     else {
-      feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee)]) // Sudo contract requires SUI as fee
       tx = await this.initOracleTxb([collateralToken, indexToken], tx)
     }
 
     // Process coin splitting
-    const [depositObject] = this.processCoinSplitting(
+    const [depositObject, feeObject] = this.processCoinSplitting(
       tx,
       collateralToken,
       coinObjects,
-      [tx.pure.u64(collateralAmount)],
+      [tx.pure.u64(collateralAmount), tx.pure.u64(relayerFee)],
       sponsoredTx,
       suiCoinObject,
     )
 
     tx.moveCall({
-      target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_v1_2`,
+      target: `${this.consts.sudoCore.upgradedPackage}::market::open_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.sui.module,
+        this.consts.coins[collateralToken].module,
       ],
       arguments: [
         tx.object(SUI_CLOCK_OBJECT_ID),
@@ -569,7 +683,6 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         tx.pure.u64(reserveAmount),
         tx.pure.u256(adjustCollateralPrice),
         tx.pure.u256(adjustPrice),
-        tx.pure.bool(isLimitOrder),
       ],
     })
     return tx
@@ -596,6 +709,10 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     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)
 
@@ -620,25 +737,31 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
 
     // Handle oracle initialization and coin processing
     let suiCoinObject
-    let feeObject
+    const [feeObject] = this.processCoinSplitting(
+      tx,
+      collateralToken,
+      coinObjects,
+      [tx.pure.u64(relayerFee)],
+      sponsoredTx,
+      suiCoinObject,
+    )
+
     if (sponsoredTx) {
       suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
-      feeObject = tx.splitCoins(suiCoinObject, [tx.pure.u64(relayerFee)]) // Sudo contract requires SUI as fee
       tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
     }
     else {
-      feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee)]) // Sudo contract requires SUI as fee
       tx = await this.initOracleTxb([collateralToken, indexToken], tx)
     }
 
     tx.moveCall({
-      target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v1_2`,
+      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.sui.module,
+        this.consts.coins[collateralToken].module,
       ],
       arguments: [
         tx.object(SUI_CLOCK_OBJECT_ID),
@@ -656,7 +779,6 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         tx.pure.u64(amount),
         tx.pure.u256(adjustCollateralPrice),
         tx.pure.u256(adjustPrice),
-        tx.pure.bool(isTriggerOrder),
       ],
     })
 
@@ -740,13 +862,13 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
       )
 
       tx.moveCall({
-        target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v1_2`,
+        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.sui.module,
+          this.consts.coins[collateralToken].module,
         ],
         arguments: [
           tx.object(SUI_CLOCK_OBJECT_ID),
@@ -764,7 +886,6 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
           tx.pure.u64(amount),
           tx.pure.u256(adjustCollateralPrice),
           tx.pure.u256(adjustPrice),
-          tx.pure.bool(isTriggerOrder),
         ],
       })
     }
@@ -872,16 +993,17 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     indexToken: string,
     long: boolean,
     type: string,
+    isV11Order?: boolean,
   ): Transaction {
     const tx = new Transaction()
     let functionName = ''
     switch (type) {
       case 'OPEN_POSITION': {
-        functionName = 'clear_open_position_order_v1_1'
+        functionName = 'clear_open_position_order_unified'
         break
       }
       case 'DECREASE_POSITION': {
-        functionName = 'clear_decrease_position_order_v1_1'
+        functionName = 'clear_decrease_position_order_unified'
         break
       }
       default: {
@@ -895,7 +1017,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         this.consts.coins[collateralToken].module,
         this.consts.coins[indexToken].module,
         `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-        this.consts.coins.sui.module,
+        isV11Order ? this.consts.coins.sui.module : this.consts.coins[collateralToken].module,
       ],
       arguments: [
         tx.object(this.consts.sudoCore.market),
@@ -921,17 +1043,15 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     }
 
     for (const order of orders) {
-      const { orderCapId, collateralToken, indexToken, long, type, isV11Order } = order
+      const { orderCapId, collateralToken, indexToken, long, type } = order
       let functionName = ''
       switch (type) {
         case 'OPEN_POSITION': {
-          functionName = isV11Order ? 'clear_open_position_order_v1_1' : 'clear_open_position_order_v1_1'
+          functionName = 'clear_open_position_order_unified'
           break
         }
         case 'DECREASE_POSITION': {
-          functionName = isV11Order
-            ? 'clear_decrease_position_order_v1_1'
-            : 'clear_decrease_position_order_v1_1'
+          functionName = 'clear_decrease_position_order_unified'
           break
         }
         default: {
@@ -979,15 +1099,16 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     indexToken: string,
     long: boolean,
     tx: Transaction,
+    isV11Order = true,
   ): void {
     tx.moveCall({
-      target: `${this.consts.sudoCore.upgradedPackage}::market::clear_open_position_order_v1_1`,
+      target: `${this.consts.sudoCore.upgradedPackage}::market::clear_open_position_order_unified`,
       typeArguments: [
         `${this.consts.sudoCore.package}::slp::SLP`,
         this.consts.coins[collateralToken].module,
         this.consts.coins[indexToken].module,
         `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-        this.consts.coins.sui.module,
+        isV11Order ? this.consts.coins.sui.module : this.consts.coins[collateralToken].module,
       ],
       arguments: [
         tx.object(this.consts.sudoCore.market),
@@ -1002,15 +1123,16 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     indexToken: string,
     long: boolean,
     tx: Transaction,
+    isV11Order = true,
   ): void {
     tx.moveCall({
-      target: `${this.consts.sudoCore.upgradedPackage}::market::clear_decrease_position_order_v1_1`,
+      target: `${this.consts.sudoCore.upgradedPackage}::market::clear_decrease_position_order_unified`,
       typeArguments: [
         `${this.consts.sudoCore.package}::slp::SLP`,
         this.consts.coins[collateralToken].module,
         this.consts.coins[indexToken].module,
         `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-        this.consts.coins.sui.module,
+        isV11Order ? this.consts.coins.sui.module : this.consts.coins[collateralToken].module,
       ],
       arguments: [
         tx.object(this.consts.sudoCore.market),
@@ -1069,35 +1191,32 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
 
     // Handle oracle initialization and coin processing
     let suiCoinObject
-    let feeObject
     if (sponsoredTx) {
       suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
-      feeObject = tx.splitCoins(suiCoinObject, [tx.pure.u64(relayerFee)]) // Sudo contract requires SUI as fee
       tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
     }
     else {
-      feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee)]) // Sudo contract requires SUI as fee
       tx = await this.initOracleTxb([collateralToken, indexToken], tx)
     }
 
     // Process coin splitting
-    const [depositObject] = this.processCoinSplitting(
+    const [depositObject, feeObject] = this.processCoinSplitting(
       tx,
       collateralToken,
       coinObjects,
-      [tx.pure.u64(collateralAmount)],
+      [tx.pure.u64(collateralAmount), tx.pure.u64(relayerFee)],
       sponsoredTx,
       suiCoinObject,
     )
 
     tx.moveCall({
-      target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_v1_3`,
+      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.sui.module,
+        this.consts.coins[collateralToken].module,
       ],
       arguments: [
         tx.object(SUI_CLOCK_OBJECT_ID),
@@ -1116,7 +1235,6 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         tx.pure.u64(reserveAmount),
         tx.pure.u256(adjustCollateralPrice),
         tx.pure.u256(adjustPrice),
-        tx.pure.bool(isLimitOrder),
         sudoCard,
       ],
     })
@@ -1152,6 +1270,10 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     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)
 
@@ -1187,25 +1309,32 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
 
     // Handle oracle initialization and coin processing
     let suiCoinObject
-    let feeObject
     if (sponsoredTx) {
       suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
-      feeObject = tx.splitCoins(suiCoinObject, [tx.pure.u64(relayerFee)]) // Sudo contract requires SUI as fee
       tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject)
     }
     else {
-      feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee)]) // Sudo contract requires SUI as fee
       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_v1_3`,
+      target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_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.sui.module,
+        this.consts.coins[collateralToken].module,
       ],
       arguments: [
         tx.object(SUI_CLOCK_OBJECT_ID),
@@ -1223,7 +1352,6 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         tx.pure.u64(amount),
         tx.pure.u256(adjustCollateralPrice),
         tx.pure.u256(adjustPrice),
-        tx.pure.bool(isTriggerOrder),
         sudoCard,
       ],
     })
@@ -1329,13 +1457,13 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
       )
 
       tx.moveCall({
-        target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v1_3`,
+        target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_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.sui.module,
+          this.consts.coins[collateralToken].module,
         ],
         arguments: [
           tx.object(SUI_CLOCK_OBJECT_ID),
@@ -1353,7 +1481,6 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
           tx.pure.u64(amount),
           tx.pure.u256(adjustCollateralPrice),
           tx.pure.u256(adjustPrice),
-          tx.pure.bool(isTriggerOrder),
           sudoCard,
         ],
       })

package/src/implementations/SLPDataAPI.ts

@@ -30,6 +30,7 @@ import type {
   ISLPReservingFeeModel,
   ISLPStaked,
   ISLPStakePool,
+  ISLPSymbolConfig,
   ISLPSymbolInfo,
   ISLPVaultInfo,
 } from '../interfaces'
@@ -323,6 +324,28 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     return await this.parseSymbolInfo(rawData, long)
   }
 
+  /**
+   * Gets SLP symbol configuration
+   */
+  public async getSymbolConfig(indexToken: string, long: boolean): Promise<ISLPSymbolConfig | null> {
+    this.validateCache()
+    try {
+      const rawData = await this.provider.getDynamicFieldObject({
+        parentId: this.consts.sudoCore.market,
+        name: {
+          type: `${this.consts.sudoCore.package}::market::SymbolName<${this.consts.coins[indexToken].module}, ${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}>`,
+          value: { dummy_field: false },
+        },
+      })
+      return SLPDataAPI.parseSymbolConfig(rawData)
+    }
+    catch {
+      // If the dynamic field doesn't exist, return null
+      console.error('Symbol Config Not Found')
+      return null
+    }
+  }
+
   public async getPositionInfoList(
     positionCapInfoList: ISLPPositionCapInfo[],
     owner: string,
@@ -520,9 +543,10 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     const credentials = rawCredentialsData
       .filter(
         (item: any) =>
-          item.data.type ===
-          `${this.sharedConfig.zoStaking.package}::pool::Credential<${this.consts.sudoCore.package}::slp::SLP, ${this.consts.sudoCore.package}::slp::SLP>`
-      ).map((item: any) =>
+          item.data.type
+          === `${this.sharedConfig.zoStaking.package}::pool::Credential<${this.consts.sudoCore.package}::slp::SLP, ${this.consts.sudoCore.package}::slp::SLP>`,
+      )
+.map((item: any) =>
         SLPDataAPI.parseCredential(item, pool),
       )
     return {
@@ -902,8 +926,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
             name: {
               type: `${this.consts.sudoCore.package}::market::OrderName<${orderCapInfo.symbol0
                 }, ${orderCapInfo.symbol1}, ${this.consts.sudoCore.package
-                }::market::${orderCapInfo.long ? 'LONG' : 'SHORT'}, ${this.consts.coins.sui.module
-                }>`,
+                }::market::${orderCapInfo.long ? 'LONG' : 'SHORT'}, ${orderCapInfo.symbol0}>`,
               value: {
                 owner,
                 id: orderCapInfo.orderCapId,
@@ -1030,6 +1053,29 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     }
   }
 
+  private static parseSymbolConfig(raw: any): ISLPSymbolConfig {
+    const { fields } = raw.data.content
+
+    return {
+      id: fields.id.id,
+      max_opening_size: parseValue(fields.max_opening_size),
+      max_opening_size_enabled: fields.max_opening_size_enabled,
+      max_opening_size_per_position: parseValue(fields.max_opening_size_per_position),
+      max_opening_size_per_position_enabled: fields.max_opening_size_per_position_enabled,
+      instant_exit_fee_config: {
+        instant_exit_tier_1_duration_threshold: parseValue(fields.instant_exit_fee_config.fields.instant_exit_tier_1_duration_threshold),
+        instant_exit_tier_1_fee_bps: parseValue(fields.instant_exit_fee_config.fields.instant_exit_tier_1_fee_bps.fields.value),
+        instant_exit_tier_1_fee_enabled: fields.instant_exit_fee_config.fields.instant_exit_tier_1_fee_enabled,
+        instant_exit_tier_2_duration_threshold: parseValue(fields.instant_exit_fee_config.fields.instant_exit_tier_2_duration_threshold),
+        instant_exit_tier_2_fee_bps: parseValue(fields.instant_exit_fee_config.fields.instant_exit_tier_2_fee_bps.fields.value),
+        instant_exit_tier_2_fee_enabled: fields.instant_exit_fee_config.fields.instant_exit_tier_2_fee_enabled,
+        instant_exit_tier_3_duration_threshold: parseValue(fields.instant_exit_fee_config.fields.instant_exit_tier_3_duration_threshold),
+        instant_exit_tier_3_fee_bps: parseValue(fields.instant_exit_fee_config.fields.instant_exit_tier_3_fee_bps.fields.value),
+        instant_exit_tier_3_fee_enabled: fields.instant_exit_fee_config.fields.instant_exit_tier_3_fee_enabled,
+      },
+    }
+  }
+
   private static parseRebaseFeeModel(raw: any): ISLPRebaseFeeModel {
     const { fields } = raw.data.content
 
@@ -1201,6 +1247,9 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     const orderType = content.fields.value.type.includes('OpenPositionOrder')
       ? 'OPEN_POSITION'
       : 'DECREASE_POSITION'
+    const orderVersion = content.fields.value.type.includes('V2')
+      ? 'V2'
+      : 'V1_1'
 
     const ret: ISLPOrderInfo = {
       id: content.fields.id.id,
@@ -1221,6 +1270,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
       feeAmount: BigInt(fields.fee),
       long: dataType.includes('::market::LONG'),
       orderType,
+      orderVersion,
       createdAt: parseValue(fields.created_at),
     }
 
@@ -1281,7 +1331,8 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     // Use appropriate refresh method based on version
     if (isNewVersion) {
       SLPDataAPI.refreshPoolV2(pool, Math.floor(Date.now() / 1000))
-    } else {
+    }
+ else {
       SLPDataAPI.refreshPool(pool, Math.floor(Date.now() / 1000))
     }