zo-sdk 0.0.51 → 0.1.0

package/dist/implementations/ZLPAPI.mjs

@@ -0,0 +1,805 @@
+/**
+ * ZLP API implementation
+ * Implements ZLP-specific trading and transaction methods
+ */
+import { Transaction } from "@mysten/sui/transactions";
+import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
+import { ALLOW_TRADE_CAN_TRADE, ALLOW_TRADE_MUST_TRADE, ALLOW_TRADE_NO_TRADE, LPToken } from "../consts/index.mjs";
+import { BaseAPI } from "../abstract/index.mjs";
+import { ZLPDataAPI } from "./ZLPDataAPI.mjs";
+import { joinSymbol } from "../utils.mjs";
+import { KioskClient, KioskTransaction } from "@mysten/kiosk";
+export class ZLPAPI extends BaseAPI {
+    constructor(network, provider, apiEndpoint, connectionURL) {
+        super(network, provider, apiEndpoint, connectionURL, LPToken.ZLP);
+        this.dataAPI = new ZLPDataAPI(network, provider, apiEndpoint, connectionURL);
+    }
+    stake(lpCoinObjects, amount, pool, tx) {
+        throw new Error('Method not implemented.');
+    }
+    unstake(credentials, amount, pool, tx) {
+        throw new Error('Method not implemented.');
+    }
+    claimTokenFromSCard(token, coinObjects, kioskClient, kioskCap, scard) {
+        throw new Error('Method not implemented.');
+    }
+    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) {
+        throw new Error('Method not implemented.');
+    }
+    rebaseFeeRate(collateralToken, increase, amount) {
+        throw new Error('Method not implemented.');
+    }
+    reservingFeeRate(collateralToken, amount) {
+        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 ZLP vault
+     */
+    async deposit(coin, coinObjects, amount, minAmountOut, referralAddress, sender) {
+        let tx = await this.initOracleTxb(Object.keys(this.consts.pythFeeder.feeder));
+        if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+            tx = await this.addReferral(referralAddress, tx);
+        }
+        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.zoCore.package}::market::deposit`,
+            typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`, this.consts.coins[coin].module],
+            arguments: [
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.rebaseFeeModel),
+                depositObject,
+                tx.pure.u64(minAmountOut || 0),
+                vaultsValuation,
+                symbolsValuation,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Withdraws collateral from ZLP vault
+     */
+    async withdraw(coin, lpCoinObjects, amount, minAmountOut) {
+        const tx = await this.initOracleTxb(Object.keys(this.consts.pythFeeder.feeder));
+        const zlpCoinObject = this.processCoins(tx, 'zlp', lpCoinObjects);
+        const [withdrawObject] = tx.splitCoins(zlpCoinObject, [tx.pure.u64(amount)]);
+        const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx);
+        tx.moveCall({
+            target: `${this.consts.zoCore.package}::market::withdraw`,
+            typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`, this.consts.coins[coin].module],
+            arguments: [
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.rebaseFeeModel),
+                withdrawObject,
+                tx.pure.u64(minAmountOut || 0),
+                vaultsValuation,
+                symbolsValuation,
+            ],
+        });
+        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.package}::market::swap`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[fromToken].module,
+                this.consts.coins[toToken].module,
+            ],
+            arguments: [
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.rebaseFeeModel),
+                fromDepositObject,
+                tx.pure.u64(minAmountOut || 0),
+                vaultsValuation,
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Opens a new position in ZLP
+     */
+    async openPosition(collateralToken, indexToken, size, collateralAmount, coinObjects, long, reserveAmount, indexPrice, collateralPrice, isLimitOrder, isIocOrder, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), referralAddress, sender) {
+        let tx = new 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, feeObject] = tx.splitCoins(coinObject, [
+            tx.pure.u64(collateralAmount),
+            tx.pure.u64(relayerFee),
+        ]);
+        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;
+        }
+        tx.moveCall({
+            target: `${this.consts.zoCore.package}::market::open_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.zoCore.symbols[symbol].positionConfig),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                depositObject,
+                feeObject,
+                tx.pure.u8(allowTrade),
+                tx.pure.u64(size),
+                tx.pure.u64(reserveAmount),
+                tx.pure.u256(adjustCollateralPrice),
+                tx.pure.u256(adjustPrice),
+            ],
+        });
+        return tx;
+    }
+    /**
+     * Decreases an existing position in ZLP
+     */
+    async decreasePosition(pcpId, collateralToken, indexToken, amount, long, indexPrice, collateralPrice, isTriggerOrder = false, isTakeProfitOrder = true, isIocOrder = false, pricesSlippage = 0.003, collateralSlippage = 0.5, relayerFee = BigInt(0.5), coinObjects) {
+        const tx = await this.initOracleTxb([collateralToken, indexToken]);
+        const symbol = 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 : 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;
+        }
+        tx.moveCall({
+            target: `${this.consts.zoCore.package}::market::decrease_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(pcpId),
+                tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                feeObject,
+                tx.pure.u8(allowTrade),
+                tx.pure.bool(isTakeProfitOrder),
+                tx.pure.u64(amount),
+                tx.pure.u256(adjustCollateralPrice),
+                tx.pure.u256(adjustPrice),
+            ],
+        });
+        return tx;
+    }
+    async decreaseMultiPositions(positions, tx) {
+        if (!tx) {
+            tx = new 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 = 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 = ALLOW_TRADE_MUST_TRADE;
+            if (isTriggerOrder) {
+                allowTrade = isIocOrder || !innerIsTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE;
+            }
+            else {
+                innerIsTakeProfitOrder = true;
+            }
+            tx.moveCall({
+                target: `${this.consts.zoCore.package}::market::decrease_position`,
+                typeArguments: [
+                    `${this.consts.zoCore.package}::zlp::ZLP`,
+                    this.consts.coins[collateralToken].module,
+                    this.consts.coins[indexToken].module,
+                    `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                    this.consts.coins[collateralToken].module,
+                ],
+                arguments: [
+                    tx.object(SUI_CLOCK_OBJECT_ID),
+                    tx.object(this.consts.zoCore.market),
+                    tx.object(pcpId),
+                    tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                    tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+                    tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                    tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                    feeObject,
+                    tx.pure.u8(allowTrade),
+                    tx.pure.bool(innerIsTakeProfitOrder),
+                    tx.pure.u64(amount),
+                    tx.pure.u256(adjustCollateralPrice),
+                    tx.pure.u256(adjustPrice),
+                ],
+            });
+        }
+        return tx;
+    }
+    async 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) {
+        let tx = new 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, feeObject] = tx.splitCoins(coinObject, [
+            tx.pure.u64(collateralAmount),
+            tx.pure.u64(relayerFee),
+        ]);
+        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,
+        });
+        tx.moveCall({
+            target: `${this.consts.zoCore.package}::market::open_position_with_scard`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.zoCore.symbols[symbol].positionConfig),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                depositObject,
+                feeObject,
+                tx.pure.u8(allowTrade),
+                tx.pure.u64(size),
+                tx.pure.u64(reserveAmount),
+                tx.pure.u256(adjustCollateralPrice),
+                tx.pure.u256(adjustPrice),
+                sudoCard,
+            ],
+        });
+        kioskTx
+            .return({
+            itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+            item: sudoCard,
+            promise: 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 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 coinObject = this.processCoins(tx, collateralToken, coinObjects || []);
+        const feeObject = tx.splitCoins(coinObject, [tx.pure.u64(relayerFee)]);
+        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;
+        }
+        tx.moveCall({
+            target: `${this.consts.zoCore.package}::market::decrease_position_with_scard`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(pcpId),
+                tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                feeObject,
+                tx.pure.u8(allowTrade),
+                tx.pure.bool(isTakeProfitOrder),
+                tx.pure.u64(amount),
+                tx.pure.u256(adjustCollateralPrice),
+                tx.pure.u256(adjustPrice),
+                sudoCard,
+            ],
+        });
+        kioskTx
+            .return({
+            itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+            item: sudoCard,
+            promise: promise,
+        })
+            .finalize();
+        return tx;
+    }
+    async decreaseMultiPositionsWithSCard(positions, kioskClient, kioskCap, scard, tx) {
+        if (!tx) {
+            tx = new Transaction();
+        }
+        tx = await this.initOracleTxb(positions.map(position => [position.collateralToken, position.indexToken]).flat(), tx);
+        const kioskTx = new KioskTransaction({
+            transaction: tx,
+            kioskClient,
+            cap: kioskCap,
+        });
+        const [sudoCard, promise] = kioskTx.borrow({
+            itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+            itemId: scard,
+        });
+        for (const position of positions) {
+            const { pcpId, collateralToken, indexToken, amount, long, indexPrice, collateralPrice, isTriggerOrder, isTakeProfitOrder, isIocOrder, slippage, relayerFee, coinObjects } = position;
+            let innerIsTakeProfitOrder = isTakeProfitOrder;
+            const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+            const coinObject = this.processCoins(tx, collateralToken, coinObjects || []);
+            const feeObject = tx.splitCoins(coinObject, [tx.pure.u64(relayerFee || BigInt(0.5))]);
+            const adjustPrice = this.processSlippage(indexPrice, !long, isTriggerOrder ? 0 : slippage);
+            const adjustCollateralPrice = this.processSlippage(collateralPrice, false, 0.5);
+            let allowTrade = ALLOW_TRADE_MUST_TRADE;
+            if (isTriggerOrder) {
+                allowTrade = isIocOrder || !innerIsTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE;
+            }
+            else {
+                innerIsTakeProfitOrder = true;
+            }
+            tx.moveCall({
+                target: `${this.consts.zoCore.package}::market::decrease_position_with_scard`,
+                typeArguments: [
+                    `${this.consts.zoCore.package}::zlp::ZLP`,
+                    this.consts.coins[collateralToken].module,
+                    this.consts.coins[indexToken].module,
+                    `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                    this.consts.coins[collateralToken].module,
+                ],
+                arguments: [
+                    tx.object(SUI_CLOCK_OBJECT_ID),
+                    tx.object(this.consts.zoCore.market),
+                    tx.object(pcpId),
+                    tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                    tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+                    tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                    tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                    feeObject,
+                    tx.pure.u8(allowTrade),
+                    tx.pure.bool(innerIsTakeProfitOrder),
+                    tx.pure.u64(amount),
+                    tx.pure.u256(adjustCollateralPrice),
+                    tx.pure.u256(adjustPrice),
+                    sudoCard,
+                ],
+            });
+        }
+        kioskTx
+            .return({
+            itemType: `0xe7e651e4974fe367aa2837712d68081efb299c470242a15e2b9c26ea326159ec::card::SudoCard`,
+            item: sudoCard,
+            promise: promise,
+        })
+            .finalize();
+        return tx;
+    }
+    /**
+     * Pledges in position (ZLP-specific functionality)
+     */
+    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.zoCore.package}::market::pledge_in_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [tx.object(this.consts.zoCore.market), tx.object(pcpId), depositObject],
+        });
+        return tx;
+    }
+    async redeemFromPosition(pcpId, collateralToken, indexToken, amount, long) {
+        const tx = await this.initOracleTxb([collateralToken, indexToken]);
+        const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+        tx.moveCall({
+            target: `${this.consts.zoCore.package}::market::redeem_from_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(pcpId),
+                tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                tx.pure.u64(amount),
+            ],
+        });
+        return tx;
+    }
+    async 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.package}::market::${functionName}`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [tx.object(this.consts.zoCore.market), tx.object(orderCapId)],
+        });
+        return tx;
+    }
+    async 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.package}::market::${functionName}`,
+                typeArguments: [
+                    `${this.consts.zoCore.package}::zlp::ZLP`,
+                    this.consts.coins[collateralToken].module,
+                    this.consts.coins[indexToken].module,
+                    `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                    this.consts.coins[collateralToken].module,
+                ],
+                arguments: [tx.object(this.consts.zoCore.market), tx.object(orderCapId)],
+            });
+        }
+        return tx;
+    }
+    clearClosedPosition(pcpId, collateralToken, indexToken, long, tx) {
+        tx.moveCall({
+            target: `${this.consts.zoCore.package}::market::clear_closed_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [tx.object(this.consts.zoCore.market), tx.object(pcpId)],
+        });
+    }
+    clearOpenPositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order) {
+        const funcName = isV11Order ? 'clear_open_position_order' : 'clear_open_position_order';
+        tx.moveCall({
+            target: `${this.consts.zoCore.package}::market::${funcName}`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [tx.object(this.consts.zoCore.market), tx.object(orderCapId)],
+        });
+    }
+    clearDecreasePositionOrder(orderCapId, collateralToken, indexToken, long, tx, isV11Order) {
+        const funcName = isV11Order ? 'clear_decrease_position_order' : 'clear_decrease_position_order';
+        tx.moveCall({
+            target: `${this.consts.zoCore.package}::market::${funcName}`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+                this.consts.coins[collateralToken].module,
+            ],
+            arguments: [tx.object(this.consts.zoCore.market), tx.object(orderCapId)],
+        });
+    }
+    addReferral(referralAddress, tx) {
+        if (!tx) {
+            tx = new Transaction();
+        }
+        tx.moveCall({
+            target: `${this.consts.zoCore.package}::market::add_new_referral`,
+            typeArguments: [`${this.consts.zoCore.package}::zlp::ZLP`],
+            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;
+    }
+    async adminSettlePosition(positionId, owner, collateralToken, indexToken, long) {
+        const tx = new Transaction();
+        tx.moveCall({
+            target: `${this.consts.zoCore.upgradedPackage}::market::force_settle_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [
+                tx.object(this.consts.zoCore.adminCap),
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(owner),
+                tx.object(positionId),
+            ],
+        });
+        this.adminClearClosedPosition(positionId, owner, collateralToken, indexToken, long, tx);
+        return tx;
+    }
+    async adminDecreasePosition(positionId, owner, collateralToken, indexToken, positionAmount, amount, long, collateralPrice, collateralSlippage, relayerFee) {
+        const tx = new Transaction();
+        const symbol = joinSymbol(long ? 'long' : 'short', indexToken);
+        tx.moveCall({
+            target: `${this.consts.zoCore.package}::market::force_close_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [
+                tx.object(this.consts.zoCore.adminCap),
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(this.consts.zoCore.market),
+                tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+                tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+                tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+                tx.object(this.consts.pythFeeder.feeder[indexToken]),
+                tx.object(owner),
+                tx.object(positionId),
+            ],
+        });
+        if (amount === BigInt(positionAmount)) {
+            this.adminClearClosedPosition(positionId, owner, collateralToken, indexToken, long, tx);
+        }
+        return tx;
+    }
+    async adminClearClosedPosition(positionId, owner, collateralToken, indexToken, long, tx) {
+        tx.moveCall({
+            target: `${this.consts.zoCore.package}::market::force_clear_closed_position`,
+            typeArguments: [
+                `${this.consts.zoCore.package}::zlp::ZLP`,
+                this.consts.coins[collateralToken].module,
+                this.consts.coins[indexToken].module,
+                `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+            ],
+            arguments: [
+                tx.object(this.consts.zoCore.adminCap),
+                tx.object(this.consts.zoCore.market),
+                tx.object(positionId),
+                tx.object(owner),
+            ],
+        });
+    }
+    async adminIssueLootbox(coin, tiers, beneficiaries, amounts, tx) {
+        let module = this.consts.zoCore.package + '::zlp::ZLP';
+        if (coin !== 'zlp') {
+            module = this.consts.coins[coin].module;
+        }
+        for (let i = 0; i < beneficiaries.length; i++) {
+            tx.moveCall({
+                target: `${this.consts.zoLootbox.package}::lootbox::admin_issue_lootbox`,
+                typeArguments: [module],
+                arguments: [
+                    tx.object(this.consts.zoLootbox.adminCap),
+                    tx.pure.u8(tiers[i]),
+                    tx.pure.address(beneficiaries[i]),
+                    tx.pure.u64(amounts[i]),
+                    tx.pure.bool(amounts[i] > 0),
+                    tx.object(`${this.consts.zoLootbox.lootboxSettings}`),
+                ],
+            });
+        }
+    }
+    async depositToPrizePool(coin, coinObjects, amount) {
+        const tx = new Transaction();
+        const coinObject = this.processCoins(tx, coin, coinObjects);
+        const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)]);
+        let module = this.consts.zoCore.package + '::zlp::ZLP';
+        if (coin !== 'zlp') {
+            module = this.consts.coins[coin].module;
+        }
+        tx.moveCall({
+            target: `${this.consts.zoLootbox.package}::lootbox::deposit`,
+            typeArguments: [module],
+            arguments: [
+                tx.object(this.consts.zoLootbox.adminCap),
+                tx.object(this.consts.zoLootbox.lootboxTreasury),
+                depositObject,
+            ],
+        });
+        return tx;
+    }
+    async withdrawFromPricePool(coin, amount) {
+        const tx = new Transaction();
+        let module = this.consts.zoCore.package + '::zlp::ZLP';
+        let metadata = this.consts.zoCore.zlpMetadata;
+        if (coin !== 'zlp') {
+            module = this.consts.coins[coin].module;
+            metadata = this.consts.coins[coin].metadata;
+        }
+        tx.moveCall({
+            target: `${this.consts.zoLootbox.package}::lootbox::withdraw`,
+            typeArguments: [module],
+            arguments: [
+                tx.object(this.consts.zoLootbox.adminCap),
+                tx.object(this.consts.zoLootbox.lootboxTreasury),
+                tx.object(metadata),
+                tx.pure.u64(amount),
+            ],
+        });
+        return tx;
+    }
+    async openLootbox(coin, lootbox) {
+        const tx = new Transaction();
+        let module = this.consts.zoCore.package + '::zlp::ZLP';
+        let metadata = this.consts.zoCore.zlpMetadata;
+        if (coin !== 'zlp') {
+            module = this.consts.coins[coin].module;
+            metadata = this.consts.coins[coin].metadata;
+        }
+        tx.moveCall({
+            target: `${this.consts.zoLootbox.package}::lootbox::open_lootbox`,
+            typeArguments: [module],
+            arguments: [
+                tx.object(`${this.consts.zoLootbox.lootboxTreasury}`),
+                tx.object(lootbox),
+                tx.object(metadata),
+                tx.object(`${this.consts.zoLootbox.lootboxSettings}`),
+            ],
+        });
+        return tx;
+    }
+}
+//# sourceMappingURL=ZLPAPI.mjs.map