zo-sdk 0.1.30 → 0.1.32

package/dist/implementations/SLPAPI.mjs

@@ -144,6 +144,66 @@ export class SLPAPI extends BaseAPI {
         });
         return tx;
     }
+    /**
+     * Deposits collateral into SLP vault and returns a coin
+     */
+    async depositPtb(coin, coinObjects, amount, minAmountOut = 0, referralAddress, sender, tx, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        if (!tx) {
+            tx = new Transaction();
+        }
+        // Add referral if needed
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        // Initialize oracle transaction
+        const pythFeederKeys = Object.keys(this.consts.pythFeeder.feeder);
+        // Handle sponsored transaction case
+        if (sponsoredTx) {
+            const suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
+            tx = await this.initOracleTxb(pythFeederKeys, tx, true, suiCoinObject);
+            // Process deposit coins
+            const depositObject = coin === 'sui'
+                ? tx.splitCoins(suiCoinObject, [tx.pure.u64(amount)])[0]
+                : tx.splitCoins(this.processCoins(tx, coin, coinObjects, true), [tx.pure.u64(amount)])[0];
+            const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+            const [mintedCoin] = tx.moveCall({
+                target: `${this.consts.sudoCore.upgradedPackage}::market::deposit_ptb`,
+                typeArguments: [`${this.consts.sudoCore.package}::slp::SLP`, this.consts.coins[coin].module],
+                arguments: [
+                    tx.object(this.consts.sudoCore.market),
+                    tx.object(this.consts.sudoCore.rebaseFeeModel),
+                    depositObject,
+                    tx.pure.u64(minAmountOut),
+                    vaultsValuation,
+                    symbolsValuation,
+                ],
+            });
+            return mintedCoin;
+        }
+        // Handle non-sponsored transaction case
+        tx = await this.initOracleTxb(pythFeederKeys, tx);
+        const depositObject = tx.splitCoins(this.processCoins(tx, coin, coinObjects, false), [tx.pure.u64(amount)])[0];
+        const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+        const [mintedCoin] = tx.moveCall({
+            target: `${this.consts.sudoCore.upgradedPackage}::market::deposit_ptb`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                this.consts.coins[coin].module,
+            ],
+            arguments: [
+                tx.object(this.consts.sudoCore.market),
+                tx.object(this.consts.sudoCore.rebaseFeeModel),
+                depositObject,
+                tx.pure.u64(minAmountOut),
+                vaultsValuation,
+                symbolsValuation,
+            ],
+        });
+        return mintedCoin;
+    }
+    /**
+     * Deposits collateral pool with PTB deposit object
+     */
     async depositWithPtb(coin, depositObject, minAmountOut = 0, referralAddress, sender, tx, sponsoredTx, suiCoinObjectsForPythUpdate) {
         if (!tx) {
             tx = new Transaction();
@@ -287,81 +347,17 @@ export class SLPAPI extends BaseAPI {
         });
         return tx;
     }
-    /**
-     * Stakes SLP tokens in Sudo staking pools
-     */
-    stake(lpCoinObjects, amount, pool) {
-        if (!this.consts.sudoStaking) {
-            throw new Error('Sudo staking configuration not found');
-        }
-        const tx = new 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(SUI_CLOCK_OBJECT_ID),
-                depositObject,
-            ],
-        });
-        return tx;
-    }
-    /**
-     * Unstakes SLP tokens from Sudo staking pools
-     */
-    unstake(credentials, amount, pool) {
-        if (!this.consts.sudoStaking) {
-            throw new Error('Sudo staking configuration not found');
-        }
-        const tx = new Transaction();
-        for (const credential of credentials) {
-            const withdrawAmount = (() => {
-                const min = (a, b) => a < b ? a : b;
-                return min(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(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;
-    }
     /**
      * Stakes SLP tokens in ZO staking pools
      */
-    stakeV2(lpCoinObjects, amount, pool, tx) {
+    stake(lpCoinObjects, amount, pool, tx) {
         if (!tx) {
             tx = new Transaction();
         }
         const coinObject = this.processCoins(tx, 'slp', lpCoinObjects);
         const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)]);
         tx.moveCall({
-            target: `${this.sharedConfig.zoStaking.package}::pool::deposit`,
+            target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::deposit`,
             typeArguments: [
                 `${this.consts.sudoCore.package}::slp::SLP`,
                 `${this.consts.sudoCore.package}::slp::SLP`,
@@ -377,12 +373,12 @@ export class SLPAPI extends BaseAPI {
     /**
      * Stakes SLP tokens using coin object only (PTB)
      */
-    stakeCoinObjectV2(coinObject, pool, tx) {
+    stakeCoinObject(coinObject, pool, tx) {
         if (!tx) {
             tx = new Transaction();
         }
         tx.moveCall({
-            target: `${this.sharedConfig.zoStaking.package}::pool::deposit`,
+            target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::deposit`,
             typeArguments: [
                 `${this.consts.sudoCore.package}::slp::SLP`,
                 `${this.consts.sudoCore.package}::slp::SLP`,
@@ -398,7 +394,7 @@ export class SLPAPI extends BaseAPI {
     /**
      * Unstakes SLP tokens from ZO staking pools
      */
-    unstakeV2(credentials, amount, pool, tx) {
+    unstake(credentials, amount, pool, tx) {
         let unstakeAmount = amount;
         if (!tx) {
             tx = new Transaction();
@@ -410,7 +406,7 @@ export class SLPAPI extends BaseAPI {
             })();
             unstakeAmount -= withdrawAmount;
             tx.moveCall({
-                target: `${this.sharedConfig.zoStaking.package}::pool::withdraw`,
+                target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::withdraw`,
                 typeArguments: [
                     `${this.consts.sudoCore.package}::slp::SLP`,
                     `${this.consts.sudoCore.package}::slp::SLP`,
@@ -424,7 +420,7 @@ export class SLPAPI extends BaseAPI {
             });
             if (credential.amount === BigInt(0)) {
                 tx.moveCall({
-                    target: `${this.sharedConfig.zoStaking.package}::pool::clear_empty_credential`,
+                    target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::clear_empty_credential`,
                     typeArguments: [
                         `${this.consts.sudoCore.package}::slp::SLP`,
                         `${this.consts.sudoCore.package}::slp::SLP`,
@@ -435,6 +431,45 @@ export class SLPAPI extends BaseAPI {
         }
         return tx;
     }
+    /**
+     * Withdraws SLP tokens from a staking pool credential (PTB)
+     * Returns the withdrawn coin object for use in programmable transaction blocks
+     */
+    withdrawFromVaultPtb(pool, credential, withdrawAmount, tx) {
+        const [withdrawnCoin] = tx.moveCall({
+            target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::withdraw_ptb`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                `${this.consts.sudoCore.package}::slp::SLP`,
+            ],
+            arguments: [
+                tx.object(pool),
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(credential),
+                tx.pure.u64(withdrawAmount),
+            ],
+        });
+        return withdrawnCoin;
+    }
+    /**
+     * Claims rewards from a staking pool credential (PTB)
+     * Returns the reward coin object for use in programmable transaction blocks
+     */
+    claimRewardsPtb(pool, credential, tx) {
+        const [rewardCoin] = tx.moveCall({
+            target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::claim_rewards_ptb`,
+            typeArguments: [
+                `${this.consts.sudoCore.package}::slp::SLP`,
+                `${this.consts.sudoCore.package}::slp::SLP`,
+            ],
+            arguments: [
+                tx.object(pool),
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(credential),
+            ],
+        });
+        return rewardCoin;
+    }
     /**
      * Opens a position using Sudo SDK approach
      */
@@ -452,26 +487,23 @@ export class SLPAPI extends BaseAPI {
         }
         // Handle oracle initialization and coin processing
         let suiCoinObject;
-        let feeObject;
         if (sponsoredTx) {
             suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
-            feeObject = tx.splitCoins(suiCoinObject, [tx.pure.u64(relayerFee)]); // Sudo contract requires SUI as fee
             tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
         }
         else {
-            feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee)]); // Sudo contract requires SUI as fee
             tx = await this.initOracleTxb([collateralToken, indexToken], tx);
         }
         // Process coin splitting
-        const [depositObject] = this.processCoinSplitting(tx, collateralToken, coinObjects, [tx.pure.u64(collateralAmount)], sponsoredTx, suiCoinObject);
+        const [depositObject, feeObject] = this.processCoinSplitting(tx, collateralToken, coinObjects, [tx.pure.u64(collateralAmount), tx.pure.u64(relayerFee)], sponsoredTx, suiCoinObject);
         tx.moveCall({
-            target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_v1_2`,
+            target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_v2_1`,
             typeArguments: [
                 `${this.consts.sudoCore.package}::slp::SLP`,
                 this.consts.coins[collateralToken].module,
                 this.consts.coins[indexToken].module,
                 `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-                this.consts.coins.sui.module,
+                this.consts.coins[collateralToken].module,
             ],
             arguments: [
                 tx.object(SUI_CLOCK_OBJECT_ID),
@@ -488,7 +520,6 @@ export class SLPAPI extends BaseAPI {
                 tx.pure.u64(reserveAmount),
                 tx.pure.u256(adjustCollateralPrice),
                 tx.pure.u256(adjustPrice),
-                tx.pure.bool(isLimitOrder),
             ],
         });
         return tx;
@@ -497,6 +528,9 @@ export class SLPAPI extends BaseAPI {
      * Decreases an existing position in SLP using Sudo SDK approach
      */
     async decreasePosition(pcpId, collateralToken, indexToken, amount, long, indexPrice, collateralPrice, isTriggerOrder = false, isTakeProfitOrder = true, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), coinObjects, sponsoredTx, suiCoinObjectsForPythUpdate) {
+        if (!coinObjects) {
+            throw new Error(`${this.constructor.name}: coinObjects is required`);
+        }
         let tx = new Transaction();
         const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
         const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage);
@@ -510,24 +544,22 @@ export class SLPAPI extends BaseAPI {
         }
         // Handle oracle initialization and coin processing
         let suiCoinObject;
-        let feeObject;
+        const [feeObject] = this.processCoinSplitting(tx, collateralToken, coinObjects, [tx.pure.u64(relayerFee)], sponsoredTx, suiCoinObject);
         if (sponsoredTx) {
             suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
-            feeObject = tx.splitCoins(suiCoinObject, [tx.pure.u64(relayerFee)]); // Sudo contract requires SUI as fee
             tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
         }
         else {
-            feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee)]); // Sudo contract requires SUI as fee
             tx = await this.initOracleTxb([collateralToken, indexToken], tx);
         }
         tx.moveCall({
-            target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v1_2`,
+            target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v2_1`,
             typeArguments: [
                 `${this.consts.sudoCore.package}::slp::SLP`,
                 this.consts.coins[collateralToken].module,
                 this.consts.coins[indexToken].module,
                 `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-                this.consts.coins.sui.module,
+                this.consts.coins[collateralToken].module,
             ],
             arguments: [
                 tx.object(SUI_CLOCK_OBJECT_ID),
@@ -543,7 +575,6 @@ export class SLPAPI extends BaseAPI {
                 tx.pure.u64(amount),
                 tx.pure.u256(adjustCollateralPrice),
                 tx.pure.u256(adjustPrice),
-                tx.pure.bool(isTriggerOrder),
             ],
         });
         return tx;
@@ -577,13 +608,13 @@ export class SLPAPI extends BaseAPI {
             // Process coin splitting
             const [feeObject] = this.processCoinSplitting(tx, collateralToken, coinObjects, [tx.pure.u64(relayerFee)], sponsoredTx, suiCoinObject);
             tx.moveCall({
-                target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v1_2`,
+                target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v2_1`,
                 typeArguments: [
                     `${this.consts.sudoCore.package}::slp::SLP`,
                     this.consts.coins[collateralToken].module,
                     this.consts.coins[indexToken].module,
                     `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-                    this.consts.coins.sui.module,
+                    this.consts.coins[collateralToken].module,
                 ],
                 arguments: [
                     tx.object(SUI_CLOCK_OBJECT_ID),
@@ -599,7 +630,6 @@ export class SLPAPI extends BaseAPI {
                     tx.pure.u64(amount),
                     tx.pure.u256(adjustCollateralPrice),
                     tx.pure.u256(adjustPrice),
-                    tx.pure.bool(isTriggerOrder),
                 ],
             });
         }
@@ -667,16 +697,16 @@ export class SLPAPI extends BaseAPI {
         });
         return tx;
     }
-    cancelOrder(orderCapId, collateralToken, indexToken, long, type) {
+    cancelOrder(orderCapId, collateralToken, indexToken, long, type, isV11Order) {
         const tx = new Transaction();
         let functionName = '';
         switch (type) {
             case 'OPEN_POSITION': {
-                functionName = 'clear_open_position_order_v1_1';
+                functionName = 'clear_open_position_order_unified';
                 break;
             }
             case 'DECREASE_POSITION': {
-                functionName = 'clear_decrease_position_order_v1_1';
+                functionName = 'clear_decrease_position_order_unified';
                 break;
             }
             default: {
@@ -690,7 +720,7 @@ export class SLPAPI extends BaseAPI {
                 this.consts.coins[collateralToken].module,
                 this.consts.coins[indexToken].module,
                 `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-                this.consts.coins.sui.module,
+                isV11Order ? this.consts.coins.sui.module : this.consts.coins[collateralToken].module,
             ],
             arguments: [
                 tx.object(this.consts.sudoCore.market),
@@ -704,17 +734,15 @@ export class SLPAPI extends BaseAPI {
             tx = new Transaction();
         }
         for (const order of orders) {
-            const { orderCapId, collateralToken, indexToken, long, type, isV11Order } = order;
+            const { orderCapId, collateralToken, indexToken, long, type } = order;
             let functionName = '';
             switch (type) {
                 case 'OPEN_POSITION': {
-                    functionName = isV11Order ? 'clear_open_position_order_v1_1' : 'clear_open_position_order_v1_1';
+                    functionName = 'clear_open_position_order_unified';
                     break;
                 }
                 case 'DECREASE_POSITION': {
-                    functionName = isV11Order
-                        ? 'clear_decrease_position_order_v1_1'
-                        : 'clear_decrease_position_order_v1_1';
+                    functionName = 'clear_decrease_position_order_unified';
                     break;
                 }
                 default: {
@@ -747,15 +775,15 @@ export class SLPAPI extends BaseAPI {
             arguments: [tx.object(this.consts.sudoCore.market), tx.object(pcpId)],
         });
     }
-    clearOpenPositionOrder(orderCapId, collateralToken, indexToken, long, tx) {
+    clearOpenPositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order = true) {
         tx.moveCall({
-            target: `${this.consts.sudoCore.upgradedPackage}::market::clear_open_position_order_v1_1`,
+            target: `${this.consts.sudoCore.upgradedPackage}::market::clear_open_position_order_unified`,
             typeArguments: [
                 `${this.consts.sudoCore.package}::slp::SLP`,
                 this.consts.coins[collateralToken].module,
                 this.consts.coins[indexToken].module,
                 `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-                this.consts.coins.sui.module,
+                isV11Order ? this.consts.coins.sui.module : this.consts.coins[collateralToken].module,
             ],
             arguments: [
                 tx.object(this.consts.sudoCore.market),
@@ -763,15 +791,15 @@ export class SLPAPI extends BaseAPI {
             ],
         });
     }
-    clearDecreasePositionOrder(orderCapId, collateralToken, indexToken, long, tx) {
+    clearDecreasePositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order = true) {
         tx.moveCall({
-            target: `${this.consts.sudoCore.upgradedPackage}::market::clear_decrease_position_order_v1_1`,
+            target: `${this.consts.sudoCore.upgradedPackage}::market::clear_decrease_position_order_unified`,
             typeArguments: [
                 `${this.consts.sudoCore.package}::slp::SLP`,
                 this.consts.coins[collateralToken].module,
                 this.consts.coins[indexToken].module,
                 `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-                this.consts.coins.sui.module,
+                isV11Order ? this.consts.coins.sui.module : this.consts.coins[collateralToken].module,
             ],
             arguments: [
                 tx.object(this.consts.sudoCore.market),
@@ -802,26 +830,23 @@ export class SLPAPI extends BaseAPI {
         });
         // Handle oracle initialization and coin processing
         let suiCoinObject;
-        let feeObject;
         if (sponsoredTx) {
             suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
-            feeObject = tx.splitCoins(suiCoinObject, [tx.pure.u64(relayerFee)]); // Sudo contract requires SUI as fee
             tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
         }
         else {
-            feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee)]); // Sudo contract requires SUI as fee
             tx = await this.initOracleTxb([collateralToken, indexToken], tx);
         }
         // Process coin splitting
-        const [depositObject] = this.processCoinSplitting(tx, collateralToken, coinObjects, [tx.pure.u64(collateralAmount)], sponsoredTx, suiCoinObject);
+        const [depositObject, feeObject] = this.processCoinSplitting(tx, collateralToken, coinObjects, [tx.pure.u64(collateralAmount), tx.pure.u64(relayerFee)], sponsoredTx, suiCoinObject);
         tx.moveCall({
-            target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_v1_3`,
+            target: `${this.consts.sudoCore.upgradedPackage}::market::open_position_with_scard_v1`,
             typeArguments: [
                 `${this.consts.sudoCore.package}::slp::SLP`,
                 this.consts.coins[collateralToken].module,
                 this.consts.coins[indexToken].module,
                 `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-                this.consts.coins.sui.module,
+                this.consts.coins[collateralToken].module,
             ],
             arguments: [
                 tx.object(SUI_CLOCK_OBJECT_ID),
@@ -838,7 +863,6 @@ export class SLPAPI extends BaseAPI {
                 tx.pure.u64(reserveAmount),
                 tx.pure.u256(adjustCollateralPrice),
                 tx.pure.u256(adjustPrice),
-                tx.pure.bool(isLimitOrder),
                 sudoCard,
             ],
         });
@@ -852,6 +876,9 @@ export class SLPAPI extends BaseAPI {
         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 symbol = joinSymbol(long ? 'long' : 'short', indexToken);
         const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : pricesSlippage);
@@ -874,24 +901,23 @@ export class SLPAPI extends BaseAPI {
         });
         // Handle oracle initialization and coin processing
         let suiCoinObject;
-        let feeObject;
         if (sponsoredTx) {
             suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true);
-            feeObject = tx.splitCoins(suiCoinObject, [tx.pure.u64(relayerFee)]); // Sudo contract requires SUI as fee
             tx = await this.initOracleTxb([collateralToken, indexToken], tx, true, suiCoinObject);
         }
         else {
-            feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee)]); // Sudo contract requires SUI as fee
             tx = await this.initOracleTxb([collateralToken, indexToken], tx);
         }
+        // Process coin splitting
+        const [feeObject] = this.processCoinSplitting(tx, collateralToken, coinObjects, [tx.pure.u64(relayerFee)], sponsoredTx, suiCoinObject);
         tx.moveCall({
-            target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v1_3`,
+            target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_with_scard_v1`,
             typeArguments: [
                 `${this.consts.sudoCore.package}::slp::SLP`,
                 this.consts.coins[collateralToken].module,
                 this.consts.coins[indexToken].module,
                 `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-                this.consts.coins.sui.module,
+                this.consts.coins[collateralToken].module,
             ],
             arguments: [
                 tx.object(SUI_CLOCK_OBJECT_ID),
@@ -907,7 +933,6 @@ export class SLPAPI extends BaseAPI {
                 tx.pure.u64(amount),
                 tx.pure.u256(adjustCollateralPrice),
                 tx.pure.u256(adjustPrice),
-                tx.pure.bool(isTriggerOrder),
                 sudoCard,
             ],
         });
@@ -958,13 +983,13 @@ export class SLPAPI extends BaseAPI {
             // Process coin splitting
             const [feeObject] = this.processCoinSplitting(tx, collateralToken, coinObjects, [tx.pure.u64(relayerFee)], sponsoredTx, suiCoinObject);
             tx.moveCall({
-                target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_v1_3`,
+                target: `${this.consts.sudoCore.upgradedPackage}::market::decrease_position_with_scard_v1`,
                 typeArguments: [
                     `${this.consts.sudoCore.package}::slp::SLP`,
                     this.consts.coins[collateralToken].module,
                     this.consts.coins[indexToken].module,
                     `${this.consts.sudoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
-                    this.consts.coins.sui.module,
+                    this.consts.coins[collateralToken].module,
                 ],
                 arguments: [
                     tx.object(SUI_CLOCK_OBJECT_ID),
@@ -980,7 +1005,6 @@ export class SLPAPI extends BaseAPI {
                     tx.pure.u64(amount),
                     tx.pure.u256(adjustCollateralPrice),
                     tx.pure.u256(adjustPrice),
-                    tx.pure.bool(isTriggerOrder),
                     sudoCard,
                 ],
             });