@zofai/zo-sdk 0.2.26 → 0.2.27

package/dist/implementations/SLPAPI.cjs

@@ -9,7 +9,9 @@ const kiosk_1 = require("@mysten/kiosk");
 const transactions_1 = require("@mysten/sui/transactions");
 const utils_1 = require("@mysten/sui/utils");
 const abstract_1 = require("../abstract/index.cjs");
+const coins_1 = require("../coins.cjs");
 const consts_1 = require("../consts/index.cjs");
+const oraclePro_1 = require("../oraclePro.cjs");
 const utils_2 = require("../utils.cjs");
 const SLPDataAPI_1 = require("./SLPDataAPI.cjs");
 class SLPAPI extends abstract_1.BaseAPI {
@@ -17,6 +19,65 @@ class SLPAPI extends abstract_1.BaseAPI {
         super(network, provider, apiEndpoint, connectionURL, consts_1.LPToken.SLP);
         this.dataAPI = new SLPDataAPI_1.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] = (0, utils_2.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 (0, coins_1.resolveSpendableSuiCoin)(tx, this.provider, this.requireSenderForSponsored(sender), additional);
+    }
+    positionFeeOracleArgs(tx, collateralToken, indexToken, long, oracle) {
+        const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+        return [
+            tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+            tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+            ...(0, oraclePro_1.oracleArgsAlt)((0, oraclePro_1.buildOracleInputsAlt)(oracle)),
+        ];
+    }
     calcPositionReserveFeeAmount(_position) {
         throw new Error(`Method not implemented in ${this.constructor.name}.`);
     }
@@ -28,48 +89,16 @@ class SLPAPI extends abstract_1.BaseAPI {
      */
     async deposit(coin, coinObjects, amount, minAmountOut = 0, referralAddress, sender, sponsoredTx) {
         let tx = new transactions_1.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),
@@ -88,45 +117,16 @@ class SLPAPI extends abstract_1.BaseAPI {
         if (!tx) {
             tx = new transactions_1.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),
@@ -145,47 +145,15 @@ class SLPAPI extends abstract_1.BaseAPI {
         if (!tx) {
             tx = new transactions_1.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),
@@ -205,28 +173,13 @@ class SLPAPI extends abstract_1.BaseAPI {
             throw new Error(`${this.constructor.name}: lpCoinObjects or sender is required`);
         }
         let tx = new transactions_1.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),
@@ -245,16 +198,12 @@ class SLPAPI extends abstract_1.BaseAPI {
         if (!tx) {
             tx = new transactions_1.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),
@@ -273,28 +222,13 @@ class SLPAPI extends abstract_1.BaseAPI {
         if (!tx) {
             tx = new transactions_1.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),
@@ -998,36 +932,17 @@ class SLPAPI extends abstract_1.BaseAPI {
         return transaction;
     }
     async pledgeInPosition(pcpId, collateralToken, indexToken, amount, coinObjects, long, sponsoredTx, sender) {
-        let tx = new transactions_1.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 transactions_1.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) {
@@ -1077,7 +992,7 @@ class SLPAPI extends abstract_1.BaseAPI {
                 break;
             }
             case 'OPEN_MARKET': {
-                functionName = 'clear_open_market_order';
+                functionName = 'clear_open_position_order_unified';
                 break;
             }
             case 'DECREASE_POSITION': {
@@ -1085,7 +1000,7 @@ class SLPAPI extends abstract_1.BaseAPI {
                 break;
             }
             case 'DECREASE_MARKET': {
-                functionName = 'clear_decrease_market_order';
+                functionName = 'clear_decrease_position_order_unified';
                 break;
             }
             default: {
@@ -1121,7 +1036,7 @@ class SLPAPI extends abstract_1.BaseAPI {
                     break;
                 }
                 case 'OPEN_MARKET': {
-                    functionName = 'clear_open_market_order';
+                    functionName = 'clear_open_position_order_unified';
                     break;
                 }
                 case 'DECREASE_POSITION': {
@@ -1129,7 +1044,7 @@ class SLPAPI extends abstract_1.BaseAPI {
                     break;
                 }
                 case 'DECREASE_MARKET': {
-                    functionName = 'clear_decrease_market_order';
+                    functionName = 'clear_decrease_position_order_unified';
                     break;
                 }
                 default: {
@@ -1162,7 +1077,7 @@ class SLPAPI extends abstract_1.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: [
@@ -1178,7 +1093,7 @@ class SLPAPI extends abstract_1.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: [
@@ -1194,33 +1109,11 @@ class SLPAPI extends abstract_1.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 transactions_1.Transaction();
@@ -1883,6 +1776,328 @@ class SLPAPI extends abstract_1.BaseAPI {
             ],
         });
     }
+    // --- Pyth Pro + Stork (v3_1 / swap_v4) ---
+    async swapV4(fromToken, toToken, fromAmount, fromCoinObjects, pythProUpdateBytes, minAmountOut, tx) {
+        if (!tx) {
+            tx = new transactions_1.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,
+                ...(0, oraclePro_1.oracleArgsRegistryFirst)(oracle),
+            ],
+        });
+        return tx_;
+    }
+    async swapV4Ptb(fromToken, toToken, fromAmount, fromCoinObjects, pythProUpdateBytes, minAmountOut, tx) {
+        if (!tx) {
+            tx = new transactions_1.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,
+                ...(0, oraclePro_1.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 transactions_1.Transaction();
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        const symbol = (0, utils_2.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 = consts_1.ALLOW_TRADE_MUST_TRADE;
+        if (isLimitOrder) {
+            allowTrade = isIocOrder ? consts_1.ALLOW_TRADE_NO_TRADE : consts_1.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(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+                ...(0, oraclePro_1.oracleArgsAlt)((0, oraclePro_1.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 transactions_1.Transaction();
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        const symbol = (0, utils_2.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 = consts_1.ALLOW_TRADE_MUST_TRADE;
+        if (isLimitOrder) {
+            allowTrade = isIocOrder ? consts_1.ALLOW_TRADE_NO_TRADE : consts_1.ALLOW_TRADE_CAN_TRADE;
+        }
+        const kioskTx = new kiosk_1.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(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+                ...(0, oraclePro_1.oracleArgsAlt)((0, oraclePro_1.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 transactions_1.Transaction();
+        }
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        const symbol = (0, utils_2.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 = consts_1.ALLOW_TRADE_MUST_TRADE;
+        if (isLimitOrder) {
+            allowTrade = isIocOrder ? consts_1.ALLOW_TRADE_NO_TRADE : consts_1.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(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+                ...(0, oraclePro_1.oracleArgsAlt)((0, oraclePro_1.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 transactions_1.Transaction();
+        }
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        const symbol = (0, utils_2.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 = consts_1.ALLOW_TRADE_MUST_TRADE;
+        if (isLimitOrder) {
+            allowTrade = isIocOrder ? consts_1.ALLOW_TRADE_NO_TRADE : consts_1.ALLOW_TRADE_CAN_TRADE;
+        }
+        const kioskTx = new kiosk_1.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(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+                ...(0, oraclePro_1.oracleArgsAlt)((0, oraclePro_1.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 transactions_1.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 = consts_1.ALLOW_TRADE_MUST_TRADE;
+        if (isTriggerOrder) {
+            allowTrade = isIocOrder || !isTakeProfitOrder ? consts_1.ALLOW_TRADE_NO_TRADE : consts_1.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(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(pcpId),
+                ...(0, oraclePro_1.oracleArgsAlt)((0, oraclePro_1.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 transactions_1.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 = consts_1.ALLOW_TRADE_MUST_TRADE;
+        if (isTriggerOrder) {
+            allowTrade = isIocOrder || !isTakeProfitOrder ? consts_1.ALLOW_TRADE_NO_TRADE : consts_1.ALLOW_TRADE_CAN_TRADE;
+        }
+        else {
+            isTakeProfitOrder = true;
+        }
+        const kioskTx = new kiosk_1.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(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(pcpId),
+                ...(0, oraclePro_1.oracleArgsAlt)((0, oraclePro_1.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 transactions_1.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(utils_1.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 transactions_1.Transaction();