zo-sdk 0.0.50 → 0.1.0

package/dist/implementations/SLPAPI.cjs

@@ -0,0 +1,829 @@
+"use strict";
+/**
+ * SLP API implementation
+ * Implements SLP-specific trading and transaction methods for Sudo SDK
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SLPAPI = void 0;
+const transactions_1 = require("@mysten/sui/transactions");
+const utils_1 = require("@mysten/sui/utils");
+const consts_1 = require("../consts/index.cjs");
+const abstract_1 = require("../abstract/index.cjs");
+const SLPDataAPI_1 = require("./SLPDataAPI.cjs");
+const utils_2 = require("../utils.cjs");
+const kiosk_1 = require("@mysten/kiosk");
+class SLPAPI extends abstract_1.BaseAPI {
+    constructor(network, provider, apiEndpoint, connectionURL) {
+        super(network, provider, apiEndpoint, connectionURL, consts_1.LPToken.SLP);
+        this.dataAPI = new SLPDataAPI_1.SLPDataAPI(network, provider, apiEndpoint, connectionURL);
+    }
+    valuateVaults(tx) {
+        throw new Error('Method not implemented.');
+    }
+    valuateSymbols(tx) {
+        throw new Error('Method not implemented.');
+    }
+    valuate(tx) {
+        throw new Error('Method not implemented.');
+    }
+    valuateMarket() {
+        throw new Error('Method not implemented.');
+    }
+    fundingFeeRate(indexToken, long, sender) {
+        throw new Error('Method not implemented.');
+    }
+    rebaseFeeRate(collateralToken, increase, amount, sender) {
+        throw new Error('Method not implemented.');
+    }
+    reservingFeeRate(collateralToken, amount, sender) {
+        throw new Error('Method not implemented.');
+    }
+    calcPositionReserveFeeAmount(position) {
+        throw new Error('Method not implemented.');
+    }
+    calcPositionFundingFeeValue(position) {
+        throw new Error('Method not implemented.');
+    }
+    getMarketInfo() {
+        throw new Error('Method not implemented.');
+    }
+    getVaultInfo(vault) {
+        throw new Error('Method not implemented.');
+    }
+    getSymbolInfo(tokenId, long) {
+        throw new Error('Method not implemented.');
+    }
+    getPositionConfig(indexToken, long) {
+        throw new Error('Method not implemented.');
+    }
+    getRebaseFeeModel() {
+        throw new Error('Method not implemented.');
+    }
+    getOpenPositions() {
+        throw new Error('Method not implemented.');
+    }
+    getPositionCapInfoList(owner) {
+        throw new Error('Method not implemented.');
+    }
+    getPositionInfoList(positionCapInfoList, owner) {
+        throw new Error('Method not implemented.');
+    }
+    getOrderCapInfoList(owner) {
+        throw new Error('Method not implemented.');
+    }
+    getOrderInfoList(orderCapInfoList, owner) {
+        throw new Error('Method not implemented.');
+    }
+    getHistory(trader, page, limit, orderType, symbol) {
+        throw new Error('Method not implemented.');
+    }
+    getStaked(owner) {
+        throw new Error('Method not implemented.');
+    }
+    getStakePool() {
+        throw new Error('Method not implemented.');
+    }
+    hasReferral(referree) {
+        throw new Error('Method not implemented.');
+    }
+    getReferralData(referree) {
+        throw new Error('Method not implemented.');
+    }
+    /**
+     * Deposits collateral into SLP vault using Sudo SDK approach
+     */
+    async deposit(coin, coinObjects, amount, minAmountOut, referralAddress, sender) {
+        let tx = new transactions_1.Transaction();
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        tx = await this.initOracleTxb(Object.keys(this.consts.pythFeeder.feeder));
+        const coinObject = this.processCoins(tx, coin, coinObjects);
+        const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)]);
+        const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::deposit`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[coin].module,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.rebaseFeeModel),
+                depositObject,
+                tx.pure.u64(minAmountOut || 0),
+                vaultsValuation,
+                symbolsValuation,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Withdraws collateral from SLP vault using Sudo SDK approach
+     */
+    async withdraw(coin, lpCoinObjects, amount, minAmountOut) {
+        const tx = await this.initOracleTxb(Object.keys(this.consts.pythFeeder.feeder));
+        const lpCoinObject = this.processCoins(tx, `${this.consts.sudoCore.package}::slp::SLP`, lpCoinObjects);
+        const [withdrawObject] = tx.splitCoins(lpCoinObject, [tx.pure.u64(amount)]);
+        const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::withdraw`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[coin].module,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.rebaseFeeModel),
+                withdrawObject,
+                tx.pure.u64(minAmountOut || 0),
+                vaultsValuation,
+                symbolsValuation,
+            ],
+        });
+        return tx;
+    }
+    async swap(fromToken, toToken, fromAmount, fromCoinObjects, minAmountOut) {
+        const tx = await this.initOracleTxb(Object.keys(this.consts.sudoCore.vaults));
+        const fromCoinObject = this.processCoins(tx, fromToken, fromCoinObjects);
+        const [fromDepositObject] = tx.splitCoins(fromCoinObject, [
+            tx.pure.u64(fromAmount),
+        ]);
+        const vaultsValuation = this.dataAPI.valuateVaults(tx);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::swap`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[fromToken].module,
+                this.consts.coins[toToken].module,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.rebaseFeeModel),
+                fromDepositObject,
+                tx.pure.u64(minAmountOut || 0),
+                vaultsValuation,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Stakes SLP tokens in Sudo staking pools
+     */
+    async stake(lpCoinObjects, amount, pool) {
+        if (!this.consts.sudoStaking) {
+            throw new Error('Sudo staking configuration not found');
+        }
+        const tx = new transactions_1.Transaction();
+        const coinObject = this.processCoins(tx, 'slp', lpCoinObjects);
+        const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)]);
+        tx.moveCall({
+            target: `${this.consts.sudoStaking.package}::pool::deposit`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                `${this.consts.sudoCore.package}::slp::SLP`,
+            ],
+            arguments: [
+                tx.object(pool),
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                depositObject,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Unstakes SLP tokens from Sudo staking pools
+     */
+    async unstake(credentials, amount, pool) {
+        if (!this.consts.sudoStaking) {
+            throw new Error('Sudo staking configuration not found');
+        }
+        const tx = new transactions_1.Transaction();
+        for (const credential of credentials) {
+            // eslint-disable-next-line unicorn/prefer-math-min-max
+            const withdrawAmount = amount < credential.amount ? amount : credential.amount;
+            amount -= withdrawAmount;
+            tx.moveCall({
+                target: `${this.consts.sudoStaking.package}::pool::withdraw`,
+                typeArguments: [
+                    `${this.consts.sudoCore.package}::slp::SLP`,
+                    `${this.consts.sudoCore.package}::slp::SLP`,
+                ],
+                arguments: [
+                    tx.object(pool),
+                    tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    tx.object(credential.id),
+                    tx.pure.u64(withdrawAmount),
+                ],
+            });
+            if (credential.amount === BigInt(0)) {
+                tx.moveCall({
+                    target: `${this.consts.sudoStaking.package}::pool::clear_empty_credential`,
+                    typeArguments: [
+                        `${this.consts.sudoCore.package}::slp::SLP`,
+                        `${this.consts.sudoCore.package}::slp::SLP`,
+                    ],
+                    arguments: [tx.object(credential.id)],
+                });
+            }
+        }
+        return tx;
+    }
+    /**
+     * Opens a position using Sudo SDK approach
+     */
+    async openPosition(collateralToken, indexToken, size, collateralAmount, coinObjects, long, reserveAmount, indexPrice, collateralPrice, isLimitOrder = false, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), referralAddress, sender) {
+        let tx = new transactions_1.Transaction();
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        tx = await this.initOracleTxb([collateralToken, indexToken], tx);
+        const coinObject = this.processCoins(tx, collateralToken, coinObjects);
+        const [depositObject] = tx.splitCoins(coinObject, [
+            tx.pure.u64(collateralAmount),
+        ]);
+        const feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee || BigInt(0.5))]); // Sudo contract requires SUI as fee
+        const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+        const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage || 0.003);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage || 0.5);
+        let allowTrade = consts_1.ALLOW_TRADE_MUST_TRADE;
+        if (isLimitOrder) {
+            allowTrade = isIocOrder ? consts_1.ALLOW_TRADE_NO_TRADE : consts_1.ALLOW_TRADE_CAN_TRADE;
+        }
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_v1_2`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins['sui'].module,
+            ],
+            arguments: [
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                depositObject,
+                feeObject,
+                tx.pure.u8(allowTrade),
+                tx.pure.u64(size),
+                tx.pure.u64(reserveAmount),
+                tx.pure.u256(adjustCollateralPrice),
+                tx.pure.u256(adjustPrice),
+                tx.pure.bool(isLimitOrder),
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Decreases an existing position in SLP using Sudo SDK approach
+     */
+    async decreasePosition(pcpId, collateralToken, indexToken, amount, long, indexPrice, collateralPrice, isTriggerOrder = false, isTakeProfitOrder = true, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), coinObjects) {
+        const tx = await this.initOracleTxb([collateralToken, indexToken]);
+        const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+        const feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee)]); // Sudo contract requires SUI as fee
+        const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+        let allowTrade = consts_1.ALLOW_TRADE_MUST_TRADE;
+        if (isTriggerOrder) {
+            if (isIocOrder || !isTakeProfitOrder) {
+                allowTrade = consts_1.ALLOW_TRADE_NO_TRADE;
+            }
+            else {
+                allowTrade = consts_1.ALLOW_TRADE_CAN_TRADE;
+            }
+        }
+        else {
+            isTakeProfitOrder = true;
+        }
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v1_2`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins['sui'].module,
+            ],
+            arguments: [
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(pcpId),
+                tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                feeObject,
+                tx.pure.u8(allowTrade),
+                tx.pure.bool(isTakeProfitOrder),
+                tx.pure.u64(amount),
+                tx.pure.u256(adjustCollateralPrice),
+                tx.pure.u256(adjustPrice),
+                tx.pure.bool(isTriggerOrder),
+            ],
+        });
+        return tx;
+    }
+    async decreaseMultiPositions(positions, tx) {
+        if (!tx) {
+            tx = new transactions_1.Transaction();
+        }
+        tx = await this.initOracleTxb(positions.map(position => [position.collateralToken, position.indexToken]).flat(), tx);
+        for (const position of positions) {
+            const { pcpId, collateralToken, coinObjects, indexToken, amount, long, indexPrice, collateralPrice, isTriggerOrder, isTakeProfitOrder, isIocOrder, slippage, relayerFee } = position;
+            let innerIsTakeProfitOrder = isTakeProfitOrder;
+            const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+            const coinObject = this.processCoins(tx, collateralToken, coinObjects);
+            const feeObject = tx.splitCoins(coinObject, [tx.pure.u64(relayerFee)]);
+            const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : slippage);
+            const adjustCollateralPrice = this.processSlippage(collateralPrice, false, 0.5);
+            let allowTrade = consts_1.ALLOW_TRADE_MUST_TRADE;
+            if (isTriggerOrder) {
+                allowTrade = isIocOrder || !innerIsTakeProfitOrder ? consts_1.ALLOW_TRADE_NO_TRADE : consts_1.ALLOW_TRADE_CAN_TRADE;
+            }
+            else {
+                innerIsTakeProfitOrder = true;
+            }
+            tx.moveCall({
+                target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v1_2`,
+                typeArguments: [
+                    `${this.consts.sudoCore.package}::slp::SLP`,
+                    this.consts.coins[collateralToken].module,
+                    this.consts.coins[indexToken].module,
+                    `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                    this.consts.coins['sui'].module,
+                ],
+                arguments: [
+                    tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    tx.object(this.consts.sudoCore.market),
+                    tx.object(pcpId),
+                    tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                    tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                    tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                    tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                    feeObject,
+                    tx.pure.u8(allowTrade),
+                    tx.pure.bool(isTakeProfitOrder),
+                    tx.pure.u64(amount),
+                    tx.pure.u256(adjustCollateralPrice),
+                    tx.pure.u256(adjustPrice),
+                    tx.pure.bool(isTriggerOrder),
+                ],
+            });
+        }
+        return tx;
+    }
+    async pledgeInPosition(pcpId, collateralToken, indexToken, amount, coinObjects, long) {
+        const tx = await this.initOracleTxb([collateralToken, indexToken]);
+        const coinObject = this.processCoins(tx, collateralToken, coinObjects);
+        const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)]);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::pledge_in_position`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.market),
+                tx.object(pcpId),
+                depositObject,
+            ],
+        });
+        return tx;
+    }
+    async redeemFromPosition(pcpId, collateralToken, indexToken, amount, long) {
+        const tx = await this.initOracleTxb([collateralToken, indexToken]);
+        const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::redeem_from_position_v1_1`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(pcpId),
+                tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                tx.pure.u64(amount),
+            ],
+        });
+        return tx;
+    }
+    async cancelOrder(orderCapId, collateralToken, indexToken, long, type, isV11Order) {
+        const tx = new transactions_1.Transaction();
+        let functionName = '';
+        switch (type) {
+            case 'OPEN_POSITION':
+                functionName = 'clear_open_position_order_v1_1';
+                break;
+            case 'DECREASE_POSITION':
+                functionName = 'clear_decrease_position_order_v1_1';
+                break;
+            default:
+                throw new Error('invalid order type');
+        }
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::${functionName}`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins['sui'].module,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.market),
+                tx.object(orderCapId),
+            ],
+        });
+        return tx;
+    }
+    async cancelMultiOrders(orders, tx) {
+        if (!tx) {
+            tx = new transactions_1.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_v1_1' : 'clear_open_position_order_v1_1';
+                    break;
+                }
+                case 'DECREASE_POSITION': {
+                    functionName = isV11Order
+                        ? 'clear_decrease_position_order_v1_1'
+                        : 'clear_decrease_position_order_v1_1';
+                    break;
+                }
+                default: {
+                    throw new Error('invalid order type');
+                }
+            }
+            tx.moveCall({
+                target: `${this.consts.sudoCore.upgradedPackage}::market::${functionName}`,
+                typeArguments: [
+                    `${this.consts.sudoCore.package}::slp::SLP`,
+                    this.consts.coins[collateralToken].module,
+                    this.consts.coins[indexToken].module,
+                    `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                    this.consts.coins[collateralToken].module,
+                ],
+                arguments: [tx.object(this.consts.sudoCore.market), tx.object(orderCapId)],
+            });
+        }
+        return tx;
+    }
+    clearClosedPosition(pcpId, collateralToken, indexToken, long, tx) {
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::clear_closed_position`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [tx.object(this.consts.sudoCore.market), tx.object(pcpId)],
+        });
+    }
+    clearOpenPositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order) {
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::clear_open_position_order_v1_1`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins['sui'].module,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.market),
+                tx.object(orderCapId),
+            ],
+        });
+    }
+    clearDecreasePositionOrder(orderCapId, collateralToken, indexToken, long, tx) {
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::clear_decrease_position_order_v1_1`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins['sui'].module,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.market),
+                tx.object(orderCapId),
+            ],
+        });
+    }
+    async openPositionWithSCard(collateralToken, indexToken, size, collateralAmount, coinObjects, long, reserveAmount, indexPrice, collateralPrice, kioskClient, kioskCap, scard, isLimitOrder = false, isIocOrder = false, pricesSlippage, collateralSlippage, relayerFee, referralAddress, sender) {
+        let tx = new transactions_1.Transaction();
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        tx = await this.initOracleTxb([collateralToken, indexToken], tx);
+        const coinObject = this.processCoins(tx, collateralToken, coinObjects);
+        const [depositObject] = tx.splitCoins(coinObject, [
+            tx.pure.u64(collateralAmount),
+        ]);
+        const feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee || BigInt(0.5))]); // Sudo contract requires SUI as fee
+        const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+        const adjustPrice = this.processSlippage(indexPrice, long, isLimitOrder ? 0 : pricesSlippage || 0.003);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage || 0.5);
+        let allowTrade = consts_1.ALLOW_TRADE_MUST_TRADE;
+        if (isLimitOrder) {
+            allowTrade = isIocOrder ? consts_1.ALLOW_TRADE_NO_TRADE : consts_1.ALLOW_TRADE_CAN_TRADE;
+        }
+        const kioskTx = new kiosk_1.KioskTransaction({
+            transaction: tx,
+            kioskClient,
+            cap: kioskCap,
+        });
+        const [sudoCard, promise] = kioskTx.borrow({
+            itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+            itemId: scard,
+        });
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_v1_3`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins['sui'].module,
+            ],
+            arguments: [
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].positionConfig),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                depositObject,
+                feeObject,
+                tx.pure.u8(allowTrade),
+                tx.pure.u64(size),
+                tx.pure.u64(reserveAmount),
+                tx.pure.u256(adjustCollateralPrice),
+                tx.pure.u256(adjustPrice),
+                tx.pure.bool(isLimitOrder),
+                sudoCard,
+            ],
+        });
+        kioskTx
+            .return({
+            itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+            item: sudoCard,
+            promise: 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) {
+        const tx = await this.initOracleTxb([collateralToken, indexToken]);
+        const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+        const feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee)]); // Sudo contract requires SUI as fee
+        const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice, false, collateralSlippage);
+        let allowTrade = consts_1.ALLOW_TRADE_MUST_TRADE;
+        if (isTriggerOrder) {
+            if (isIocOrder || !isTakeProfitOrder) {
+                allowTrade = consts_1.ALLOW_TRADE_NO_TRADE;
+            }
+            else {
+                allowTrade = consts_1.ALLOW_TRADE_CAN_TRADE;
+            }
+        }
+        else {
+            isTakeProfitOrder = true;
+        }
+        const kioskTx = new kiosk_1.KioskTransaction({
+            transaction: tx,
+            kioskClient,
+            cap: kioskCap,
+        });
+        const [sudoCard, promise] = kioskTx.borrow({
+            itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+            itemId: scard,
+        });
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v1_3`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins['sui'].module,
+            ],
+            arguments: [
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(pcpId),
+                tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                feeObject,
+                tx.pure.u8(allowTrade),
+                tx.pure.bool(isTakeProfitOrder),
+                tx.pure.u64(amount),
+                tx.pure.u256(adjustCollateralPrice),
+                tx.pure.u256(adjustPrice),
+                tx.pure.bool(isTriggerOrder),
+                sudoCard,
+            ],
+        });
+        kioskTx
+            .return({
+            itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+            item: sudoCard,
+            promise: promise,
+        })
+            .finalize();
+        return tx;
+    }
+    async decreaseMultiPositionsWithSCard(positions, kioskClient, kioskCap, scard, tx) {
+        if (!tx) {
+            tx = new transactions_1.Transaction();
+        }
+        tx = await this.initOracleTxb(positions.map(position => [position.collateralToken, position.indexToken]).flat(), tx);
+        const kioskTx = new kiosk_1.KioskTransaction({
+            transaction: tx,
+            kioskClient,
+            cap: kioskCap,
+        });
+        const [sudoCard, promise] = kioskTx.borrow({
+            itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+            itemId: scard,
+        });
+        for (const position of positions) {
+            const { pcpId, collateralToken, indexToken, amount, long, indexPrice, collateralPrice, isTriggerOrder, isTakeProfitOrder, isIocOrder, slippage, relayerFee, coinObjects, } = position;
+            let innerIsTakeProfitOrder = isTakeProfitOrder;
+            const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+            const coinObject = this.processCoins(tx, collateralToken, coinObjects);
+            const feeObject = tx.splitCoins(coinObject, [tx.pure.u64(relayerFee)]);
+            const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : slippage);
+            const adjustCollateralPrice = this.processSlippage(collateralPrice, false, 0.5);
+            let allowTrade = consts_1.ALLOW_TRADE_MUST_TRADE;
+            if (isTriggerOrder) {
+                allowTrade = isIocOrder || !innerIsTakeProfitOrder ? consts_1.ALLOW_TRADE_NO_TRADE : consts_1.ALLOW_TRADE_CAN_TRADE;
+            }
+            else {
+                innerIsTakeProfitOrder = true;
+            }
+            tx.moveCall({
+                target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v1_3`,
+                typeArguments: [
+                    `${this.consts.sudoCore.package}::slp::SLP`,
+                    this.consts.coins[collateralToken].module,
+                    this.consts.coins[indexToken].module,
+                    `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                    this.consts.coins['sui'].module,
+                ],
+                arguments: [
+                    tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    tx.object(this.consts.sudoCore.market),
+                    tx.object(pcpId),
+                    tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                    tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                    tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                    tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                    feeObject,
+                    tx.pure.u8(allowTrade),
+                    tx.pure.bool(isTakeProfitOrder),
+                    tx.pure.u64(amount),
+                    tx.pure.u256(adjustCollateralPrice),
+                    tx.pure.u256(adjustPrice),
+                    tx.pure.bool(isTriggerOrder),
+                    sudoCard,
+                ],
+            });
+        }
+        kioskTx
+            .return({
+            itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+            item: sudoCard,
+            promise: promise,
+        })
+            .finalize();
+        return tx;
+    }
+    addReferral(referrer, tx) {
+        if (!tx) {
+            tx = new transactions_1.Transaction();
+        }
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::add_new_referral`,
+            typeArguments: [`${this.consts.sudoCore.package}::slp::SLP`],
+            arguments: [tx.object(this.consts.sudoCore.market), tx.object(referrer)],
+        });
+        return tx;
+    }
+    async adminUpdatePriceFeed(collateralToken, indexToken) {
+        const tx = await this.initOracleTxb([collateralToken, indexToken]);
+        return tx;
+    }
+    async adminSettlePosition(positionId, owner, collateralToken, indexToken, long) {
+        // SLP does not support this operation
+        throw new Error('Method not implemented.');
+    }
+    async adminDecreasePosition(positionId, owner, collateralToken, indexToken, positionAmount, amount, long, collateralPrice, collateralSlippage, relayerFee) {
+        const tx = await this.initOracleTxb([collateralToken, indexToken]);
+        const symbol = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
+        const feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee || BigInt(1))]);
+        const adjustCollateralPrice = this.processSlippage(collateralPrice || 0, false, collateralSlippage || 0.5);
+        let allowTrade = consts_1.ALLOW_TRADE_MUST_TRADE;
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::admin_decrease_position_v1_3`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins['sui'].module,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.adminCap),
+                tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(positionId),
+                tx.object(this.consts.sudoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.sudoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                feeObject,
+                tx.pure.u8(allowTrade),
+                tx.pure.u64(amount),
+                tx.pure.u256(adjustCollateralPrice),
+                tx.object(owner),
+            ],
+        });
+        if (amount === BigInt(positionAmount)) {
+            this.adminClearClosedPosition(positionId, owner, collateralToken, indexToken, long, tx);
+        }
+        return tx;
+    }
+    async adminClearClosedPosition(positionId, owner, collateralToken, indexToken, long, tx) {
+        tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::admin_clear_closed_position_v1_1`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.adminCap),
+                tx.object(owner),
+                tx.object(this.consts.sudoCore.market),
+                tx.object(positionId),
+            ],
+        });
+    }
+    // SLP Specific APIs
+    async claimTokenFromSCard(token, coinObjects, kioskClient, kioskCap, scard) {
+        const tx = new transactions_1.Transaction();
+        const kioskTx = new kiosk_1.KioskTransaction({
+            transaction: tx,
+            kioskClient,
+            cap: kioskCap,
+        });
+        const [sudoCard, promise] = kioskTx.borrow({
+            itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+            itemId: scard,
+        });
+        // claim tokens
+        coinObjects.forEach(coinObject => {
+            return tx.moveCall({
+                target: `${this.consts.sudoNft.upgradedPackage}::card::claim_token`,
+                typeArguments: [`${this.consts.coins[token].module}`],
+                arguments: [sudoCard, tx.object(coinObject)],
+            });
+        });
+        kioskTx
+            .return({
+            itemType: `${this.consts.sudoNft.package}::card::SudoCard`,
+            item: sudoCard,
+            promise: promise,
+        })
+            .finalize();
+        return tx;
+    }
+}
+exports.SLPAPI = SLPAPI;
+//# sourceMappingURL=SLPAPI.cjs.map