@zofai/zo-sdk 0.1.92

package/dist/implementations/ZBTCVCAPI.mjs

@@ -0,0 +1,902 @@
+/**
+ * ZBTCVC API implementation
+ * Implements ZBTCVC-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 { ZBTCVCDataAPI } from "./ZBTCVCDataAPI.mjs";
+export class ZBTCVCAPI extends BaseAPI {
+    constructor(network, provider, apiEndpoint, connectionURL) {
+        super(network, provider, apiEndpoint, connectionURL, LPToken.ZBTCVC);
+        this.dataAPI = new ZBTCVCDataAPI(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}.`);
+    }
+    clearClosedPosition(pcpId, collateralToken, indexToken, long, tx) {
+        tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::clear_closed_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zbtcvc::ZBTCVC`,
+                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}::zbtcvc::ZBTCVC`,
+                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}::zbtcvc::ZBTCVC`,
+                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)],
+        });
+    }
+    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}::zbtcvc::ZBTCVC`,
+                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 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}::zbtcvc::ZBTCVC`,
+                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 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, 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_with_scard`,
+                typeArguments: [
+                    `${this.consts.zoCore.package}::zbtcvc::ZBTCVC`,
+                    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;
+    }
+    /**
+     * Deposits collateral into ZBTCVC 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}::zbtcvc::ZBTCVC`, 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}::zbtcvc::ZBTCVC`,
+                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 ZBTCVC vault
+     */
+    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}::zbtcvc::ZBTCVC`, 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}::zbtcvc::ZBTCVC`,
+                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;
+    }
+    /**
+     * Withdraws collateral from ZBTCVC 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 zbtcvcCoinObject = this.processCoins(tx, 'zbtcvc', lpCoinObjects, false);
+        const [withdrawObject] = tx.splitCoins(zbtcvcCoinObject, [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}::zbtcvc::ZBTCVC`,
+                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;
+    }
+    /**
+     * Stakes ZBTCVC tokens in ZO staking pools
+     */
+    stake(lpCoinObjects, amount, pool, tx) {
+        if (!tx) {
+            tx = new Transaction();
+        }
+        const coinObject = this.processCoins(tx, 'zbtcvc', lpCoinObjects);
+        const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)]);
+        tx.moveCall({
+            target: `${this.sharedConfig.zoStaking.upgradedPackage}::pool::deposit`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zbtcvc::ZBTCVC`,
+                `${this.consts.coins.sui.module}`,
+            ],
+            arguments: [
+                tx.object(pool),
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                depositObject,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Stakes ZBTCVC 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}::zbtcvc::ZBTCVC`,
+                `${this.consts.coins.sui.module}`,
+            ],
+            arguments: [
+                tx.object(pool),
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                coinObject,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Unstakes ZBTCVC 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}::zbtcvc::ZBTCVC`,
+                    `${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}::zbtcvc::ZBTCVC`,
+                        `${this.consts.coins.sui.module}`,
+                    ],
+                    arguments: [tx.object(credential.id)],
+                });
+            }
+        }
+        return tx;
+    }
+    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`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zbtcvc::ZBTCVC`,
+                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,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Opens a new position in ZBTCVC
+     */
+    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}::zbtcvc::ZBTCVC`,
+                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;
+    }
+    /**
+     * Decreases an existing position in ZBTCVC
+     */
+    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}::zbtcvc::ZBTCVC`,
+                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;
+    }
+    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}::zbtcvc::ZBTCVC`,
+                    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;
+    }
+    /**
+     * Pledges in position (ZBTCVC-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}::zbtcvc::ZBTCVC`,
+                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}::zbtcvc::ZBTCVC`,
+                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 'DECREASE_POSITION': {
+                functionName = isV11Order
+                    ? 'clear_decrease_position_order'
+                    : 'clear_decrease_position_order';
+                break;
+            }
+            default: {
+                throw new Error('invalid order type');
+            }
+        }
+        tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::${functionName}`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zbtcvc::ZBTCVC`,
+                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 'DECREASE_POSITION': {
+                    functionName = isV11Order
+                        ? 'clear_decrease_position_order'
+                        : 'clear_decrease_position_order';
+                    break;
+                }
+                default: {
+                    throw new Error('invalid order type');
+                }
+            }
+            tx.moveCall({
+                target: `${this.consts.zoCore.upgradedPackage}::market::${functionName}`,
+                typeArguments: [
+                    `${this.consts.zoCore.package}::zbtcvc::ZBTCVC`,
+                    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;
+    }
+    addReferral(referralAddress, tx) {
+        if (!tx) {
+            tx = new Transaction();
+        }
+        tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::add_new_referral`,
+            typeArguments: [`${this.consts.zoCore.package}::zbtcvc::ZBTCVC`],
+            arguments: [tx.object(this.consts.zoCore.market), tx.object(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}::zbtcvc::ZBTCVC`,
+                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}::zbtcvc::ZBTCVC`,
+                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}::zbtcvc::ZBTCVC`,
+                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),
+            ],
+        });
+    }
+}
+//# sourceMappingURL=ZBTCVCAPI.mjs.map