@zofai/zo-sdk 0.2.25 → 0.2.27

package/dist/implementations/SLPAPI.mjs

@@ -6,14 +6,75 @@ import { KioskTransaction } from "@mysten/kiosk";
 import { Transaction } from "@mysten/sui/transactions";
 import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
 import { BaseAPI } from "../abstract/index.mjs";
+import { resolveSpendableSuiCoin } from "../coins.mjs";
 import { ALLOW_TRADE_CAN_TRADE, ALLOW_TRADE_MUST_TRADE, ALLOW_TRADE_NO_TRADE, LPToken } from "../consts/index.mjs";
-import { joinSymbol } from "../utils.mjs";
+import { buildOracleInputsAlt, oracleArgsAlt, oracleArgsRegistryFirst } from "../oraclePro.mjs";
+import { joinSymbol, parseSymbolKey } from "../utils.mjs";
 import { SLPDataAPI } from "./SLPDataAPI.mjs";
 export class SLPAPI extends BaseAPI {
     constructor(network, provider, apiEndpoint, connectionURL) {
         super(network, provider, apiEndpoint, connectionURL, LPToken.SLP);
         this.dataAPI = new SLPDataAPI(network, provider, apiEndpoint, connectionURL);
     }
+    slpLpType() {
+        return `${this.consts.sudoCore.package}::slp::SLP`;
+    }
+    positionTypeArgs(collateralToken, indexToken, long) {
+        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,
+        ];
+    }
+    redeemTypeArgs(collateralToken, indexToken, long) {
+        return [
+            this.slpLpType(),
+            this.consts.coins[collateralToken].module,
+            this.consts.coins[indexToken].module,
+            `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        ];
+    }
+    async initV3OracleForTokens(tokens, tx, pythProUpdateBytes, includeEmaPrice, options) {
+        const result = await this.initV3OracleTxb(tokens, tx, {
+            rawUpdateBytes: pythProUpdateBytes,
+            includeEmaPrice,
+            ...options,
+        });
+        return { tx: result.tx, oracle: result.oracle };
+    }
+    getValuationOracleTokens() {
+        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];
+    }
+    async initValuationOracle(tx) {
+        const tokens = this.getValuationOracleTokens();
+        const pythProUpdateBytes = await this.fetchPythProUpdateBytesForTokens(tokens);
+        return this.initV3OracleForTokens(tokens, tx, pythProUpdateBytes);
+    }
+    async resolveSponsoredSui(tx, collateralToken, relayerFee, sponsoredTx, sender) {
+        if (!sponsoredTx) {
+            return undefined;
+        }
+        const additional = collateralToken === 'sui' ? relayerFee : 0n;
+        if (additional === 0n) {
+            return undefined;
+        }
+        return resolveSpendableSuiCoin(tx, this.provider, this.requireSenderForSponsored(sender), additional);
+    }
+    positionFeeOracleArgs(tx, collateralToken, indexToken, long, oracle) {
+        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)),
+        ];
+    }
     calcPositionReserveFeeAmount(_position) {
         throw new Error(`Method not implemented in ${this.constructor.name}.`);
     }
@@ -25,48 +86,16 @@ export class SLPAPI extends BaseAPI {
      */
     async deposit(coin, coinObjects, amount, minAmountOut = 0, referralAddress, sender, sponsoredTx) {
         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;
-        }
-        // Handle non-sponsored transaction case
-        tx = (await this.initOracleTxb(pythFeederKeys, tx)).tx;
-        const depositObject = await this.resolveSplitCoinObject(tx, coin, BigInt(amount), coinObjects, { sender });
-        const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+        const { tx: txWithOracle, oracle } = await this.initValuationOracle(tx);
+        tx = txWithOracle;
+        const depositObject = await this.resolveSplitCoinObject(tx, coin, BigInt(amount), coinObjects, { sponsoredTx, sender });
+        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),
@@ -85,45 +114,16 @@ export class SLPAPI extends BaseAPI {
         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 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;
-        }
-        // Handle non-sponsored transaction case
-        tx = (await this.initOracleTxb(pythFeederKeys, tx)).tx;
-        const depositObject = await this.resolveSplitCoinObject(tx, coin, BigInt(amount), coinObjects, { sender });
-        const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+        const { tx: txWithOracle, oracle } = await this.initValuationOracle(tx);
+        tx = txWithOracle;
+        const depositObject = await this.resolveSplitCoinObject(tx, coin, BigInt(amount), coinObjects, { sponsoredTx, sender });
+        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),
@@ -142,47 +142,15 @@ export class SLPAPI extends BaseAPI {
         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 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 { 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::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),
@@ -202,28 +170,13 @@ export class SLPAPI extends BaseAPI {
             throw new Error(`${this.constructor.name}: lpCoinObjects or sender is required`);
         }
         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 withdrawObject = await this.resolveSplitCoinObject(tx, 'slp', BigInt(amount), lpCoinObjects, { sponsoredTx, suiCoinObject, sender });
-        const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+        const { tx: txWithOracle, oracle } = await this.initValuationOracle(tx);
+        tx = txWithOracle;
+        const withdrawObject = await this.resolveSplitCoinObject(tx, 'slp', BigInt(amount), lpCoinObjects, { sponsoredTx, sender });
+        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),
@@ -242,16 +195,12 @@ export class SLPAPI extends BaseAPI {
         if (!tx) {
             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),
@@ -270,28 +219,13 @@ export class SLPAPI extends BaseAPI {
         if (!tx) {
             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 withdrawObject = await this.resolveSplitCoinObject(tx, 'slp', BigInt(amount), lpCoinObjects, { sponsoredTx, suiCoinObject, sender });
-        const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+        const { tx: txWithOracle, oracle } = await this.initValuationOracle(tx);
+        tx = txWithOracle;
+        const withdrawObject = await this.resolveSplitCoinObject(tx, 'slp', BigInt(amount), lpCoinObjects, { sponsoredTx, sender });
+        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),
@@ -995,36 +929,17 @@ export class SLPAPI extends BaseAPI {
         return transaction;
     }
     async pledgeInPosition(pcpId, collateralToken, indexToken, amount, coinObjects, long, sponsoredTx, sender) {
-        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 depositObject = await this.resolveSplitCoinObject(tx, collateralToken, BigInt(amount), coinObjects, { sponsoredTx, suiCoinObject, sender });
+        const tx = new Transaction();
+        const depositObject = await this.resolveSplitCoinObject(tx, collateralToken, BigInt(amount), coinObjects, { 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;
     }
     async redeemFromPosition(pcpId, collateralToken, indexToken, amount, long, sponsoredTx, sender) {
@@ -1074,7 +989,7 @@ export class SLPAPI extends BaseAPI {
                 break;
             }
             case 'OPEN_MARKET': {
-                functionName = 'clear_open_market_order';
+                functionName = 'clear_open_position_order_unified';
                 break;
             }
             case 'DECREASE_POSITION': {
@@ -1082,7 +997,7 @@ export class SLPAPI extends BaseAPI {
                 break;
             }
             case 'DECREASE_MARKET': {
-                functionName = 'clear_decrease_market_order';
+                functionName = 'clear_decrease_position_order_unified';
                 break;
             }
             default: {
@@ -1118,7 +1033,7 @@ export class SLPAPI extends BaseAPI {
                     break;
                 }
                 case 'OPEN_MARKET': {
-                    functionName = 'clear_open_market_order';
+                    functionName = 'clear_open_position_order_unified';
                     break;
                 }
                 case 'DECREASE_POSITION': {
@@ -1126,7 +1041,7 @@ export class SLPAPI extends BaseAPI {
                     break;
                 }
                 case 'DECREASE_MARKET': {
-                    functionName = 'clear_decrease_market_order';
+                    functionName = 'clear_decrease_position_order_unified';
                     break;
                 }
                 default: {
@@ -1159,7 +1074,7 @@ export class SLPAPI extends BaseAPI {
             arguments: [tx.object(this.consts.sudoCore.market), tx.object(pcpId)],
         });
     }
-    clearOpenPositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order = true) {
+    clearOpenPositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order = false) {
         tx.moveCall({
             target: `${this.consts.sudoCore.upgradedPackage}::market::clear_open_position_order_unified`,
             typeArguments: [
@@ -1175,7 +1090,7 @@ export class SLPAPI extends BaseAPI {
             ],
         });
     }
-    clearDecreasePositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order = true) {
+    clearDecreasePositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order = false) {
         tx.moveCall({
             target: `${this.consts.sudoCore.upgradedPackage}::market::clear_decrease_position_order_unified`,
             typeArguments: [
@@ -1191,33 +1106,11 @@ export class SLPAPI extends BaseAPI {
             ],
         });
     }
-    clearOpenMarketOrder(orderCapId, collateralToken, indexToken, long, tx, _isV11Order) {
-        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)],
-        });
+    clearOpenMarketOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order = false) {
+        this.clearOpenPositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order);
     }
-    clearDecreaseMarketOrder(orderCapId, collateralToken, indexToken, long, tx, _isV11Order) {
-        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)],
-        });
+    clearDecreaseMarketOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order = false) {
+        this.clearDecreasePositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order);
     }
     async openPositionWithSCard(collateralToken, indexToken, size, collateralAmount, coinObjects, long, reserveAmount, indexPrice, collateralPrice, kioskClient, kioskCap, scard, isLimitOrder = false, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), referralAddress, sender, sponsoredTx) {
         let tx = new Transaction();
@@ -1880,6 +1773,328 @@ export class SLPAPI extends BaseAPI {
             ],
         });
     }
+    // --- Pyth Pro + Stork (v3_1 / swap_v4) ---
+    async swapV4(fromToken, toToken, fromAmount, fromCoinObjects, pythProUpdateBytes, minAmountOut, tx) {
+        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_;
+    }
+    async swapV4Ptb(fromToken, toToken, fromAmount, fromCoinObjects, pythProUpdateBytes, minAmountOut, tx) {
+        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;
+    }
+    async openPositionV3(collateralToken, indexToken, size, collateralAmount, coinObjects, long, reserveAmount, indexPrice, collateralPrice, pythProUpdateBytes, isLimitOrder, isIocOrder, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), referralAddress, sender, sponsoredTx) {
+        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;
+    }
+    async openPositionWithSCardV3(collateralToken, indexToken, size, collateralAmount, coinObjects, long, reserveAmount, indexPrice, collateralPrice, kioskClient, kioskCap, scard, pythProUpdateBytes, isLimitOrder, isIocOrder, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), referralAddress, sender, sponsoredTx) {
+        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;
+    }
+    async openPositionWithCoinV3(collateralToken, indexToken, size, coinObj, long, reserveAmount, indexPrice, collateralPrice, pythProUpdateBytes, isLimitOrder, isIocOrder, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), referralAddress, sender, tx, sponsoredTx) {
+        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;
+    }
+    async openPositionWithCoinAndSCardV3(collateralToken, indexToken, size, coinObj, long, reserveAmount, indexPrice, collateralPrice, kioskClient, kioskCap, scard, pythProUpdateBytes, isLimitOrder, isIocOrder, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), referralAddress, sender, tx, sponsoredTx) {
+        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;
+    }
+    async decreasePositionV3(pcpId, collateralToken, indexToken, amount, long, indexPrice, collateralPrice, pythProUpdateBytes, isTriggerOrder = false, isTakeProfitOrder = true, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), coinObjects, sponsoredTx, sender) {
+        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;
+    }
+    async decreasePositionWithSCardV3(pcpId, collateralToken, indexToken, amount, long, indexPrice, collateralPrice, kioskClient, kioskCap, scard, pythProUpdateBytes, isTriggerOrder = false, isTakeProfitOrder = true, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), coinObjects, sponsoredTx, sender) {
+        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;
+    }
+    async redeemFromPositionV3(pcpId, collateralToken, indexToken, amount, long, pythProUpdateBytes, tx) {
+        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
     claimTokenFromSCard(token, coinObjects, kioskClient, kioskCap, scard) {
         const tx = new Transaction();