@zofai/zo-sdk 0.2.26 → 0.2.28

package/src/implementations/SLPAPI.ts

@@ -10,6 +10,7 @@ import { Transaction } from '@mysten/sui/transactions'
 import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui/utils'
 
 import { BaseAPI } from '../abstract'
+import { resolveSpendableSuiCoin } from '../coins'
 import type { Network } from '../consts'
 import { ALLOW_TRADE_CAN_TRADE, ALLOW_TRADE_MUST_TRADE, ALLOW_TRADE_NO_TRADE, LPToken } from '../consts'
 import type {
@@ -17,8 +18,11 @@ import type {
   ISLPAPI,
   ISLPCredential,
 } from '../interfaces'
+import type { IInitPythProOracleOptions } from '../oracle'
+import type { OracleInputs } from '../oraclePro'
+import { buildOracleInputsAlt, oracleArgsAlt, oracleArgsRegistryFirst } from '../oraclePro'
 import type { SuiClient } from '../suiClient'
-import { joinSymbol } from '../utils'
+import { joinSymbol, parseSymbolKey } from '../utils'
 import { SLPDataAPI } from './SLPDataAPI'
 
 export class SLPAPI extends BaseAPI implements ISLPAPI {
@@ -34,6 +38,98 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     this.dataAPI = new SLPDataAPI(network, provider, apiEndpoint, connectionURL)
   }
 
+  private slpLpType(): string {
+    return `${this.consts.sudoCore.package}::slp::SLP`
+  }
+
+  private positionTypeArgs(collateralToken: string, indexToken: string, long: boolean): string[] {
+    return [
+      this.slpLpType(),
+      this.consts.coins[collateralToken].module,
+      this.consts.coins[indexToken].module,
+      `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+      this.consts.coins[collateralToken].module,
+    ]
+  }
+
+  private redeemTypeArgs(collateralToken: string, indexToken: string, long: boolean): string[] {
+    return [
+      this.slpLpType(),
+      this.consts.coins[collateralToken].module,
+      this.consts.coins[indexToken].module,
+      `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+    ]
+  }
+
+  private async initV3OracleForTokens(
+    tokens: string[],
+    tx: Transaction,
+    pythProUpdateBytes: Uint8Array | number[],
+    includeEmaPrice?: boolean,
+    options?: Pick<IInitPythProOracleOptions, 'storkUpdateData' | 'skipStork' | 'storkFeeSource' | 'kronosUrl'>,
+  ): Promise<{ tx: Transaction, oracle: OracleInputs }> {
+    const result = await this.initV3OracleTxb(tokens, tx, {
+      rawUpdateBytes: pythProUpdateBytes,
+      includeEmaPrice,
+      ...options,
+    })
+    return { tx: result.tx, oracle: result.oracle }
+  }
+
+  private getValuationOracleTokens(): string[] {
+    const tokens = new Set(Object.keys(this.consts.sudoCore.vaults))
+    for (const key of Object.keys(this.consts.sudoCore.symbols)) {
+      const [, token] = parseSymbolKey(key)
+      tokens.add(token)
+    }
+    return [...tokens]
+  }
+
+  private async initValuationOracle(
+    tx: Transaction,
+  ): Promise<{ tx: Transaction, oracle: OracleInputs }> {
+    const tokens = this.getValuationOracleTokens()
+    const pythProUpdateBytes = await this.fetchPythProUpdateBytesForTokens(tokens)
+    return this.initV3OracleForTokens(tokens, tx, pythProUpdateBytes)
+  }
+
+  private async resolveSponsoredSui(
+    tx: Transaction,
+    collateralToken: string,
+    relayerFee: bigint,
+    sponsoredTx?: boolean,
+    sender?: string,
+  ): Promise<TransactionObjectArgument | undefined> {
+    if (!sponsoredTx) {
+      return undefined
+    }
+    const additional = collateralToken === 'sui' ? relayerFee : 0n
+    if (additional === 0n) {
+      return undefined
+    }
+    return resolveSpendableSuiCoin(
+      tx,
+      this.provider,
+      this.requireSenderForSponsored(sender),
+      additional,
+    )
+  }
+
+  private positionFeeOracleArgs(
+    tx: Transaction,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    oracle: OracleInputs,
+  ): TransactionObjectArgument[] {
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+    return [
+      tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+      tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+      ...oracleArgsAlt(buildOracleInputsAlt(oracle)),
+    ]
+  }
+
   public calcPositionReserveFeeAmount(_position: IBasePositionInfo): Promise<number> {
     throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
@@ -56,68 +152,26 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
   ): 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 oracle = await this.initOracleTxb(pythFeederKeys, tx, true, {
-        sender: this.requireSenderForSponsored(sender),
-        additionalSuiAmount: coin === 'sui' ? BigInt(amount) : 0n,
-      })
-      tx = oracle.tx
-
-      const depositObject = await this.resolveSplitCoinObject(
-        tx,
-        coin,
-        BigInt(amount),
-        coinObjects,
-        { sponsoredTx: true, suiCoinObject: oracle.suiCoinObject, sender },
-      )
-
-      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
-    }
+    const { tx: txWithOracle, oracle } = await this.initValuationOracle(tx)
+    tx = txWithOracle
 
-    // Handle non-sponsored transaction case
-    tx = (await this.initOracleTxb(pythFeederKeys, tx)).tx
     const depositObject = await this.resolveSplitCoinObject(
       tx,
       coin,
       BigInt(amount),
       coinObjects,
-      { sender },
+      { sponsoredTx, sender },
     )
 
-    const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx)
+    const { vaultsValuation, symbolsValuation } = this.dataAPI.valuateV3(tx, oracle)
 
     tx.moveCall({
       target: `${this.consts.sudoCore.upgradedPackage}::market::deposit`,
-      typeArguments: [
-        `${this.consts.sudoCore.package}::slp::SLP`,
-        this.consts.coins[coin].module,
-      ],
+      typeArguments: [this.slpLpType(), this.consts.coins[coin].module],
       arguments: [
         tx.object(this.consts.sudoCore.market),
         tx.object(this.consts.sudoCore.rebaseFeeModel),
@@ -147,65 +201,26 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
       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 oracle = await this.initOracleTxb(pythFeederKeys, tx, true, {
-        sender: this.requireSenderForSponsored(sender),
-        additionalSuiAmount: coin === 'sui' ? BigInt(amount) : 0n,
-      })
-      tx = oracle.tx
-
-      const depositObject = await this.resolveSplitCoinObject(
-        tx,
-        coin,
-        BigInt(amount),
-        coinObjects,
-        { sponsoredTx: true, suiCoinObject: oracle.suiCoinObject, sender },
-      )
-
-      const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx)
-
-      const [mintedCoin] = tx.moveCall({
-        target: `${this.consts.sudoCore.upgradedPackage}::market::deposit_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),
-          depositObject,
-          tx.pure.u64(minAmountOut),
-          vaultsValuation,
-          symbolsValuation,
-        ],
-      })
-      return mintedCoin
-    }
+    const { tx: txWithOracle, oracle } = await this.initValuationOracle(tx)
+    tx = txWithOracle
 
-    // Handle non-sponsored transaction case
-    tx = (await this.initOracleTxb(pythFeederKeys, tx)).tx
     const depositObject = await this.resolveSplitCoinObject(
       tx,
       coin,
       BigInt(amount),
       coinObjects,
-      { sender },
+      { sponsoredTx, sender },
     )
 
-    const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx)
+    const { vaultsValuation, symbolsValuation } = this.dataAPI.valuateV3(tx, oracle)
 
     const [mintedCoin] = tx.moveCall({
       target: `${this.consts.sudoCore.upgradedPackage}::market::deposit_ptb`,
-      typeArguments: [
-        `${this.consts.sudoCore.package}::slp::SLP`,
-        this.consts.coins[coin].module,
-      ],
+      typeArguments: [this.slpLpType(), this.consts.coins[coin].module],
       arguments: [
         tx.object(this.consts.sudoCore.market),
         tx.object(this.consts.sudoCore.rebaseFeeModel),
@@ -215,7 +230,6 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         symbolsValuation,
       ],
     })
-
     return mintedCoin
   }
 
@@ -235,54 +249,18 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
       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 oracle = await this.initOracleTxb(pythFeederKeys, tx, true, {
-        sender: this.requireSenderForSponsored(sender),
-        additionalSuiAmount: 0n,
-      })
-      tx = oracle.tx
-      const { suiCoinObject } = oracle
-
-      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)).tx
+    const { tx: txWithOracle, oracle } = await this.initValuationOracle(tx)
+    tx = txWithOracle
 
-    const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx)
+    const { vaultsValuation, symbolsValuation } = this.dataAPI.valuateV3(tx, oracle)
 
     tx.moveCall({
       target: `${this.consts.sudoCore.upgradedPackage}::market::deposit`,
-      typeArguments: [
-        `${this.consts.sudoCore.package}::slp::SLP`,
-        this.consts.coins[coin].module,
-      ],
+      typeArguments: [this.slpLpType(), this.consts.coins[coin].module],
       arguments: [
         tx.object(this.consts.sudoCore.market),
         tx.object(this.consts.sudoCore.rebaseFeeModel),
@@ -312,37 +290,21 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
 
     let tx = new Transaction()
 
-    // Initialize oracle transaction
-    const pythFeederKeys = Object.keys(this.consts.pythFeeder.feeder)
-
-    let suiCoinObject
-    if (sponsoredTx) {
-      const oracle = await this.initOracleTxb(pythFeederKeys, tx, true, {
-        sender: this.requireSenderForSponsored(sender),
-        additionalSuiAmount: 0n,
-      })
-      tx = oracle.tx
-      suiCoinObject = oracle.suiCoinObject
-    }
-    else {
-      tx = (await this.initOracleTxb(pythFeederKeys, tx)).tx
-    }
+    const { tx: txWithOracle, oracle } = await this.initValuationOracle(tx)
+    tx = txWithOracle
 
     const withdrawObject = await this.resolveSplitCoinObject(
       tx,
       'slp',
       BigInt(amount),
       lpCoinObjects,
-      { sponsoredTx, suiCoinObject, sender },
+      { sponsoredTx, sender },
     )
-    const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx)
+    const { vaultsValuation, symbolsValuation } = this.dataAPI.valuateV3(tx, oracle)
 
     tx.moveCall({
       target: `${this.consts.sudoCore.upgradedPackage}::market::withdraw`,
-      typeArguments: [
-        `${this.consts.sudoCore.package}::slp::SLP`,
-        this.consts.coins[coin].module,
-      ],
+      typeArguments: [this.slpLpType(), this.consts.coins[coin].module],
       arguments: [
         tx.object(this.consts.sudoCore.market),
         tx.object(this.consts.sudoCore.rebaseFeeModel),
@@ -368,18 +330,13 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
       tx = new Transaction()
     }
 
-    // Initialize oracle transaction
-    const pythFeederKeys = Object.keys(this.consts.pythFeeder.feeder)
-
-    tx = (await this.initOracleTxb(pythFeederKeys, tx)).tx
-    const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx)
+    const { tx: txWithOracle, oracle } = await this.initValuationOracle(tx)
+    tx = txWithOracle
+    const { vaultsValuation, symbolsValuation } = this.dataAPI.valuateV3(tx, oracle)
 
     tx.moveCall({
       target: `${this.consts.sudoCore.upgradedPackage}::market::withdraw`,
-      typeArguments: [
-        `${this.consts.sudoCore.package}::slp::SLP`,
-        this.consts.coins[coin].module,
-      ],
+      typeArguments: [this.slpLpType(), this.consts.coins[coin].module],
       arguments: [
         tx.object(this.consts.sudoCore.market),
         tx.object(this.consts.sudoCore.rebaseFeeModel),
@@ -409,37 +366,21 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
       tx = new Transaction()
     }
 
-    // Initialize oracle transaction
-    const pythFeederKeys = Object.keys(this.consts.pythFeeder.feeder)
-
-    let suiCoinObject
-    if (sponsoredTx) {
-      const oracle = await this.initOracleTxb(pythFeederKeys, tx, true, {
-        sender: this.requireSenderForSponsored(sender),
-        additionalSuiAmount: 0n,
-      })
-      tx = oracle.tx
-      suiCoinObject = oracle.suiCoinObject
-    }
-    else {
-      tx = (await this.initOracleTxb(pythFeederKeys, tx)).tx
-    }
+    const { tx: txWithOracle, oracle } = await this.initValuationOracle(tx)
+    tx = txWithOracle
 
     const withdrawObject = await this.resolveSplitCoinObject(
       tx,
       'slp',
       BigInt(amount),
       lpCoinObjects,
-      { sponsoredTx, suiCoinObject, sender },
+      { sponsoredTx, sender },
     )
-    const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx)
+    const { vaultsValuation, symbolsValuation } = this.dataAPI.valuateV3(tx, oracle)
 
     const [withdrawCoin] = tx.moveCall({
       target: `${this.consts.sudoCore.upgradedPackage}::market::withdraw_ptb`,
-      typeArguments: [
-        `${this.consts.sudoCore.package}::slp::SLP`,
-        this.consts.coins[coin].module,
-      ],
+      typeArguments: [this.slpLpType(), this.consts.coins[coin].module],
       arguments: [
         tx.object(this.consts.sudoCore.market),
         tx.object(this.consts.sudoCore.rebaseFeeModel),
@@ -1486,45 +1427,25 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     sponsoredTx?: boolean,
     sender?: string,
   ): Promise<Transaction> {
-    let tx = new Transaction()
-
-    // Handle oracle initialization and coin processing
-    let suiCoinObject
-    if (sponsoredTx) {
-      const oracle = await this.initOracleTxb([collateralToken, indexToken], tx, true, {
-        sender: this.requireSenderForSponsored(sender),
-        additionalSuiAmount: collateralToken === 'sui' ? BigInt(amount) : 0n,
-      })
-      tx = oracle.tx
-      suiCoinObject = oracle.suiCoinObject
-    }
-    else {
-      tx = (await this.initOracleTxb([collateralToken, indexToken], tx)).tx
-    }
+    const tx = new Transaction()
 
     const depositObject = await this.resolveSplitCoinObject(
       tx,
       collateralToken,
       BigInt(amount),
       coinObjects,
-      { sponsoredTx, suiCoinObject, sender },
+      { sponsoredTx, sender },
     )
 
     tx.moveCall({
       target: `${this.consts.sudoCore.upgradedPackage}::market::pledge_in_position`,
-      typeArguments: [
-        `${this.consts.sudoCore.package}::slp::SLP`,
-        this.consts.coins[collateralToken].module,
-        this.consts.coins[indexToken].module,
-        `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-      ],
+      typeArguments: this.redeemTypeArgs(collateralToken, indexToken, long),
       arguments: [
         tx.object(this.consts.sudoCore.market),
         tx.object(pcpId),
         depositObject,
       ],
     })
-    this.returnUnusedSuiCoin(tx, suiCoinObject, sender)
     return tx
   }
 
@@ -1595,7 +1516,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         break
       }
       case 'OPEN_MARKET': {
-        functionName = 'clear_open_market_order'
+        functionName = 'clear_open_position_order_unified'
         break
       }
       case 'DECREASE_POSITION': {
@@ -1603,7 +1524,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
         break
       }
       case 'DECREASE_MARKET': {
-        functionName = 'clear_decrease_market_order'
+        functionName = 'clear_decrease_position_order_unified'
         break
       }
       default: {
@@ -1651,7 +1572,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
           break
         }
         case 'OPEN_MARKET': {
-          functionName = 'clear_open_market_order'
+          functionName = 'clear_open_position_order_unified'
           break
         }
         case 'DECREASE_POSITION': {
@@ -1659,7 +1580,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
           break
         }
         case 'DECREASE_MARKET': {
-          functionName = 'clear_decrease_market_order'
+          functionName = 'clear_decrease_position_order_unified'
           break
         }
         default: {
@@ -1707,7 +1628,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     indexToken: string,
     long: boolean,
     tx: Transaction,
-    isV11Order = true,
+    isV11Order = false,
   ): void {
     tx.moveCall({
       target: `${this.consts.sudoCore.upgradedPackage}::market::clear_open_position_order_unified`,
@@ -1731,7 +1652,7 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     indexToken: string,
     long: boolean,
     tx: Transaction,
-    isV11Order = true,
+    isV11Order = false,
   ): void {
     tx.moveCall({
       target: `${this.consts.sudoCore.upgradedPackage}::market::clear_decrease_position_order_unified`,
@@ -1755,20 +1676,9 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     indexToken: string,
     long: boolean,
     tx: Transaction,
-    _isV11Order?: boolean,
+    isV11Order = false,
   ): 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)],
-    })
+    this.clearOpenPositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order)
   }
 
   public clearDecreaseMarketOrder(
@@ -1777,20 +1687,9 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     indexToken: string,
     long: boolean,
     tx: Transaction,
-    _isV11Order?: boolean,
+    isV11Order = false,
   ): 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)],
-    })
+    this.clearDecreasePositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order)
   }
 
   public async openPositionWithSCard(
@@ -2841,6 +2740,591 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     })
   }
 
+  // --- Pyth Pro + Stork (v3_1 / swap_v4) ---
+
+  public async swapV4(
+    fromToken: string,
+    toToken: string,
+    fromAmount: bigint,
+    fromCoinObjects: string[],
+    pythProUpdateBytes: Uint8Array | number[],
+    minAmountOut?: number,
+    tx?: Transaction,
+  ): Promise<Transaction> {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    const { tx: tx_, oracle } = await this.initV3OracleForTokens(
+      Object.keys(this.consts.sudoCore.vaults),
+      tx,
+      pythProUpdateBytes,
+      true,
+    )
+    const fromCoinObject = this.processCoins(tx_, fromToken, fromCoinObjects)
+    const [fromDepositObject] = tx_.splitCoins(fromCoinObject, [tx_.pure.u64(fromAmount)])
+    const vaultsValuation = this.dataAPI.valuateVaultsV3(tx_, oracle)
+
+    tx_.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::swap_v4`,
+      typeArguments: [this.slpLpType(), this.consts.coins[fromToken].module, this.consts.coins[toToken].module],
+      arguments: [
+        tx_.object(this.consts.sudoCore.market),
+        tx_.object(this.consts.sudoCore.rebaseFeeModel),
+        fromDepositObject,
+        tx_.pure.u64(minAmountOut || 0),
+        vaultsValuation,
+        ...oracleArgsRegistryFirst(oracle),
+      ],
+    })
+    return tx_
+  }
+
+  public async swapV4Ptb(
+    fromToken: string,
+    toToken: string,
+    fromAmount: bigint,
+    fromCoinObjects: string[],
+    pythProUpdateBytes: Uint8Array | number[],
+    minAmountOut?: number,
+    tx?: Transaction,
+  ): Promise<TransactionObjectArgument> {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    const { tx: tx_, oracle } = await this.initV3OracleForTokens(
+      Object.keys(this.consts.sudoCore.vaults),
+      tx,
+      pythProUpdateBytes,
+      true,
+    )
+    const fromCoinObject = this.processCoins(tx_, fromToken, fromCoinObjects)
+    const [fromDepositObject] = tx_.splitCoins(fromCoinObject, [tx_.pure.u64(fromAmount)])
+    const vaultsValuation = this.dataAPI.valuateVaultsV3(tx_, oracle)
+
+    const [outputCoin] = tx_.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::swap_v4_ptb`,
+      typeArguments: [this.slpLpType(), this.consts.coins[fromToken].module, this.consts.coins[toToken].module],
+      arguments: [
+        tx_.object(this.consts.sudoCore.market),
+        tx_.object(this.consts.sudoCore.rebaseFeeModel),
+        fromDepositObject,
+        tx_.pure.u64(minAmountOut || 0),
+        vaultsValuation,
+        ...oracleArgsRegistryFirst(oracle),
+      ],
+    })
+    return outputCoin
+  }
+
+  public async openPositionV3(
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    collateralAmount: bigint,
+    coinObjects: string[],
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    pythProUpdateBytes: Uint8Array | number[],
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    referralAddress?: string,
+    sender?: string,
+    sponsoredTx?: boolean,
+  ): 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 { tx: tx_, oracle } = await this.initV3OracleForTokens(
+      [collateralToken, indexToken],
+      tx,
+      pythProUpdateBytes,
+    )
+    tx = tx_
+
+    const suiCoinObject = await this.resolveSponsoredSui(tx, collateralToken, relayerFee, sponsoredTx, sender)
+    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_1`,
+      typeArguments: this.positionTypeArgs(collateralToken, indexToken, long),
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+        ...oracleArgsAlt(buildOracleInputsAlt(oracle)),
+        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
+  }
+
+  public async openPositionWithSCardV3(
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    collateralAmount: bigint,
+    coinObjects: string[],
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    pythProUpdateBytes: Uint8Array | number[],
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    referralAddress?: string,
+    sender?: string,
+    sponsoredTx?: boolean,
+  ): 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: `${this.consts.sudoNft.package}::card::SudoCard`,
+      itemId: scard,
+    })
+
+    const { tx: tx_, oracle } = await this.initV3OracleForTokens(
+      [collateralToken, indexToken],
+      tx,
+      pythProUpdateBytes,
+    )
+    tx = tx_
+
+    const suiCoinObject = await this.resolveSponsoredSui(tx, collateralToken, relayerFee, sponsoredTx, sender)
+    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_v3_1`,
+      typeArguments: this.positionTypeArgs(collateralToken, indexToken, long),
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+        ...oracleArgsAlt(buildOracleInputsAlt(oracle)),
+        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: `${this.consts.sudoNft.package}::card::SudoCard`,
+      item: sudoCard,
+      promise,
+    }).finalize()
+    return tx
+  }
+
+  public async openPositionWithCoinV3(
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    coinObj: TransactionObjectArgument,
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    pythProUpdateBytes: Uint8Array | number[],
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    referralAddress?: string,
+    sender?: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+  ): 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 { tx: tx_, oracle } = await this.initV3OracleForTokens(
+      [collateralToken, indexToken],
+      tx,
+      pythProUpdateBytes,
+    )
+    tx = tx_
+
+    const [feeObject] = tx.splitCoins(coinObj, [tx.pure.u64(relayerFee)])
+
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_v3_1`,
+      typeArguments: this.positionTypeArgs(collateralToken, indexToken, long),
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+        ...oracleArgsAlt(buildOracleInputsAlt(oracle)),
+        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
+  }
+
+  public async openPositionWithCoinAndSCardV3(
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    coinObj: TransactionObjectArgument,
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    pythProUpdateBytes: Uint8Array | number[],
+    isLimitOrder?: boolean,
+    isIocOrder?: boolean,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    referralAddress?: string,
+    sender?: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+  ): 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: `${this.consts.sudoNft.package}::card::SudoCard`,
+      itemId: scard,
+    })
+
+    const { tx: tx_, oracle } = await this.initV3OracleForTokens(
+      [collateralToken, indexToken],
+      tx,
+      pythProUpdateBytes,
+    )
+    tx = tx_
+
+    const [feeObject] = tx.splitCoins(coinObj, [tx.pure.u64(relayerFee)])
+
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_with_scard_v3_1`,
+      typeArguments: this.positionTypeArgs(collateralToken, indexToken, long),
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+        ...oracleArgsAlt(buildOracleInputsAlt(oracle)),
+        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: `${this.consts.sudoNft.package}::card::SudoCard`,
+      item: sudoCard,
+      promise,
+    }).finalize()
+    return tx
+  }
+
+  public async decreasePositionV3(
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: bigint,
+    long: boolean,
+    indexPrice: number,
+    collateralPrice: number,
+    pythProUpdateBytes: Uint8Array | number[],
+    isTriggerOrder = false,
+    isTakeProfitOrder = true,
+    isIocOrder = false,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    coinObjects?: string[],
+    sponsoredTx?: boolean,
+    sender?: string,
+  ): Promise<Transaction> {
+    if (!coinObjects?.length && !sender) {
+      throw new Error(`${this.constructor.name}: coinObjects or sender 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
+    }
+
+    const { tx: tx_, oracle } = await this.initV3OracleForTokens(
+      [collateralToken, indexToken],
+      tx,
+      pythProUpdateBytes,
+    )
+    tx = tx_
+
+    const suiCoinObject = await this.resolveSponsoredSui(tx, collateralToken, relayerFee, sponsoredTx, sender)
+    const feeObject = await this.resolveRelayerFeeObject(
+      tx,
+      collateralToken,
+      coinObjects ?? [],
+      relayerFee,
+      sponsoredTx,
+      suiCoinObject,
+      sender,
+    )
+
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v3_1`,
+      typeArguments: this.positionTypeArgs(collateralToken, indexToken, long),
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(pcpId),
+        ...oracleArgsAlt(buildOracleInputsAlt(oracle)),
+        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 decreasePositionWithSCardV3(
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: bigint,
+    long: boolean,
+    indexPrice: number,
+    collateralPrice: number,
+    kioskClient: KioskClient,
+    kioskCap: KioskOwnerCap,
+    scard: string,
+    pythProUpdateBytes: Uint8Array | number[],
+    isTriggerOrder = false,
+    isTakeProfitOrder = true,
+    isIocOrder = false,
+    pricesSlippage = 0.003,
+    collateralSlippage = 0.5,
+    relayerFee = BigInt(0.5),
+    coinObjects?: string[],
+    sponsoredTx?: boolean,
+    sender?: string,
+  ): Promise<Transaction> {
+    if (!coinObjects?.length && !sender) {
+      throw new Error(`${this.constructor.name}: coinObjects or sender 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
+    }
+
+    const kioskTx = new KioskTransaction({ transaction: tx, kioskClient, cap: kioskCap })
+    const [sudoCard, promise] = kioskTx.borrow({
+      itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+      itemId: scard,
+    })
+
+    const { tx: tx_, oracle } = await this.initV3OracleForTokens(
+      [collateralToken, indexToken],
+      tx,
+      pythProUpdateBytes,
+    )
+    tx = tx_
+
+    const suiCoinObject = await this.resolveSponsoredSui(tx, collateralToken, relayerFee, sponsoredTx, sender)
+    const feeObject = await this.resolveRelayerFeeObject(
+      tx,
+      collateralToken,
+      coinObjects ?? [],
+      relayerFee,
+      sponsoredTx,
+      suiCoinObject,
+      sender,
+    )
+
+    tx.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_with_scard_v3_1`,
+      typeArguments: this.positionTypeArgs(collateralToken, indexToken, long),
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.sudoCore.market),
+        tx.object(pcpId),
+        ...oracleArgsAlt(buildOracleInputsAlt(oracle)),
+        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 redeemFromPositionV3(
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: number,
+    long: boolean,
+    pythProUpdateBytes: Uint8Array | number[],
+    tx?: Transaction,
+  ): Promise<Transaction> {
+    if (!tx) {
+      tx = new Transaction()
+    }
+
+    const { tx: tx_, oracle } = await this.initV3OracleForTokens(
+      [collateralToken, indexToken],
+      tx,
+      pythProUpdateBytes,
+    )
+
+    tx_.moveCall({
+      target: `${this.consts.sudoCore.upgradedPackage}::market::redeem_from_position_v3_1`,
+      typeArguments: this.redeemTypeArgs(collateralToken, indexToken, long),
+      arguments: [
+        tx_.object(SUI_CLOCK_OBJECT_ID),
+        tx_.object(this.consts.sudoCore.market),
+        tx_.object(pcpId),
+        ...this.positionFeeOracleArgs(tx_, collateralToken, indexToken, long, oracle),
+        tx_.pure.u64(amount),
+      ],
+    })
+    return tx_
+  }
+
   // SLP Specific APIs
   public claimTokenFromSCard(
     token: string,