@zofai/zo-sdk 0.1.92

package/dist/implementations/SLPAPI.cjs

@@ -0,0 +1,1794 @@
+"use strict";
+/**
+ * SLP API implementation
+ * Implements SLP-specific trading and transaction methods for Sudo SDK
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SLPAPI = void 0;
+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 consts_1 = require("../consts/index.cjs");
+const utils_2 = require("../utils.cjs");
+const SLPDataAPI_1 = require("./SLPDataAPI.cjs");
+class SLPAPI extends abstract_1.BaseAPI {
+    constructor(network, provider, apiEndpoint, connectionURL) {
+        super(network, provider, apiEndpoint, connectionURL, consts_1.LPToken.SLP);
+        this.dataAPI = new SLPDataAPI_1.SLPDataAPI(network, provider, apiEndpoint, connectionURL);
+    }
+    calcPositionReserveFeeAmount(_position) {
+        throw new Error(`Method not implemented in ${this.constructor.name}.`);
+    }
+    calcPositionFundingFeeValue(_position) {
+        throw new Error(`Method not implemented in ${this.constructor.name}.`);
+    }
+    /**
+     * Deposits collateral into SLP vault using Sudo SDK approach
+     */
+    async deposit(coin, coinObjects, amount, minAmountOut = 0, referralAddress, sender, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        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 suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb(pythFeederKeys, tx, true, suiCoinObject);
+            // Process deposit coins
+            const depositObject = coin === 'sui'
+                ? tx.splitCoins(suiCoinObject, [tx.pure.u64(amount)])[0]
+                : tx.splitCoins(this.processCoins(tx, coin, coinObjects, true), [tx.pure.u64(amount)])[0];
+            const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+            tx.moveCall({
+                target: `${this.consts.sudoCore.upgradedPackage}::market::deposit`,
+                typeArguments: [
+                    `${this.consts.sudoCore.package}::slp::SLP`,
+                    this.consts.coins[coin].module,
+                ],
+                arguments: [
+                    tx.object(this.consts.sudoCore.market),
+                    tx.object(this.consts.sudoCore.rebaseFeeModel),
+                    depositObject,
+                    tx.pure.u64(minAmountOut),
+                    vaultsValuation,
+                    symbolsValuation,
+                ],
+            });
+            return tx;
+        }
+        // Handle non-sponsored transaction case
+        tx = await this.initOracleTxb(pythFeederKeys, tx);
+        const depositObject = tx.splitCoins(this.processCoins(tx, coin, coinObjects, false), [tx.pure.u64(amount)])[0];
+        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;
+    }
+    /**
+     * Deposits collateral into SLP vault and returns a coin
+     */
+    async depositPtb(coin, coinObjects, amount, minAmountOut = 0, referralAddress, sender, tx, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        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 suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb(pythFeederKeys, tx, true, suiCoinObject);
+            // Process deposit coins
+            const depositObject = coin === 'sui'
+                ? tx.splitCoins(suiCoinObject, [tx.pure.u64(amount)])[0]
+                : tx.splitCoins(this.processCoins(tx, coin, coinObjects, true), [tx.pure.u64(amount)])[0];
+            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);
+        const depositObject = tx.splitCoins(this.processCoins(tx, coin, coinObjects, false), [tx.pure.u64(amount)])[0];
+        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;
+    }
+    /**
+     * Deposits collateral pool with PTB deposit object
+     */
+    async depositWithPtb(coin, depositObject, minAmountOut = 0, referralAddress, sender, tx, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        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 suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb(pythFeederKeys, tx, true, suiCoinObject);
+            const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+            tx.moveCall({
+                target: `${this.consts.sudoCore.upgradedPackage}::market::deposit`,
+                typeArguments: [
+                    `${this.consts.sudoCore.package}::slp::SLP`,
+                    this.consts.coins[coin].module,
+                ],
+                arguments: [
+                    tx.object(this.consts.sudoCore.market),
+                    tx.object(this.consts.sudoCore.rebaseFeeModel),
+                    depositObject,
+                    tx.pure.u64(minAmountOut),
+                    vaultsValuation,
+                    symbolsValuation,
+                ],
+            });
+            return tx;
+        }
+        // Handle non-sponsored transaction case
+        tx = await this.initOracleTxb(pythFeederKeys, tx);
+        const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::deposit`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[coin].module,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.rebaseFeeModel),
+                depositObject,
+                tx.pure.u64(minAmountOut),
+                vaultsValuation,
+                symbolsValuation,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Withdraws collateral from SLP vault using Sudo SDK approach
+     */
+    async withdraw(coin, lpCoinObjects, amount, minAmountOut = 0, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        let tx = new transactions_1.Transaction();
+        // Initialize oracle transaction
+        const pythFeederKeys = Object.keys(this.consts.pythFeeder.feeder);
+        if (sponsoredTx) {
+            const suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb(pythFeederKeys, tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb(pythFeederKeys, tx);
+        }
+        const slpCoinObject = this.processCoins(tx, 'slp', lpCoinObjects, false);
+        const [withdrawObject] = tx.splitCoins(slpCoinObject, [tx.pure.u64(amount)]);
+        const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::withdraw`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[coin].module,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.rebaseFeeModel),
+                withdrawObject,
+                tx.pure.u64(minAmountOut),
+                vaultsValuation,
+                symbolsValuation,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Withdraws LP coin object from SLP Vault
+     */
+    async withdrawLpCoinObject(coin, lpCoinObject, minAmountOut = 0, tx) {
+        if (!tx) {
+            tx = new transactions_1.Transaction();
+        }
+        // Initialize oracle transaction
+        const pythFeederKeys = Object.keys(this.consts.pythFeeder.feeder);
+        tx = await this.initOracleTxb(pythFeederKeys, tx);
+        const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::withdraw`,
+            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),
+                lpCoinObject,
+                tx.pure.u64(minAmountOut),
+                vaultsValuation,
+                symbolsValuation,
+            ],
+        });
+        return tx;
+    }
+    async withdrawPtb(coin, lpCoinObjects, amount, minAmountOut = 0, tx, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        if (!tx) {
+            tx = new transactions_1.Transaction();
+        }
+        // Initialize oracle transaction
+        const pythFeederKeys = Object.keys(this.consts.pythFeeder.feeder);
+        if (sponsoredTx) {
+            const suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb(pythFeederKeys, tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb(pythFeederKeys, tx);
+        }
+        const slpCoinObject = this.processCoins(tx, 'slp', lpCoinObjects, false);
+        const [withdrawObject] = tx.splitCoins(slpCoinObject, [tx.pure.u64(amount)]);
+        const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+        const [withdrawCoin] = tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::withdraw_ptb`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[coin].module,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.rebaseFeeModel),
+                withdrawObject,
+                tx.pure.u64(minAmountOut),
+                vaultsValuation,
+                symbolsValuation,
+            ],
+        });
+        return withdrawCoin;
+    }
+    async swap(fromToken, toToken, fromAmount, fromCoinObjects, minAmountOut) {
+        const tx = await this.initOracleTxb(Object.keys(this.consts.sudoCore.vaults));
+        const fromCoinObject = this.processCoins(tx, fromToken, fromCoinObjects);
+        const [fromDepositObject] = tx.splitCoins(fromCoinObject, [
+            tx.pure.u64(fromAmount),
+        ]);
+        const vaultsValuation = this.dataAPI.valuateVaults(tx);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::swap_v2`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                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,
+                tx.object(this.consts.pythFeeder.feeder[fromToken]),
+                tx.object(this.consts.pythFeeder.feeder[toToken]),
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Stakes SLP tokens in ZO staking pools
+     */
+    stake(lpCoinObjects, amount, pool, tx) {
+        if (!tx) {
+            tx = new transactions_1.Transaction();
+        }
+        const coinObject = this.processCoins(tx, 'slp', lpCoinObjects);
+        const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)]);
+        tx.moveCall({
+            target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::deposit`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                `${this.consts.sudoCore.package}::slp::SLP`,
+            ],
+            arguments: [
+                tx.object(pool),
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                depositObject,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Stakes SLP tokens using coin object only (PTB)
+     */
+    stakeCoinObject(coinObject, pool, tx) {
+        if (!tx) {
+            tx = new transactions_1.Transaction();
+        }
+        tx.moveCall({
+            target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::deposit`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                `${this.consts.sudoCore.package}::slp::SLP`,
+            ],
+            arguments: [
+                tx.object(pool),
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                coinObject,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Unstakes SLP tokens from ZO staking pools
+     */
+    unstake(credentials, amount, pool, tx) {
+        let unstakeAmount = amount;
+        if (!tx) {
+            tx = new transactions_1.Transaction();
+        }
+        for (const credential of credentials) {
+            const withdrawAmount = (() => {
+                const min = (a, b) => a < b ? a : b;
+                return min(unstakeAmount, credential.amount);
+            })();
+            unstakeAmount -= withdrawAmount;
+            tx.moveCall({
+                target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::withdraw`,
+                typeArguments: [
+                    `${this.consts.sudoCore.package}::slp::SLP`,
+                    `${this.consts.sudoCore.package}::slp::SLP`,
+                ],
+                arguments: [
+                    tx.object(pool),
+                    tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    tx.object(credential.id),
+                    tx.pure.u64(withdrawAmount),
+                ],
+            });
+            if (credential.amount === BigInt(0)) {
+                tx.moveCall({
+                    target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::clear_empty_credential`,
+                    typeArguments: [
+                        `${this.consts.sudoCore.package}::slp::SLP`,
+                        `${this.consts.sudoCore.package}::slp::SLP`,
+                    ],
+                    arguments: [tx.object(credential.id)],
+                });
+            }
+        }
+        return tx;
+    }
+    /**
+     * Unstakes SLP tokens from ZO staking pools return Coins
+     */
+    unstakeToCoins(credentials, amount, pool, tx) {
+        let unstakeAmount = amount;
+        const withdrawnCoinObjects = [];
+        for (const credential of credentials) {
+            const withdrawAmount = (() => {
+                const min = (a, b) => a < b ? a : b;
+                return min(unstakeAmount, credential.amount);
+            })();
+            unstakeAmount -= withdrawAmount;
+            const [withdrawnCoin] = tx.moveCall({
+                target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::withdraw_ptb`,
+                typeArguments: [
+                    `${this.consts.sudoCore.package}::slp::SLP`,
+                    `${this.consts.sudoCore.package}::slp::SLP`,
+                ],
+                arguments: [
+                    tx.object(pool),
+                    tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    tx.object(credential.id),
+                    tx.pure.u64(withdrawAmount),
+                ],
+            });
+            withdrawnCoinObjects.push(withdrawnCoin);
+            if (credential.amount === BigInt(0)) {
+                tx.moveCall({
+                    target: `${this.sharedConfig.zoStaking.package}::pool::clear_empty_credential`,
+                    typeArguments: [
+                        `${this.consts.sudoCore.package}::slp::SLP`,
+                        `${this.consts.sudoCore.package}::slp::SLP`,
+                    ],
+                    arguments: [tx.object(credential.id)],
+                });
+            }
+        }
+        return withdrawnCoinObjects;
+    }
+    /**
+     * Withdraws SLP tokens from a staking pool credential (PTB)
+     * Returns the withdrawn coin object for use in programmable transaction blocks
+     */
+    withdrawFromVaultPtb(pool, credential, withdrawAmount, tx) {
+        const [withdrawnCoin] = tx.moveCall({
+            target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::withdraw_ptb`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                `${this.consts.sudoCore.package}::slp::SLP`,
+            ],
+            arguments: [
+                tx.object(pool),
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(credential),
+                tx.pure.u64(withdrawAmount),
+            ],
+        });
+        return withdrawnCoin;
+    }
+    /**
+     * Claims rewards from a staking pool credential (PTB)
+     * Returns the reward coin object for use in programmable transaction blocks
+     */
+    claimRewardsPtb(pool, credential, tx) {
+        const [rewardCoin] = tx.moveCall({
+            target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::claim_rewards_ptb`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                `${this.consts.sudoCore.package}::slp::SLP`,
+            ],
+            arguments: [
+                tx.object(pool),
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(credential),
+            ],
+        });
+        return rewardCoin;
+    }
+    /**
+     * Opens a position using Sudo SDK approach
+     */
+    async openPosition(collateralToken, indexToken, size, collateralAmount, coinObjects, long, reserveAmount, indexPrice, collateralPrice, isLimitOrder = false, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), referralAddress, sender, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        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);
+        let allowTrade = consts_1.ALLOW_TRADE_MUST_TRADE;
+        if (isLimitOrder) {
+            allowTrade = isIocOrder ? consts_1.ALLOW_TRADE_NO_TRADE : consts_1.ALLOW_TRADE_CAN_TRADE;
+        }
+        // Handle oracle initialization and coin processing
+        let suiCoinObject;
+        if (sponsoredTx) {
+            suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx);
+        }
+        // Process coin splitting
+        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_v2_1`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                depositObject,
+                feeObject,
+                tx.pure.u8(allowTrade),
+                tx.pure.u64(size),
+                tx.pure.u64(reserveAmount),
+                tx.pure.u256(adjustCollateralPrice),
+                tx.pure.u256(adjustPrice),
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Opens a position using Sudo SDK approach
+     */
+    async openPositionWithCoin(collateralToken, indexToken, size, coinObj, long, reserveAmount, indexPrice, collateralPrice, isLimitOrder = false, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), referralAddress, sender, tx, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        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);
+        let allowTrade = consts_1.ALLOW_TRADE_MUST_TRADE;
+        if (isLimitOrder) {
+            allowTrade = isIocOrder ? consts_1.ALLOW_TRADE_NO_TRADE : consts_1.ALLOW_TRADE_CAN_TRADE;
+        }
+        // Handle oracle initialization and coin processing
+        let suiCoinObject;
+        if (sponsoredTx) {
+            suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx);
+        }
+        // Process coin splitting
+        const [feeObject] = tx.splitCoins(coinObj, [tx.pure.u64(relayerFee)]);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_v2_1`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                coinObj,
+                feeObject,
+                tx.pure.u8(allowTrade),
+                tx.pure.u64(size),
+                tx.pure.u64(reserveAmount),
+                tx.pure.u256(adjustCollateralPrice),
+                tx.pure.u256(adjustPrice),
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Opens a new position in SLP (V2 - uses v3 contract)
+     */
+    async openPositionV2(collateralToken, indexToken, size, collateralAmount, coinObjects, long, reserveAmount, indexPrice, collateralPrice, isLimitOrder, isIocOrder, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), referralAddress, sender, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        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;
+        }
+        // Handle oracle initialization and coin processing
+        let suiCoinObject;
+        if (sponsoredTx) {
+            suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx);
+        }
+        // Process coin splitting
+        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`,
+            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(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                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;
+    }
+    /**
+     * Opens a new position with Coin in SLP (V2 - uses v3 contract)
+     */
+    async openPositionWithCoinV2(collateralToken, indexToken, size, coinObj, long, reserveAmount, indexPrice, collateralPrice, isLimitOrder, isIocOrder, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), referralAddress, sender, tx, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        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;
+        }
+        // Handle oracle initialization and coin processing
+        let suiCoinObject;
+        if (sponsoredTx) {
+            suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx);
+        }
+        // Process coin splitting
+        const [feeObject] = tx.splitCoins(coinObj, [tx.pure.u64(relayerFee)]);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_v3`,
+            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(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                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;
+    }
+    /**
+     * Decreases an existing position in SLP using Sudo SDK approach
+     */
+    async decreasePosition(pcpId, collateralToken, indexToken, amount, long, indexPrice, collateralPrice, isTriggerOrder = false, isTakeProfitOrder = true, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), coinObjects, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        if (!coinObjects) {
+            throw new Error(`${this.constructor.name}: coinObjects is required`);
+        }
+        let tx = new transactions_1.Transaction();
+        const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+        const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+        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;
+        }
+        let suiCoinObject;
+        if (sponsoredTx) {
+            suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx);
+        }
+        // Handle oracle initialization and coin processing
+        const [feeObject] = this.processCoinSplitting(tx, collateralToken, coinObjects, [tx.pure.u64(relayerFee)], sponsoredTx, suiCoinObject);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v2_1`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(pcpId),
+                tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                feeObject,
+                tx.pure.u8(allowTrade),
+                tx.pure.bool(isTakeProfitOrder),
+                tx.pure.u64(amount),
+                tx.pure.u256(adjustCollateralPrice),
+                tx.pure.u256(adjustPrice),
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Decreases an existing position in SLP (V2 - uses v3 contract)
+     */
+    async decreasePositionV2(pcpId, collateralToken, indexToken, amount, long, indexPrice, collateralPrice, isTriggerOrder = false, isTakeProfitOrder = true, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), coinObjects, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        if (!coinObjects) {
+            throw new Error(`${this.constructor.name}: coinObjects 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;
+        }
+        // Handle oracle initialization and coin processing
+        let suiCoinObject;
+        if (sponsoredTx) {
+            suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx);
+        }
+        // Process coin splitting
+        const [feeObject] = this.processCoinSplitting(tx, collateralToken, coinObjects, [tx.pure.u64(relayerFee)], sponsoredTx, suiCoinObject);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v3`,
+            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(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(pcpId),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                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 decreaseMultiPositions(positions, tx, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        if (!tx) {
+            tx = new transactions_1.Transaction();
+        }
+        // Handle oracle initialization and coin processing
+        let suiCoinObject;
+        if (sponsoredTx) {
+            suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb(positions.flatMap(position => [position.collateralToken, position.indexToken]), tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb(positions.flatMap(position => [position.collateralToken, position.indexToken]), tx);
+        }
+        for (const position of positions) {
+            const { pcpId, collateralToken, coinObjects = [], indexToken, amount, long, indexPrice, collateralPrice, isTriggerOrder = false, isTakeProfitOrder = true, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), } = position;
+            let innerIsTakeProfitOrder = isTakeProfitOrder;
+            const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+            const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage);
+            const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+            let allowTrade = consts_1.ALLOW_TRADE_MUST_TRADE;
+            if (isTriggerOrder) {
+                allowTrade = isIocOrder || !innerIsTakeProfitOrder ? consts_1.ALLOW_TRADE_NO_TRADE : consts_1.ALLOW_TRADE_CAN_TRADE;
+            }
+            else {
+                innerIsTakeProfitOrder = true;
+            }
+            // Process coin splitting
+            const [feeObject] = this.processCoinSplitting(tx, collateralToken, coinObjects, [tx.pure.u64(relayerFee)], sponsoredTx, suiCoinObject);
+            tx.moveCall({
+                target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v2_1`,
+                typeArguments: [
+                    `${this.consts.sudoCore.package}::slp::SLP`,
+                    this.consts.coins[collateralToken].module,
+                    this.consts.coins[indexToken].module,
+                    `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                    this.consts.coins[collateralToken].module,
+                ],
+                arguments: [
+                    tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    tx.object(this.consts.sudoCore.market),
+                    tx.object(pcpId),
+                    tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                    tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                    tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                    tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                    feeObject,
+                    tx.pure.u8(allowTrade),
+                    tx.pure.bool(innerIsTakeProfitOrder),
+                    tx.pure.u64(amount),
+                    tx.pure.u256(adjustCollateralPrice),
+                    tx.pure.u256(adjustPrice),
+                ],
+            });
+        }
+        return tx;
+    }
+    async decreaseMultiPositionsV2(positions, tx, sponsoredTx, suiCoinObjectsForPythUpdate, feeObjects) {
+        const transaction = tx ?? new transactions_1.Transaction();
+        // Handle oracle initialization and coin processing
+        const tokens = positions.flatMap(position => [position.collateralToken, position.indexToken]);
+        const suiCoinObject = sponsoredTx
+            ? this.processCoins(transaction, 'sui', suiCoinObjectsForPythUpdate || [], true)
+            : undefined;
+        await this.initOracleTxb(tokens, transaction, !!sponsoredTx, suiCoinObject);
+        if (!feeObjects || feeObjects.length !== positions.length) {
+            throw new Error('feeObjects must be provided (pre-processed via buildFeeCoinObjects) and match positions length');
+        }
+        for (const [i, position] of positions.entries()) {
+            const feeObject = feeObjects[i];
+            const { pcpId, collateralToken, indexToken, amount, long, indexPrice, collateralPrice, isTriggerOrder = false, isTakeProfitOrder = true, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, } = position;
+            let innerIsTakeProfitOrder = isTakeProfitOrder;
+            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 || !innerIsTakeProfitOrder ? consts_1.ALLOW_TRADE_NO_TRADE : consts_1.ALLOW_TRADE_CAN_TRADE;
+            }
+            else {
+                innerIsTakeProfitOrder = true;
+            }
+            transaction.moveCall({
+                target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v3`,
+                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: [
+                    transaction.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    transaction.object(this.consts.sudoCore.market),
+                    transaction.object(pcpId),
+                    transaction.object(this.consts.pythFeeder.feeder[collateralToken]),
+                    transaction.object(this.consts.pythFeeder.feeder[indexToken]),
+                    feeObject,
+                    transaction.pure.u8(allowTrade),
+                    transaction.pure.bool(innerIsTakeProfitOrder),
+                    transaction.pure.u64(amount),
+                    transaction.pure.u256(adjustCollateralPrice),
+                    transaction.pure.u256(adjustPrice),
+                    transaction.pure.u256(indexPriceThreshold),
+                ],
+            });
+        }
+        return transaction;
+    }
+    async pledgeInPosition(pcpId, collateralToken, indexToken, amount, coinObjects, long, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        let tx = new transactions_1.Transaction();
+        // Handle oracle initialization and coin processing
+        let suiCoinObject;
+        if (sponsoredTx) {
+            suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx);
+        }
+        // Process coin splitting
+        const [depositObject] = this.processCoinSplitting(tx, collateralToken, coinObjects, [tx.pure.u64(amount)], sponsoredTx, suiCoinObject);
+        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'}`,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.market),
+                tx.object(pcpId),
+                depositObject,
+            ],
+        });
+        return tx;
+    }
+    async redeemFromPosition(pcpId, collateralToken, indexToken, amount, long, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        let tx = new transactions_1.Transaction();
+        // Handle oracle initialization and coin processing
+        let suiCoinObject;
+        if (sponsoredTx) {
+            suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx);
+        }
+        const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::redeem_from_position_v1_1`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(pcpId),
+                tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                tx.pure.u64(amount),
+            ],
+        });
+        return tx;
+    }
+    cancelOrder(orderCapId, collateralToken, indexToken, long, type, isV11Order) {
+        const tx = new transactions_1.Transaction();
+        let functionName = '';
+        switch (type) {
+            case 'OPEN_POSITION': {
+                functionName = 'clear_open_position_order_unified';
+                break;
+            }
+            case 'OPEN_MARKET': {
+                functionName = 'clear_open_market_order';
+                break;
+            }
+            case 'DECREASE_POSITION': {
+                functionName = 'clear_decrease_position_order_unified';
+                break;
+            }
+            case 'DECREASE_MARKET': {
+                functionName = 'clear_decrease_market_order';
+                break;
+            }
+            default: {
+                throw new Error('invalid order type');
+            }
+        }
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::${functionName}`,
+            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'}`,
+                isV11Order ? this.consts.coins.sui.module : this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.market),
+                tx.object(orderCapId),
+            ],
+        });
+        return tx;
+    }
+    cancelMultiOrders(orders, tx) {
+        if (!tx) {
+            tx = new transactions_1.Transaction();
+        }
+        for (const order of orders) {
+            const { orderCapId, collateralToken, indexToken, long, type } = order;
+            let functionName = '';
+            switch (type) {
+                case 'OPEN_POSITION': {
+                    functionName = 'clear_open_position_order_unified';
+                    break;
+                }
+                case 'OPEN_MARKET': {
+                    functionName = 'clear_open_market_order';
+                    break;
+                }
+                case 'DECREASE_POSITION': {
+                    functionName = 'clear_decrease_position_order_unified';
+                    break;
+                }
+                case 'DECREASE_MARKET': {
+                    functionName = 'clear_decrease_market_order';
+                    break;
+                }
+                default: {
+                    throw new Error('invalid order type');
+                }
+            }
+            tx.moveCall({
+                target: `${this.consts.sudoCore.upgradedPackage}::market::${functionName}`,
+                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)],
+            });
+        }
+        return tx;
+    }
+    clearClosedPosition(pcpId, collateralToken, indexToken, long, tx) {
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::clear_closed_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'}`,
+            ],
+            arguments: [tx.object(this.consts.sudoCore.market), tx.object(pcpId)],
+        });
+    }
+    clearOpenPositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order = true) {
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::clear_open_position_order_unified`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                isV11Order ? this.consts.coins.sui.module : this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.market),
+                tx.object(orderCapId),
+            ],
+        });
+    }
+    clearDecreasePositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order = true) {
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::clear_decrease_position_order_unified`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                isV11Order ? this.consts.coins.sui.module : this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.market),
+                tx.object(orderCapId),
+            ],
+        });
+    }
+    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)],
+        });
+    }
+    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)],
+        });
+    }
+    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, suiCoinObjectsForPythUpdate) {
+        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 || 0.003);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage || 0.5);
+        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,
+        });
+        // Handle oracle initialization and coin processing
+        let suiCoinObject;
+        if (sponsoredTx) {
+            suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx);
+        }
+        // Process coin splitting
+        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_v1`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                depositObject,
+                feeObject,
+                tx.pure.u8(allowTrade),
+                tx.pure.u64(size),
+                tx.pure.u64(reserveAmount),
+                tx.pure.u256(adjustCollateralPrice),
+                tx.pure.u256(adjustPrice),
+                sudoCard,
+            ],
+        });
+        kioskTx
+            .return({
+            itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+            item: sudoCard,
+            promise,
+        })
+            .finalize();
+        return tx;
+    }
+    async openPositionWithCoinAndSCard(collateralToken, indexToken, size, coinObj, long, reserveAmount, indexPrice, collateralPrice, kioskClient, kioskCap, scard, isLimitOrder = false, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), referralAddress, sender, tx, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        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 || 0.003);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage || 0.5);
+        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,
+        });
+        // Handle oracle initialization and coin processing
+        let suiCoinObject;
+        if (sponsoredTx) {
+            suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx);
+        }
+        // Process coin splitting
+        const [feeObject] = tx.splitCoins(coinObj, [tx.pure.u64(relayerFee)]);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_with_scard_v1`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                coinObj,
+                feeObject,
+                tx.pure.u8(allowTrade),
+                tx.pure.u64(size),
+                tx.pure.u64(reserveAmount),
+                tx.pure.u256(adjustCollateralPrice),
+                tx.pure.u256(adjustPrice),
+                sudoCard,
+            ],
+        });
+        kioskTx
+            .return({
+            itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+            item: sudoCard,
+            promise,
+        })
+            .finalize();
+        return tx;
+    }
+    async openPositionWithSCardV2(collateralToken, indexToken, size, collateralAmount, coinObjects, long, reserveAmount, indexPrice, collateralPrice, kioskClient, kioskCap, scard, isLimitOrder, isIocOrder, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), referralAddress, sender, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        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,
+        });
+        // Handle oracle initialization and coin processing
+        let suiCoinObject;
+        if (sponsoredTx) {
+            suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx);
+        }
+        // Process coin splitting
+        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_v2`,
+            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(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                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;
+    }
+    // S Card operations
+    async openPositionWithCoinAndSCardV2(collateralToken, indexToken, size, coinObj, long, reserveAmount, indexPrice, collateralPrice, kioskClient, kioskCap, scard, isLimitOrder, isIocOrder, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), referralAddress, sender, tx, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        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,
+        });
+        // Handle oracle initialization and coin processing
+        let suiCoinObject;
+        if (sponsoredTx) {
+            suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx);
+        }
+        // Process coin splitting
+        const [feeObject] = tx.splitCoins(coinObj, [tx.pure.u64(relayerFee)]);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_with_scard_v2`,
+            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(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                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 decreasePositionWithSCard(pcpId, collateralToken, indexToken, amount, long, indexPrice, collateralPrice, kioskClient, kioskCap, scard, isTriggerOrder = false, isTakeProfitOrder = true, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), coinObjects, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        if (!coinObjects) {
+            throw new Error(`${this.constructor.name}: coinObjects is required`);
+        }
+        let tx = new transactions_1.Transaction();
+        const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+        const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+        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,
+        });
+        // Handle oracle initialization and coin processing
+        let suiCoinObject;
+        if (sponsoredTx) {
+            suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx);
+        }
+        // Process coin splitting
+        const [feeObject] = this.processCoinSplitting(tx, collateralToken, coinObjects, [tx.pure.u64(relayerFee)], sponsoredTx, suiCoinObject);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_with_scard_v1`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(pcpId),
+                tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                feeObject,
+                tx.pure.u8(allowTrade),
+                tx.pure.bool(isTakeProfitOrder),
+                tx.pure.u64(amount),
+                tx.pure.u256(adjustCollateralPrice),
+                tx.pure.u256(adjustPrice),
+                sudoCard,
+            ],
+        });
+        kioskTx
+            .return({
+            itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+            item: sudoCard,
+            promise,
+        })
+            .finalize();
+        return tx;
+    }
+    async decreasePositionWithSCardV2(pcpId, collateralToken, indexToken, amount, long, indexPrice, collateralPrice, kioskClient, kioskCap, scard, isTriggerOrder = false, isTakeProfitOrder = true, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), coinObjects, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        if (!coinObjects) {
+            throw new Error(`${this.constructor.name}: coinObjects is required`);
+        }
+        let tx = new transactions_1.Transaction();
+        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 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;
+        }
+        // Handle oracle initialization and coin processing
+        let suiCoinObject;
+        if (sponsoredTx) {
+            suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb([collateralToken, indexToken], tx);
+        }
+        // Process coin splitting
+        const [feeObject] = this.processCoinSplitting(tx, collateralToken, coinObjects, [tx.pure.u64(relayerFee)], sponsoredTx, suiCoinObject);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_with_scard_v2`,
+            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(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(pcpId),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                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 decreaseMultiPositionsWithSCard(positions, kioskClient, kioskCap, scard, tx, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        if (!tx) {
+            tx = new transactions_1.Transaction();
+        }
+        // Handle oracle initialization and coin processing
+        let suiCoinObject;
+        if (sponsoredTx) {
+            suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb(positions.flatMap(position => [position.collateralToken, position.indexToken]), tx, true, suiCoinObject);
+        }
+        else {
+            tx = await this.initOracleTxb(positions.flatMap(position => [position.collateralToken, position.indexToken]), tx);
+        }
+        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,
+        });
+        for (const position of positions) {
+            const { pcpId, collateralToken, indexToken, amount, long, indexPrice, collateralPrice, isTriggerOrder = false, isTakeProfitOrder = true, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), coinObjects = [], } = position;
+            let innerIsTakeProfitOrder = isTakeProfitOrder;
+            const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+            const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage);
+            const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+            let allowTrade = consts_1.ALLOW_TRADE_MUST_TRADE;
+            if (isTriggerOrder) {
+                allowTrade = isIocOrder || !innerIsTakeProfitOrder ? consts_1.ALLOW_TRADE_NO_TRADE : consts_1.ALLOW_TRADE_CAN_TRADE;
+            }
+            else {
+                innerIsTakeProfitOrder = true;
+            }
+            // Process coin splitting
+            const [feeObject] = this.processCoinSplitting(tx, collateralToken, coinObjects, [tx.pure.u64(relayerFee)], sponsoredTx, suiCoinObject);
+            tx.moveCall({
+                target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_with_scard_v1`,
+                typeArguments: [
+                    `${this.consts.sudoCore.package}::slp::SLP`,
+                    this.consts.coins[collateralToken].module,
+                    this.consts.coins[indexToken].module,
+                    `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                    this.consts.coins[collateralToken].module,
+                ],
+                arguments: [
+                    tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    tx.object(this.consts.sudoCore.market),
+                    tx.object(pcpId),
+                    tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                    tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                    tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                    tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                    feeObject,
+                    tx.pure.u8(allowTrade),
+                    tx.pure.bool(isTakeProfitOrder),
+                    tx.pure.u64(amount),
+                    tx.pure.u256(adjustCollateralPrice),
+                    tx.pure.u256(adjustPrice),
+                    sudoCard,
+                ],
+            });
+        }
+        kioskTx
+            .return({
+            itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+            item: sudoCard,
+            promise,
+        })
+            .finalize();
+        return tx;
+    }
+    async decreaseMultiPositionsWithSCardV2(positions, kioskClient, kioskCap, scard, tx, sponsoredTx, suiCoinObjectsForPythUpdate, feeObjects) {
+        const transaction = tx ?? new transactions_1.Transaction();
+        // Handle oracle initialization and coin processing
+        const tokens = positions.flatMap(position => [position.collateralToken, position.indexToken]);
+        const suiCoinObject = sponsoredTx
+            ? this.processCoins(transaction, 'sui', suiCoinObjectsForPythUpdate || [], true)
+            : undefined;
+        await this.initOracleTxb(tokens, transaction, !!sponsoredTx, suiCoinObject);
+        if (!feeObjects || feeObjects.length !== positions.length) {
+            throw new Error('feeObjects must be provided (pre-processed via buildFeeCoinObjects) and match positions length');
+        }
+        const kioskTx = new kiosk_1.KioskTransaction({
+            transaction,
+            kioskClient,
+            cap: kioskCap,
+        });
+        const [sudoCard, promise] = kioskTx.borrow({
+            itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+            itemId: scard,
+        });
+        for (const [i, position] of positions.entries()) {
+            const feeObject = feeObjects[i];
+            const { pcpId, collateralToken, indexToken, amount, long, indexPrice, collateralPrice, isTriggerOrder = false, isTakeProfitOrder = true, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, } = position;
+            let innerIsTakeProfitOrder = isTakeProfitOrder;
+            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 || !innerIsTakeProfitOrder ? consts_1.ALLOW_TRADE_NO_TRADE : consts_1.ALLOW_TRADE_CAN_TRADE;
+            }
+            else {
+                innerIsTakeProfitOrder = true;
+            }
+            transaction.moveCall({
+                target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_with_scard_v2`,
+                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: [
+                    transaction.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    transaction.object(this.consts.sudoCore.market),
+                    transaction.object(pcpId),
+                    transaction.object(this.consts.pythFeeder.feeder[collateralToken]),
+                    transaction.object(this.consts.pythFeeder.feeder[indexToken]),
+                    feeObject,
+                    transaction.pure.u8(allowTrade),
+                    transaction.pure.bool(innerIsTakeProfitOrder),
+                    transaction.pure.u64(amount),
+                    transaction.pure.u256(adjustCollateralPrice),
+                    transaction.pure.u256(adjustPrice),
+                    transaction.pure.u256(indexPriceThreshold),
+                    sudoCard,
+                ],
+            });
+        }
+        kioskTx
+            .return({
+            itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+            item: sudoCard,
+            promise,
+        })
+            .finalize();
+        return transaction;
+    }
+    addReferral(referrer, tx) {
+        if (!tx) {
+            tx = new transactions_1.Transaction();
+        }
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::add_new_referral`,
+            typeArguments: [`${this.consts.sudoCore.package}::slp::SLP`],
+            arguments: [tx.object(this.consts.sudoCore.market), tx.pure.address(referrer)],
+        });
+        return tx;
+    }
+    async adminUpdatePriceFeed(collateralToken, indexToken) {
+        const tx = await this.initOracleTxb([collateralToken, indexToken]);
+        return tx;
+    }
+    adminSettlePosition(_positionId, _owner, _collateralToken, _indexToken, _long) {
+        // SLP does not support this operation
+        throw new Error(`Method not implemented for ${this.constructor.name}`);
+    }
+    adminDecreasePosition(positionId, owner, collateralToken, indexToken, positionAmount, amount, long, collateralPrice, collateralSlippage, relayerFee) {
+        const tx = new transactions_1.Transaction();
+        const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+        const feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee || BigInt(1))]);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice || 0, false, collateralSlippage || 0.5);
+        const allowTrade = consts_1.ALLOW_TRADE_MUST_TRADE;
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::admin_decrease_position_v1_3`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins.sui.module,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.adminCap),
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(positionId),
+                tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                feeObject,
+                tx.pure.u8(allowTrade),
+                tx.pure.u64(amount),
+                tx.pure.u256(adjustCollateralPrice),
+                tx.object(owner),
+            ],
+        });
+        if (amount === BigInt(positionAmount)) {
+            this.adminClearClosedPosition(positionId, owner, collateralToken, indexToken, long, tx);
+        }
+        return tx;
+    }
+    adminClearClosedPosition(positionId, owner, collateralToken, indexToken, long, tx) {
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::admin_clear_closed_position_v1_1`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.adminCap),
+                tx.object(owner),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(positionId),
+            ],
+        });
+    }
+    // SLP Specific APIs
+    claimTokenFromSCard(token, coinObjects, kioskClient, kioskCap, scard) {
+        const tx = new transactions_1.Transaction();
+        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,
+        });
+        // claim tokens
+        coinObjects.forEach((coinObject) => {
+            return tx.moveCall({
+                target: `${this.consts.sudoNft.upgradedPackage}::card::claim_token`,
+                typeArguments: [`${this.consts.coins[token].module}`],
+                arguments: [sudoCard, tx.object(coinObject)],
+            });
+        });
+        kioskTx
+            .return({
+            itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+            item: sudoCard,
+            promise,
+        })
+            .finalize();
+        return tx;
+    }
+}
+exports.SLPAPI = SLPAPI;
+//# sourceMappingURL=SLPAPI.cjs.map