@zofai/zo-sdk 0.1.92

package/dist/implementations/ZLPAPI.mjs

@@ -0,0 +1,1944 @@
+/**
+ * ZLP API implementation
+ * Implements ZLP-specific trading and transaction methods
+ */
+import { KioskTransaction } from "@mysten/kiosk";
+import { Transaction } from "@mysten/sui/transactions";
+import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
+import { BaseAPI } from "../abstract/index.mjs";
+import { ALLOW_TRADE_CAN_TRADE, ALLOW_TRADE_MUST_TRADE, ALLOW_TRADE_NO_TRADE, LPToken } from "../consts/index.mjs";
+import { joinSymbol } from "../utils.mjs";
+import { ZLPDataAPI } from "./ZLPDataAPI.mjs";
+export class ZLPAPI extends BaseAPI {
+    constructor(network, provider, apiEndpoint, connectionURL) {
+        super(network, provider, apiEndpoint, connectionURL, LPToken.ZLP);
+        this.dataAPI = new ZLPDataAPI(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 ZLP vault
+     */
+    async deposit(coin, coinObjects, amount, minAmountOut = 0, referralAddress, sender, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        let tx = new Transaction();
+        // Add referral if needed
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        // Initialize oracle transaction
+        const pythFeederKeys = Object.keys(this.consts.pythFeeder.feeder);
+        // Handle sponsored transaction case
+        if (sponsoredTx) {
+            const 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.zoCore.upgradedPackage}::market::deposit`,
+                typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`, this.consts.coins[coin].module],
+                arguments: [
+                    tx.object(this.consts.zoCore.market),
+                    tx.object(this.consts.zoCore.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.zoCore.upgradedPackage}::market::deposit`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[coin].module,
+            ],
+            arguments: [
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.rebaseFeeModel),
+                depositObject,
+                tx.pure.u64(minAmountOut),
+                vaultsValuation,
+                symbolsValuation,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Deposits collateral into ZLP vault and returns a coin
+     */
+    async depositPtb(coin, coinObjects, amount, minAmountOut = 0, referralAddress, sender, tx, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        if (!tx) {
+            tx = new Transaction();
+        }
+        // Add referral if needed
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        // Initialize oracle transaction
+        const pythFeederKeys = Object.keys(this.consts.pythFeeder.feeder);
+        // Handle sponsored transaction case
+        if (sponsoredTx) {
+            const 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.zoCore.upgradedPackage}::market::deposit_ptb`,
+                typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`, this.consts.coins[coin].module],
+                arguments: [
+                    tx.object(this.consts.zoCore.market),
+                    tx.object(this.consts.zoCore.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.zoCore.upgradedPackage}::market::deposit_ptb`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[coin].module,
+            ],
+            arguments: [
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.rebaseFeeModel),
+                depositObject,
+                tx.pure.u64(minAmountOut),
+                vaultsValuation,
+                symbolsValuation,
+            ],
+        });
+        return mintedCoin;
+    }
+    async depositWithPtb(coin, depositObject, minAmountOut = 0, referralAddress, sender, tx, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        if (!tx) {
+            tx = new Transaction();
+        }
+        // Add referral if needed
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        // Initialize oracle transaction
+        const pythFeederKeys = Object.keys(this.consts.pythFeeder.feeder);
+        // Handle sponsored transaction case
+        if (sponsoredTx) {
+            const 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.zoCore.upgradedPackage}::market::deposit`,
+                typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`, this.consts.coins[coin].module],
+                arguments: [
+                    tx.object(this.consts.zoCore.market),
+                    tx.object(this.consts.zoCore.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.zoCore.upgradedPackage}::market::deposit`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[coin].module,
+            ],
+            arguments: [
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.rebaseFeeModel),
+                depositObject,
+                tx.pure.u64(minAmountOut),
+                vaultsValuation,
+                symbolsValuation,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Withdraws collateral from ZLP vault
+     */
+    async withdraw(coin, lpCoinObjects, amount, minAmountOut = 0, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        let tx = new 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 zlpCoinObject = this.processCoins(tx, 'zlp', lpCoinObjects, false);
+        const [withdrawObject] = tx.splitCoins(zlpCoinObject, [tx.pure.u64(amount)]);
+        const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+        tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::withdraw`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[coin].module,
+            ],
+            arguments: [
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.rebaseFeeModel),
+                withdrawObject,
+                tx.pure.u64(minAmountOut),
+                vaultsValuation,
+                symbolsValuation,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Withdraws LP coin object from ZLP vault
+     */
+    async withdrawLpCoinObject(coin, lpCoinObject, minAmountOut = 0, tx) {
+        if (!tx) {
+            tx = new 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.zoCore.upgradedPackage}::market::withdraw`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[coin].module,
+            ],
+            arguments: [
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.rebaseFeeModel),
+                lpCoinObject,
+                tx.pure.u64(minAmountOut),
+                vaultsValuation,
+                symbolsValuation,
+            ],
+        });
+        return tx;
+    }
+    async withdrawPtb(coin, lpCoinObjects, amount, minAmountOut = 0, tx, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        if (!tx) {
+            tx = new 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 zlpCoinObject = this.processCoins(tx, 'zlp', lpCoinObjects, false);
+        const [withdrawObject] = tx.splitCoins(zlpCoinObject, [tx.pure.u64(amount)]);
+        const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+        const [withdrawCoin] = tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::withdraw_ptb`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[coin].module,
+            ],
+            arguments: [
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.rebaseFeeModel),
+                withdrawObject,
+                tx.pure.u64(minAmountOut),
+                vaultsValuation,
+                symbolsValuation,
+            ],
+        });
+        return withdrawCoin;
+    }
+    /**
+     * Stakes ZLP tokens in ZO staking pools
+     */
+    stake(lpCoinObjects, amount, pool, tx) {
+        if (!tx) {
+            tx = new Transaction();
+        }
+        const coinObject = this.processCoins(tx, 'zlp', lpCoinObjects);
+        const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)]);
+        tx.moveCall({
+            target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::deposit`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                `${this.consts.coins.sui.module}`,
+            ],
+            arguments: [
+                tx.object(pool),
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                depositObject,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Stakes ZLP tokens using coin object only (PTB)
+     */
+    stakeCoinObject(coinObject, pool, tx) {
+        if (!tx) {
+            tx = new Transaction();
+        }
+        tx.moveCall({
+            target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::deposit`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                `${this.consts.coins.sui.module}`,
+            ],
+            arguments: [
+                tx.object(pool),
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                coinObject,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Unstakes ZLP tokens from ZO staking pools
+     */
+    unstake(credentials, amount, pool, tx) {
+        let unstakeAmount = amount;
+        if (!tx) {
+            tx = new 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.zoCore.package}::zlp::ZLP`,
+                    `${this.consts.coins.sui.module}`,
+                ],
+                arguments: [
+                    tx.object(pool),
+                    tx.object(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.zoCore.package}::zlp::ZLP`,
+                        `${this.consts.coins.sui.module}`,
+                    ],
+                    arguments: [tx.object(credential.id)],
+                });
+            }
+        }
+        return tx;
+    }
+    /**
+     * Unstakes ZLP tokens from ZO staking pools and 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.zoCore.package}::zlp::ZLP`,
+                    `${this.consts.coins.sui.module}`,
+                ],
+                arguments: [
+                    tx.object(pool),
+                    tx.object(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.upgradedPackage}::pool::clear_empty_credential`,
+                    typeArguments: [
+                        `${this.consts.zoCore.package}::zlp::ZLP`,
+                        `${this.consts.coins.sui.module}`,
+                    ],
+                    arguments: [tx.object(credential.id)],
+                });
+            }
+        }
+        return withdrawnCoinObjects;
+    }
+    /**
+     * Withdraws ZLP 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.zoCore.package}::zlp::ZLP`,
+                `${this.consts.coins.sui.module}`,
+            ],
+            arguments: [
+                tx.object(pool),
+                tx.object(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.zoCore.package}::zlp::ZLP`,
+                `${this.consts.coins.sui.module}`,
+            ],
+            arguments: [
+                tx.object(pool),
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(credential),
+            ],
+        });
+        return rewardCoin;
+    }
+    async swap(fromToken, toToken, fromAmount, fromCoinObjects, minAmountOut) {
+        const tx = await this.initOracleTxb(Object.keys(this.consts.zoCore.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.zoCore.upgradedPackage}::market::swap_v2`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[fromToken].module,
+                this.consts.coins[toToken].module,
+            ],
+            arguments: [
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.rebaseFeeModel),
+                fromDepositObject,
+                tx.pure.u64(minAmountOut || 0),
+                vaultsValuation,
+                tx.object(this.consts.pythFeeder.feeder[fromToken]),
+                tx.object(this.consts.pythFeeder.feeder[toToken]),
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Opens a new position in ZLP
+     */
+    async openPosition(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 Transaction();
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+        const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+        let allowTrade = ALLOW_TRADE_MUST_TRADE;
+        if (isLimitOrder) {
+            allowTrade = isIocOrder ? ALLOW_TRADE_NO_TRADE : 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.zoCore.upgradedPackage}::market::open_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.zoCore.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 new position in ZLP
+     */
+    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 Transaction();
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+        const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+        const indexPriceThreshold = this.processPriceThreshold(indexPrice, pricesSlippage);
+        let allowTrade = ALLOW_TRADE_MUST_TRADE;
+        if (isLimitOrder) {
+            allowTrade = isIocOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE;
+        }
+        // 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.zoCore.upgradedPackage}::market::open_position_v2`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.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 ZLP
+     */
+    async openPositionWithCoin(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 Transaction();
+        }
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+        const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+        let allowTrade = ALLOW_TRADE_MUST_TRADE;
+        if (isLimitOrder) {
+            allowTrade = isIocOrder ? ALLOW_TRADE_NO_TRADE : 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.zoCore.upgradedPackage}::market::open_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.zoCore.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 with Coin in ZLP (V2)
+     */
+    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 Transaction();
+        }
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+        const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+        const indexPriceThreshold = this.processPriceThreshold(indexPrice, pricesSlippage);
+        let allowTrade = ALLOW_TRADE_MUST_TRADE;
+        if (isLimitOrder) {
+            allowTrade = isIocOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE;
+        }
+        // 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.zoCore.upgradedPackage}::market::open_position_v2`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.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 ZLP
+     */
+    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 Transaction();
+        const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+        const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+        let allowTrade = ALLOW_TRADE_MUST_TRADE;
+        if (isTriggerOrder) {
+            allowTrade = isIocOrder || !isTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : 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.zoCore.upgradedPackage}::market::decrease_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(pcpId),
+                tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.zoCore.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 ZLP
+     */
+    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 Transaction();
+        const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+        const indexPriceThreshold = this.processPriceThreshold(indexPrice, pricesSlippage);
+        let allowTrade = ALLOW_TRADE_MUST_TRADE;
+        if (isTriggerOrder) {
+            allowTrade = isIocOrder || !isTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE;
+        }
+        else {
+            isTakeProfitOrder = true;
+        }
+        // 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.zoCore.upgradedPackage}::market::decrease_position_v2`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.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 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 = joinSymbol(long ? 'long' : 'short', indexToken);
+            const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage);
+            const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+            let allowTrade = ALLOW_TRADE_MUST_TRADE;
+            if (isTriggerOrder) {
+                allowTrade = isIocOrder || !innerIsTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : 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.zoCore.upgradedPackage}::market::decrease_position`,
+                typeArguments: [
+                    `${this.consts.zoCore.package}::zlp::ZLP`,
+                    this.consts.coins[collateralToken].module,
+                    this.consts.coins[indexToken].module,
+                    `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                    this.consts.coins[collateralToken].module,
+                ],
+                arguments: [
+                    tx.object(SUI_CLOCK_OBJECT_ID),
+                    tx.object(this.consts.zoCore.market),
+                    tx.object(pcpId),
+                    tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                    tx.object(this.consts.zoCore.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 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 = ALLOW_TRADE_MUST_TRADE;
+            if (isTriggerOrder) {
+                allowTrade = isIocOrder || !innerIsTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE;
+            }
+            else {
+                innerIsTakeProfitOrder = true;
+            }
+            transaction.moveCall({
+                target: `${this.consts.zoCore.upgradedPackage}::market::decrease_position_v2`,
+                typeArguments: [
+                    `${this.consts.zoCore.package}::zlp::ZLP`,
+                    this.consts.coins[collateralToken].module,
+                    this.consts.coins[indexToken].module,
+                    `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                    this.consts.coins[collateralToken].module,
+                ],
+                arguments: [
+                    transaction.object(SUI_CLOCK_OBJECT_ID),
+                    transaction.object(this.consts.zoCore.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 openPositionWithSCard(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 Transaction();
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+        const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+        let allowTrade = ALLOW_TRADE_MUST_TRADE;
+        if (isLimitOrder) {
+            allowTrade = isIocOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE;
+        }
+        const kioskTx = new KioskTransaction({
+            transaction: tx,
+            kioskClient,
+            cap: kioskCap,
+        });
+        const [sudoCard, promise] = kioskTx.borrow({
+            itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::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.zoCore.upgradedPackage}::market::open_position_with_scard`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.zoCore.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: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::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 Transaction();
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+        const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+        const indexPriceThreshold = this.processPriceThreshold(indexPrice, pricesSlippage);
+        let allowTrade = ALLOW_TRADE_MUST_TRADE;
+        if (isLimitOrder) {
+            allowTrade = isIocOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE;
+        }
+        const kioskTx = new KioskTransaction({
+            transaction: tx,
+            kioskClient,
+            cap: kioskCap,
+        });
+        const [sudoCard, promise] = kioskTx.borrow({
+            itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::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.zoCore.upgradedPackage}::market::open_position_with_scard_v2`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.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: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+            item: sudoCard,
+            promise,
+        })
+            .finalize();
+        return tx;
+    }
+    async openPositionWithCoinAndSCard(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 Transaction();
+        }
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+        const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+        let allowTrade = ALLOW_TRADE_MUST_TRADE;
+        if (isLimitOrder) {
+            allowTrade = isIocOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE;
+        }
+        const kioskTx = new KioskTransaction({
+            transaction: tx,
+            kioskClient,
+            cap: kioskCap,
+        });
+        const [sudoCard, promise] = kioskTx.borrow({
+            itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::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.zoCore.upgradedPackage}::market::open_position_with_scard`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.zoCore.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: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+            item: sudoCard,
+            promise,
+        })
+            .finalize();
+        return tx;
+    }
+    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 Transaction();
+        }
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+        const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+        const indexPriceThreshold = this.processPriceThreshold(indexPrice, pricesSlippage);
+        let allowTrade = ALLOW_TRADE_MUST_TRADE;
+        if (isLimitOrder) {
+            allowTrade = isIocOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE;
+        }
+        const kioskTx = new KioskTransaction({
+            transaction: tx,
+            kioskClient,
+            cap: kioskCap,
+        });
+        const [sudoCard, promise] = kioskTx.borrow({
+            itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::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.zoCore.upgradedPackage}::market::open_position_with_scard_v2`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.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: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::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 Transaction();
+        const kioskTx = new KioskTransaction({
+            transaction: tx,
+            kioskClient,
+            cap: kioskCap,
+        });
+        const [sudoCard, promise] = kioskTx.borrow({
+            itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+            itemId: scard,
+        });
+        const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+        const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+        let allowTrade = ALLOW_TRADE_MUST_TRADE;
+        if (isTriggerOrder) {
+            allowTrade = isIocOrder || !isTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : 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.zoCore.upgradedPackage}::market::decrease_position_with_scard`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(pcpId),
+                tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.zoCore.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: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::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 Transaction();
+        const kioskTx = new KioskTransaction({
+            transaction: tx,
+            kioskClient,
+            cap: kioskCap,
+        });
+        const [sudoCard, promise] = kioskTx.borrow({
+            itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::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 = ALLOW_TRADE_MUST_TRADE;
+        if (isTriggerOrder) {
+            allowTrade = isIocOrder || !isTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : 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.zoCore.upgradedPackage}::market::decrease_position_with_scard_v2`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.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: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+            item: sudoCard,
+            promise,
+        })
+            .finalize();
+        return tx;
+    }
+    async decreaseMultiPositionsWithSCard(positions, kioskClient, kioskCap, scard, tx, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        if (!tx) {
+            tx = new 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 KioskTransaction({
+            transaction: tx,
+            kioskClient,
+            cap: kioskCap,
+        });
+        const [sudoCard, promise] = kioskTx.borrow({
+            itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::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 = joinSymbol(long ? 'long' : 'short', indexToken);
+            const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage);
+            const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+            let allowTrade = ALLOW_TRADE_MUST_TRADE;
+            if (isTriggerOrder) {
+                allowTrade = isIocOrder || !innerIsTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : 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.zoCore.upgradedPackage}::market::decrease_position_with_scard`,
+                typeArguments: [
+                    `${this.consts.zoCore.package}::zlp::ZLP`,
+                    this.consts.coins[collateralToken].module,
+                    this.consts.coins[indexToken].module,
+                    `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                    this.consts.coins[collateralToken].module,
+                ],
+                arguments: [
+                    tx.object(SUI_CLOCK_OBJECT_ID),
+                    tx.object(this.consts.zoCore.market),
+                    tx.object(pcpId),
+                    tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                    tx.object(this.consts.zoCore.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),
+                    sudoCard,
+                ],
+            });
+        }
+        kioskTx
+            .return({
+            itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+            item: sudoCard,
+            promise,
+        })
+            .finalize();
+        return tx;
+    }
+    async decreaseMultiPositionsWithSCardV2(positions, kioskClient, kioskCap, scard, tx, sponsoredTx, suiCoinObjectsForPythUpdate, feeObjects) {
+        const transaction = tx ?? new 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 KioskTransaction({
+            transaction,
+            kioskClient,
+            cap: kioskCap,
+        });
+        const [sudoCard, promise] = kioskTx.borrow({
+            itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::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 = ALLOW_TRADE_MUST_TRADE;
+            if (isTriggerOrder) {
+                allowTrade = isIocOrder || !innerIsTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE;
+            }
+            else {
+                innerIsTakeProfitOrder = true;
+            }
+            transaction.moveCall({
+                target: `${this.consts.zoCore.upgradedPackage}::market::decrease_position_with_scard_v2`,
+                typeArguments: [
+                    `${this.consts.zoCore.package}::zlp::ZLP`,
+                    this.consts.coins[collateralToken].module,
+                    this.consts.coins[indexToken].module,
+                    `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                    this.consts.coins[collateralToken].module,
+                ],
+                arguments: [
+                    transaction.object(SUI_CLOCK_OBJECT_ID),
+                    transaction.object(this.consts.zoCore.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: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+            item: sudoCard,
+            promise,
+        })
+            .finalize();
+        return transaction;
+    }
+    /**
+     * Pledges in position (ZLP-specific functionality)
+     */
+    async pledgeInPosition(pcpId, collateralToken, indexToken, amount, coinObjects, long, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        let tx = new 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.zoCore.upgradedPackage}::market::pledge_in_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [tx.object(this.consts.zoCore.market), tx.object(pcpId), depositObject],
+        });
+        return tx;
+    }
+    async redeemFromPosition(pcpId, collateralToken, indexToken, amount, long, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        let tx = new 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 = joinSymbol(long ? 'long' : 'short', indexToken);
+        tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::redeem_from_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(pcpId),
+                tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.zoCore.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 Transaction();
+        let functionName = '';
+        switch (type) {
+            case 'OPEN_POSITION': {
+                functionName = isV11Order ? 'clear_open_position_order' : 'clear_open_position_order';
+                break;
+            }
+            case 'OPEN_MARKET': {
+                functionName = 'clear_open_market_order';
+                break;
+            }
+            case 'DECREASE_POSITION': {
+                functionName = isV11Order
+                    ? 'clear_decrease_position_order'
+                    : 'clear_decrease_position_order';
+                break;
+            }
+            case 'DECREASE_MARKET': {
+                functionName = 'clear_decrease_market_order';
+                break;
+            }
+            default: {
+                throw new Error('invalid order type');
+            }
+        }
+        tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::${functionName}`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [tx.object(this.consts.zoCore.market), tx.object(orderCapId)],
+        });
+        return tx;
+    }
+    cancelMultiOrders(orders, tx) {
+        if (!tx) {
+            tx = new Transaction();
+        }
+        for (const order of orders) {
+            const { orderCapId, collateralToken, indexToken, long, type, isV11Order } = order;
+            let functionName = '';
+            switch (type) {
+                case 'OPEN_POSITION': {
+                    functionName = isV11Order ? 'clear_open_position_order' : 'clear_open_position_order';
+                    break;
+                }
+                case 'OPEN_MARKET': {
+                    functionName = 'clear_open_market_order';
+                    break;
+                }
+                case 'DECREASE_POSITION': {
+                    functionName = isV11Order
+                        ? 'clear_decrease_position_order'
+                        : 'clear_decrease_position_order';
+                    break;
+                }
+                case 'DECREASE_MARKET': {
+                    functionName = 'clear_decrease_market_order';
+                    break;
+                }
+                default: {
+                    throw new Error('invalid order type');
+                }
+            }
+            tx.moveCall({
+                target: `${this.consts.zoCore.upgradedPackage}::market::${functionName}`,
+                typeArguments: [
+                    `${this.consts.zoCore.package}::zlp::ZLP`,
+                    this.consts.coins[collateralToken].module,
+                    this.consts.coins[indexToken].module,
+                    `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                    this.consts.coins[collateralToken].module,
+                ],
+                arguments: [tx.object(this.consts.zoCore.market), tx.object(orderCapId)],
+            });
+        }
+        return tx;
+    }
+    clearClosedPosition(pcpId, collateralToken, indexToken, long, tx) {
+        tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::clear_closed_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [tx.object(this.consts.zoCore.market), tx.object(pcpId)],
+        });
+    }
+    clearOpenPositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order) {
+        const funcName = isV11Order ? 'clear_open_position_order' : 'clear_open_position_order';
+        tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::${funcName}`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [tx.object(this.consts.zoCore.market), tx.object(orderCapId)],
+        });
+    }
+    clearOpenMarketOrder(orderCapId, collateralToken, indexToken, long, tx, _isV11Order) {
+        const funcName = 'clear_open_market_order';
+        tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::${funcName}`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [tx.object(this.consts.zoCore.market), tx.object(orderCapId)],
+        });
+    }
+    clearDecreasePositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order) {
+        const funcName = isV11Order ? 'clear_decrease_position_order' : 'clear_decrease_position_order';
+        tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::${funcName}`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [tx.object(this.consts.zoCore.market), tx.object(orderCapId)],
+        });
+    }
+    clearDecreaseMarketOrder(orderCapId, collateralToken, indexToken, long, tx, _isV11Order) {
+        const funcName = 'clear_decrease_market_order';
+        tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::${funcName}`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [tx.object(this.consts.zoCore.market), tx.object(orderCapId)],
+        });
+    }
+    addReferral(referralAddress, tx) {
+        if (!tx) {
+            tx = new Transaction();
+        }
+        tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::add_new_referral`,
+            typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`],
+            arguments: [tx.object(this.consts.zoCore.market), tx.pure.address(referralAddress)],
+        });
+        return tx;
+    }
+    async adminUpdatePriceFeed(collateralToken, indexToken) {
+        const tx = await this.initOracleTxb([collateralToken, indexToken]);
+        return tx;
+    }
+    adminSettlePosition(positionId, owner, collateralToken, indexToken, long) {
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::force_settle_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [
+                tx.object(this.consts.zoCore.adminCap),
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(owner),
+                tx.object(positionId),
+            ],
+        });
+        this.adminClearClosedPosition(positionId, owner, collateralToken, indexToken, long, tx);
+        return tx;
+    }
+    adminDecreasePosition(positionId, owner, collateralToken, indexToken, positionAmount, amount, long) {
+        const tx = new Transaction();
+        const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+        tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::force_close_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [
+                tx.object(this.consts.zoCore.adminCap),
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                tx.object(owner),
+                tx.object(positionId),
+            ],
+        });
+        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.zoCore.upgradedPackage}::market::force_clear_closed_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [
+                tx.object(this.consts.zoCore.adminCap),
+                tx.object(this.consts.zoCore.market),
+                tx.object(positionId),
+                tx.object(owner),
+            ],
+        });
+    }
+    adminIssueLootbox(coin, tiers, beneficiaries, amounts, tx) {
+        let module = `${this.consts.zoCore.package}::zlp::ZLP`;
+        if (coin !== 'zlp') {
+            module = this.consts.coins[coin].module;
+        }
+        for (const [i, beneficiary] of beneficiaries.entries()) {
+            tx.moveCall({
+                target: `${this.sharedConfig.zoLootbox.package}::lootbox::admin_issue_lootbox`,
+                typeArguments: [module],
+                arguments: [
+                    tx.object(this.sharedConfig.zoLootbox.adminCap),
+                    tx.pure.u8(tiers[i]),
+                    tx.pure.address(beneficiary),
+                    tx.pure.u64(amounts[i]),
+                    tx.pure.bool(amounts[i] > 0),
+                    tx.object(`${this.sharedConfig.zoLootbox.lootboxSettings}`),
+                ],
+            });
+        }
+    }
+    depositToPrizePool(coin, coinObjects, amount) {
+        const tx = new Transaction();
+        const coinObject = this.processCoins(tx, coin, coinObjects);
+        const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)]);
+        let module = `${this.consts.zoCore.package}::zlp::ZLP`;
+        if (coin !== 'zlp') {
+            module = this.consts.coins[coin].module;
+        }
+        tx.moveCall({
+            target: `${this.sharedConfig.zoLootbox.package}::lootbox::deposit`,
+            typeArguments: [module],
+            arguments: [
+                tx.object(this.sharedConfig.zoLootbox.adminCap),
+                tx.object(this.sharedConfig.zoLootbox.lootboxTreasury),
+                depositObject,
+            ],
+        });
+        return tx;
+    }
+    withdrawFromPricePool(coin, amount) {
+        const tx = new Transaction();
+        let module = `${this.consts.zoCore.package}::zlp::ZLP`;
+        let metadata = this.consts.zoCore.zlpMetadata;
+        if (coin !== 'zlp') {
+            module = this.consts.coins[coin].module;
+            metadata = this.consts.coins[coin].metadata;
+        }
+        tx.moveCall({
+            target: `${this.sharedConfig.zoLootbox.package}::lootbox::withdraw`,
+            typeArguments: [module],
+            arguments: [
+                tx.object(this.sharedConfig.zoLootbox.adminCap),
+                tx.object(this.sharedConfig.zoLootbox.lootboxTreasury),
+                tx.object(metadata),
+                tx.pure.u64(amount),
+            ],
+        });
+        return tx;
+    }
+    openLootbox(coin, lootbox) {
+        const tx = new Transaction();
+        let module = `${this.consts.zoCore.package}::zlp::ZLP`;
+        let metadata = this.consts.zoCore.zlpMetadata;
+        if (coin !== 'zlp') {
+            module = this.consts.coins[coin].module;
+            metadata = this.consts.coins[coin].metadata;
+        }
+        tx.moveCall({
+            target: `${this.sharedConfig.zoLootbox.upgradedPackage}::lootbox::open_lootbox`,
+            typeArguments: [module],
+            arguments: [
+                tx.object(`${this.sharedConfig.zoLootbox.lootboxTreasury}`),
+                tx.object(lootbox),
+                tx.object(metadata),
+                tx.object(`${this.sharedConfig.zoLootbox.lootboxSettings}`),
+            ],
+        });
+        return tx;
+    }
+    // V2 Lootbox Methods for new contract
+    adminIssueLootboxV2(coin, tiers, beneficiaries, amounts, titles, descriptions, tx) {
+        let module = `${this.consts.zoCore.package}::zlp::ZLP`;
+        if (coin !== 'zlp') {
+            module = this.consts.coins[coin].module;
+        }
+        for (const [i, beneficiary] of beneficiaries.entries()) {
+            const moveCallArgs = {
+                target: `${this.sharedConfig.zoLootboxV2.upgradedPackage}::lootbox::admin_issue_lootbox`,
+                typeArguments: [module],
+                arguments: [
+                    tx.object(this.sharedConfig.zoLootboxV2.adminCap),
+                    tx.object(this.sharedConfig.zoLootboxV2.lootboxTreasury),
+                    tx.pure.u8(tiers[i]),
+                    tx.pure.address(beneficiary),
+                    tx.pure.u64(amounts[i]),
+                    tx.pure.bool(amounts[i] > 0),
+                    tx.pure.string(titles[i]),
+                    tx.pure.string(descriptions[i]),
+                    tx.object(`${this.sharedConfig.zoLootboxV2.lootboxSettings}`),
+                ],
+            };
+            tx.moveCall(moveCallArgs);
+        }
+    }
+    openLootboxV2(coin, lootbox) {
+        const tx = new Transaction();
+        let module = `${this.consts.zoCore.package}::zlp::ZLP`;
+        let metadata = this.consts.zoCore.zlpMetadata;
+        if (coin !== 'zlp') {
+            module = this.consts.coins[coin].module;
+            metadata = this.consts.coins[coin].metadata;
+        }
+        tx.moveCall({
+            target: `${this.sharedConfig.zoLootboxV2.upgradedPackage}::lootbox::open_lootbox`,
+            typeArguments: [module],
+            arguments: [
+                tx.object(this.sharedConfig.zoLootboxV2.lootboxTreasury),
+                tx.object(lootbox),
+                tx.object(metadata),
+                tx.object(this.sharedConfig.zoLootboxV2.lootboxSettings),
+            ],
+        });
+        return tx;
+    }
+    // Vesting Lootbox Methods (V2)
+    adminIssueVestingLootboxV2(_coin, beneficiaries, unlockedAmounts, lockedAmounts, lockDurationsMs, tx) {
+        const module = `${this.consts.zoCore.package}::zlp::ZLP`;
+        for (const [i, beneficiary] of beneficiaries.entries()) {
+            tx.moveCall({
+                target: `${this.sharedConfig.zoLootboxV2.upgradedPackage}::lootbox::admin_issue_vesting_lootbox_precision`,
+                typeArguments: [module],
+                arguments: [
+                    tx.object(this.sharedConfig.zoLootboxV2.adminCap),
+                    tx.object(this.sharedConfig.zoLootboxV2.lootboxTreasury),
+                    tx.object(SUI_CLOCK_OBJECT_ID),
+                    tx.pure.u64(unlockedAmounts[i]),
+                    tx.pure.u64(lockedAmounts[i]),
+                    tx.pure.u64(lockDurationsMs[i]),
+                    tx.pure.address(beneficiary),
+                ],
+            });
+        }
+    }
+    claimUnlockedV2(coin, vestingLootbox) {
+        const tx = new Transaction();
+        let module = `${this.consts.zoCore.package}::zlp::ZLP`;
+        if (coin !== 'zlp') {
+            module = this.consts.coins[coin].module;
+        }
+        tx.moveCall({
+            target: `${this.sharedConfig.zoLootboxV2.upgradedPackage}::lootbox::claim_unlocked`,
+            typeArguments: [module],
+            arguments: [
+                tx.object(this.sharedConfig.zoLootboxV2.lootboxTreasury),
+                tx.object(vestingLootbox),
+            ],
+        });
+        return tx;
+    }
+    claimVestedV2(coin, vestingLootbox) {
+        const tx = new Transaction();
+        let module = `${this.consts.zoCore.package}::zlp::ZLP`;
+        if (coin !== 'zlp') {
+            module = this.consts.coins[coin].module;
+        }
+        tx.moveCall({
+            target: `${this.sharedConfig.zoLootboxV2.upgradedPackage}::lootbox::claim_vested`,
+            typeArguments: [module],
+            arguments: [
+                tx.object(this.sharedConfig.zoLootboxV2.lootboxTreasury),
+                tx.object(vestingLootbox),
+                tx.object(SUI_CLOCK_OBJECT_ID),
+            ],
+        });
+        return tx;
+    }
+    destroyVestingLootboxV2(coin, vestingLootbox) {
+        const tx = new Transaction();
+        let module = `${this.consts.zoCore.package}::zlp::ZLP`;
+        if (coin !== 'zlp') {
+            module = this.consts.coins[coin].module;
+        }
+        tx.moveCall({
+            target: `${this.sharedConfig.zoLootboxV2.upgradedPackage}::lootbox::destroy_vesting_lootbox`,
+            typeArguments: [module],
+            arguments: [tx.object(vestingLootbox)],
+        });
+        return tx;
+    }
+}
+//# sourceMappingURL=ZLPAPI.mjs.map