zo-sdk 0.1.30 → 0.1.31

package/src/implementations/SLPAPI.ts

@@ -6,7 +6,8 @@
 import type { KioskClient, KioskOwnerCap } from '@mysten/kiosk'
 import { KioskTransaction } from '@mysten/kiosk'
 import type { SuiClient } from '@mysten/sui/client'
-import { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions'
+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'
@@ -638,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),
@@ -685,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
@@ -712,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)
 
@@ -736,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),
@@ -772,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),
       ],
     })
 
@@ -856,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),
@@ -880,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),
         ],
       })
     }
@@ -988,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: {
@@ -1011,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),
@@ -1037,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: {
@@ -1095,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),
@@ -1118,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),
@@ -1185,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),
@@ -1232,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,
       ],
     })
@@ -1268,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)
 
@@ -1303,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),
@@ -1339,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,
       ],
     })
@@ -1445,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),
@@ -1469,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))
     }
 

package/src/implementations/ZLPAPI.ts

@@ -6,14 +6,14 @@
 import type { KioskClient, KioskOwnerCap } from '@mysten/kiosk'
 import { KioskTransaction } from '@mysten/kiosk'
 import type { SuiClient } from '@mysten/sui/client'
-import { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions'
+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 {
-  IBaseCredential,
   IBaseHistoryResponse,
   IBaseMarketInfo,
   IBaseMarketValuationInfo,

package/src/interfaces/base.ts

@@ -125,6 +125,7 @@ export interface IBaseOrderInfo {
   orderType: 'OPEN_POSITION' | 'DECREASE_POSITION'
   createdAt: number
   v11Order?: boolean
+  orderVersion?: string
 }
 
 export interface IBasePositionConfig {
@@ -363,7 +364,9 @@ export interface IBaseAPI {
       relayerFee?: bigint
       coinObjects?: string[]
     }>,
-    tx?: Transaction
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
   ) => Promise<Transaction>
 
   pledgeInPosition: (
@@ -476,7 +479,9 @@ export interface IBaseAPI {
     pricesSlippage?: number,
     collateralSlippage?: number,
     relayerFee?: bigint,
-    coinObjects?: string[]
+    coinObjects?: string[],
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
   ) => Promise<Transaction>
 
   decreaseMultiPositionsWithSCard: (
@@ -499,7 +504,9 @@ export interface IBaseAPI {
     kioskClient: KioskClient,
     kioskCap: KioskOwnerCap,
     scard: string,
-    tx?: Transaction
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
   ) => Promise<Transaction>
 
   claimTokenFromSCard: (

package/src/interfaces/slp.ts

@@ -48,7 +48,9 @@ export interface ISLPPositionConfig extends IBasePositionConfig { }
 
 export interface ISLPPositionCapInfo extends IBasePositionCapInfo { }
 
-export interface ISLPOrderInfo extends IBaseOrderInfo { }
+export interface ISLPOrderInfo extends IBaseOrderInfo {
+  orderVersion: string
+}
 
 export interface ISLPOrderCapInfo extends IBaseOrderCapInfo { }
 
@@ -63,6 +65,28 @@ export interface ISLPStakePool extends IBaseStakePool {
 
 export interface ISLPCredential extends IBaseCredential { }
 
+// ZLP Symbol Config interfaces
+export interface ISLPPositionInstantExitFeeConfig {
+  instant_exit_tier_1_duration_threshold: number
+  instant_exit_tier_1_fee_bps: number
+  instant_exit_tier_1_fee_enabled: boolean
+  instant_exit_tier_2_duration_threshold: number
+  instant_exit_tier_2_fee_bps: number
+  instant_exit_tier_2_fee_enabled: boolean
+  instant_exit_tier_3_duration_threshold: number
+  instant_exit_tier_3_fee_bps: number
+  instant_exit_tier_3_fee_enabled: boolean
+}
+
+export interface ISLPSymbolConfig {
+  id: string
+  max_opening_size: number
+  max_opening_size_enabled: boolean
+  max_opening_size_per_position: number
+  max_opening_size_per_position_enabled: boolean
+  instant_exit_fee_config: ISLPPositionInstantExitFeeConfig
+}
+
 // Sudo SDK specific data structures
 export interface ISudoMarket {
   lpSupply: bigint
@@ -145,6 +169,7 @@ export interface ISudoStakeCredential {
 export interface ISLPDataAPI extends IBaseDataAPI {
   // SLP-specific data api methods can be added here
   getCumulativeApr: () => Promise<number>
+  getSymbolConfig: (indexToken: string, long: boolean) => Promise<ISLPSymbolConfig | null>
 }
 
 // SLP-specific API interface