@typus/typus-sdk 1.4.20 → 1.4.22

package/dist/src/typus-perp/fetch.d.ts

@@ -4,15 +4,14 @@ import { Markets, SymbolMarket } from "./trading/structs";
 import { TradingOrder, Position } from "./position/structs";
 import { LpUserShare, StakePool } from "./stake-pool/structs";
 import { PythClient, TypusConfig } from "../utils";
-export declare function getLpPools(provider: SuiClient, config: TypusConfig): Promise<LiquidityPool[]>;
-export declare function getStakePools(provider: SuiClient, config: TypusConfig): Promise<StakePool[]>;
-export declare function getMarkets(provider: SuiClient, config: TypusConfig): Promise<Markets[]>;
+export declare function getLpPools(config: TypusConfig): Promise<LiquidityPool[]>;
+export declare function getStakePools(config: TypusConfig): Promise<StakePool[]>;
+export declare function getMarkets(config: TypusConfig): Promise<Markets[]>;
 export declare function getSymbolMarkets(provider: SuiClient, market: Markets): Promise<Map<string, SymbolMarket>>;
-export declare function getUserOrders(provider: SuiClient, config: TypusConfig, user: string): Promise<TradingOrder[]>;
-export declare function getUserPositions(provider: SuiClient, config: TypusConfig, user: string): Promise<Position[]>;
-export declare function getUserStake(provider: SuiClient, config: TypusConfig, user: string): Promise<LpUserShare[]>;
-export declare function getLiquidationPrice(provider: SuiClient, config: TypusConfig, input: {
-    pythClient: PythClient;
+export declare function getUserOrders(config: TypusConfig, user: string): Promise<TradingOrder[]>;
+export declare function getUserPositions(config: TypusConfig, user: string): Promise<Position[]>;
+export declare function getUserStake(config: TypusConfig, user: string): Promise<LpUserShare[]>;
+export declare function getLiquidationPrice(config: TypusConfig, pythClient: PythClient, input: {
     positions: Position[];
     user: string;
 }): Promise<string[] | undefined>;

package/dist/src/typus-perp/fetch.js

@@ -55,6 +55,7 @@ exports.getUserOrders = getUserOrders;
 exports.getUserPositions = getUserPositions;
 exports.getUserStake = getUserStake;
 exports.getLiquidationPrice = getLiquidationPrice;
+var client_1 = require("@mysten/sui.js/client");
 var structs_1 = require("./lp-pool/structs");
 var structs_2 = require("./trading/structs");
 var functions_1 = require("./trading/functions");
@@ -67,15 +68,17 @@ var constants_2 = require("../constants");
 var utils_1 = require("../utils");
 var _1 = require(".");
 var bcs_1 = require("@mysten/bcs");
-function getLpPools(provider, config) {
+function getLpPools(config) {
     return __awaiter(this, void 0, void 0, function () {
-        var dynamicFields, lpPools, _a, _b, field, lpPool, e_1_1;
+        var provider, dynamicFields, lpPools, _a, _b, field, lpPool, e_1_1;
         var e_1, _c;
         return __generator(this, function (_d) {
             switch (_d.label) {
-                case 0: return [4 /*yield*/, provider.getDynamicFields({
-                        parentId: config.registry.perp.liquidityPool,
-                    })];
+                case 0:
+                    provider = new client_1.SuiClient({ url: config.rpcEndpoint });
+                    return [4 /*yield*/, provider.getDynamicFields({
+                            parentId: config.registry.perp.liquidityPool,
+                        })];
                 case 1:
                     dynamicFields = _d.sent();
                     lpPools = [];
@@ -112,15 +115,17 @@ function getLpPools(provider, config) {
         });
     });
 }
-function getStakePools(provider, config) {
+function getStakePools(config) {
     return __awaiter(this, void 0, void 0, function () {
-        var dynamicFields, stakePools, _a, _b, field, stakePool, e_2_1;
+        var provider, dynamicFields, stakePools, _a, _b, field, stakePool, e_2_1;
         var e_2, _c;
         return __generator(this, function (_d) {
             switch (_d.label) {
-                case 0: return [4 /*yield*/, provider.getDynamicFields({
-                        parentId: config.registry.perp.stakePool,
-                    })];
+                case 0:
+                    provider = new client_1.SuiClient({ url: config.rpcEndpoint });
+                    return [4 /*yield*/, provider.getDynamicFields({
+                            parentId: config.registry.perp.stakePool,
+                        })];
                 case 1:
                     dynamicFields = _d.sent();
                     stakePools = [];
@@ -157,15 +162,17 @@ function getStakePools(provider, config) {
         });
     });
 }
-function getMarkets(provider, config) {
+function getMarkets(config) {
     return __awaiter(this, void 0, void 0, function () {
-        var dynamicFields, markets, _a, _b, field, market, e_3_1;
+        var provider, dynamicFields, markets, _a, _b, field, market, e_3_1;
         var e_3, _c;
         return __generator(this, function (_d) {
             switch (_d.label) {
-                case 0: return [4 /*yield*/, provider.getDynamicFields({
-                        parentId: config.registry.perp.market,
-                    })];
+                case 0:
+                    provider = new client_1.SuiClient({ url: config.rpcEndpoint });
+                    return [4 /*yield*/, provider.getDynamicFields({
+                            parentId: config.registry.perp.market,
+                        })];
                 case 1:
                     dynamicFields = _d.sent();
                     markets = [];
@@ -250,12 +257,13 @@ function getSymbolMarkets(provider, market) {
         });
     });
 }
-function getUserOrders(provider, config, user) {
+function getUserOrders(config, user) {
     return __awaiter(this, void 0, void 0, function () {
-        var tx, res, returnValues, orders;
+        var provider, tx, res, returnValues, orders;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
+                    provider = new client_1.SuiClient({ url: config.rpcEndpoint });
                     tx = new transactions_1.TransactionBlock();
                     (0, functions_1.getUserOrders)(tx, {
                         version: config.version.perp,
@@ -274,12 +282,13 @@ function getUserOrders(provider, config, user) {
         });
     });
 }
-function getUserPositions(provider, config, user) {
+function getUserPositions(config, user) {
     return __awaiter(this, void 0, void 0, function () {
-        var tx, res, returnValues, positions;
+        var provider, tx, res, returnValues, positions;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
+                    provider = new client_1.SuiClient({ url: config.rpcEndpoint });
                     tx = new transactions_1.TransactionBlock();
                     (0, functions_1.getUserPositions)(tx, {
                         version: config.version.perp,
@@ -298,12 +307,13 @@ function getUserPositions(provider, config, user) {
         });
     });
 }
-function getUserStake(provider, config, user) {
+function getUserStake(config, user) {
     return __awaiter(this, void 0, void 0, function () {
-        var tx, res, returnValues, stake;
+        var provider, tx, res, returnValues, stake;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
+                    provider = new client_1.SuiClient({ url: config.rpcEndpoint });
                     tx = new transactions_1.TransactionBlock();
                     (0, functions_2.getUserShares)(tx, {
                         registry: config.registry.perp.stakePool,
@@ -330,14 +340,15 @@ function getUserStake(provider, config, user) {
         });
     });
 }
-function getLiquidationPrice(provider, config, input) {
+function getLiquidationPrice(config, pythClient, input) {
     return __awaiter(this, void 0, void 0, function () {
-        var tx, pythTokens, _a, _b, position, TOKEN, BASE_TOKEN, _c, _d, position, TOKEN, BASE_TOKEN, cToken, baseToken, res, prices;
+        var provider, tx, pythTokens, _a, _b, position, TOKEN, BASE_TOKEN, _c, _d, position, TOKEN, BASE_TOKEN, cToken, baseToken, res, prices;
         var e_5, _e, e_6, _f;
         var _g;
         return __generator(this, function (_h) {
             switch (_h.label) {
                 case 0:
+                    provider = new client_1.SuiClient({ url: config.rpcEndpoint });
                     tx = new transactions_1.TransactionBlock();
                     pythTokens = [];
                     try {
@@ -356,7 +367,7 @@ function getLiquidationPrice(provider, config, input) {
                         }
                         finally { if (e_5) throw e_5.error; }
                     }
-                    return [4 /*yield*/, (0, utils_1.updatePyth)(input.pythClient, tx, Array.from(new Set(pythTokens)))];
+                    return [4 /*yield*/, (0, utils_1.updatePyth)(pythClient, tx, Array.from(new Set(pythTokens)))];
                 case 1:
                     _h.sent();
                     try {

package/dist/src/typus-perp/user/order.d.ts

@@ -2,9 +2,7 @@ import { Position, TradingOrder } from "../position/structs";
 import { PythClient, TypusConfig } from "../../utils";
 import { TOKEN } from "../../constants";
 import { TransactionBlock } from "@mysten/sui.js/transactions";
-export declare function createTradingOrder(config: TypusConfig, input: {
-    pythClient: PythClient;
-    tx: TransactionBlock;
+export declare function createTradingOrder(config: TypusConfig, tx: TransactionBlock, pythClient: PythClient, input: {
     coins: string[];
     cToken: TOKEN;
     amount: string;
@@ -16,21 +14,16 @@ export declare function createTradingOrder(config: TypusConfig, input: {
     reduceOnly: boolean;
     linkedPositionId: string | null;
 }): Promise<TransactionBlock>;
-export declare function cancelTradingOrder(config: TypusConfig, input: {
-    tx: TransactionBlock;
+export declare function cancelTradingOrder(config: TypusConfig, tx: TransactionBlock, input: {
     order: TradingOrder;
     user: string;
 }): Promise<TransactionBlock>;
-export declare function increaseCollateral(config: TypusConfig, input: {
-    pythClient: PythClient;
-    tx: TransactionBlock;
+export declare function increaseCollateral(config: TypusConfig, tx: TransactionBlock, pythClient: PythClient, input: {
     coins: string[];
     amount: string;
     position: Position;
 }): Promise<TransactionBlock>;
-export declare function releaseCollateral(config: TypusConfig, input: {
-    pythClient: PythClient;
-    tx: TransactionBlock;
+export declare function releaseCollateral(config: TypusConfig, tx: TransactionBlock, pythClient: PythClient, input: {
     position: Position;
     amount: string;
 }): Promise<TransactionBlock>;

package/dist/src/typus-perp/user/order.js

@@ -61,7 +61,7 @@ var constants_1 = require("../../constants");
 var __1 = require("..");
 var utils_1 = require("../../utils");
 var constants_2 = require("../../constants");
-function createTradingOrder(config, input) {
+function createTradingOrder(config, tx, pythClient, input) {
     return __awaiter(this, void 0, void 0, function () {
         var TOKEN, BASE_TOKEN, cToken, baseToken, coin, destination;
         var _a, _b;
@@ -70,22 +70,22 @@ function createTradingOrder(config, input) {
                 case 0:
                     TOKEN = input.cToken;
                     BASE_TOKEN = input.tradingToken;
-                    return [4 /*yield*/, (0, utils_1.updatePyth)(input.pythClient, input.tx, [TOKEN, BASE_TOKEN])];
+                    return [4 /*yield*/, (0, utils_1.updatePyth)(pythClient, tx, [TOKEN, BASE_TOKEN])];
                 case 1:
                     _c.sent();
                     cToken = constants_2.tokenType[__1.NETWORK][TOKEN];
                     baseToken = constants_2.tokenType[__1.NETWORK][BASE_TOKEN];
                     if (TOKEN == "SUI") {
-                        _a = __read(input.tx.splitCoins(input.tx.gas, [input.amount]), 1), coin = _a[0];
+                        _a = __read(tx.splitCoins(tx.gas, [input.amount]), 1), coin = _a[0];
                     }
                     else {
                         destination = input.coins.pop();
                         if (input.coins.length > 0) {
-                            input.tx.mergeCoins(destination, input.coins);
+                            tx.mergeCoins(destination, input.coins);
                         }
-                        _b = __read(input.tx.splitCoins(destination, [input.amount]), 1), coin = _b[0];
+                        _b = __read(tx.splitCoins(destination, [input.amount]), 1), coin = _b[0];
                     }
-                    (0, functions_1.createTradingOrder)(input.tx, [cToken, baseToken], {
+                    (0, functions_1.createTradingOrder)(tx, [cToken, baseToken], {
                         version: config.version.perp,
                         registry: config.registry.perp.market,
                         poolRegistry: config.registry.perp.lpPool,
@@ -106,30 +106,30 @@ function createTradingOrder(config, input) {
                         reduceOnly: input.reduceOnly,
                         linkedPositionId: input.linkedPositionId ? BigInt(input.linkedPositionId) : null,
                     });
-                    return [2 /*return*/, input.tx];
+                    return [2 /*return*/, tx];
             }
         });
     });
 }
-function cancelTradingOrder(config, input) {
+function cancelTradingOrder(config, tx, input) {
     return __awaiter(this, void 0, void 0, function () {
         var cToken, BASE_TOKEN, coin;
         return __generator(this, function (_a) {
             cToken = "0x" + input.order.collateralToken.name;
             BASE_TOKEN = "0x" + input.order.symbol.baseToken.name;
-            coin = (0, functions_1.cancelTradingOrder)(input.tx, [cToken, BASE_TOKEN], {
+            coin = (0, functions_1.cancelTradingOrder)(tx, [cToken, BASE_TOKEN], {
                 version: config.version.perp,
                 registry: config.registry.perp.market,
                 marketIndex: BigInt(0),
                 orderId: input.order.orderId,
                 triggerPrice: input.order.triggerPrice,
             });
-            input.tx.transferObjects([coin], input.user);
-            return [2 /*return*/, input.tx];
+            tx.transferObjects([coin], input.user);
+            return [2 /*return*/, tx];
         });
     });
 }
-function increaseCollateral(config, input) {
+function increaseCollateral(config, tx, pythClient, input) {
     return __awaiter(this, void 0, void 0, function () {
         var TOKEN, BASE_TOKEN, cToken, baseToken, coin, destination;
         var _a, _b;
@@ -138,22 +138,22 @@ function increaseCollateral(config, input) {
                 case 0:
                     TOKEN = (0, constants_2.typeArgToToken)(input.position.collateralToken.name);
                     BASE_TOKEN = (0, constants_2.typeArgToToken)(input.position.symbol.baseToken.name);
-                    return [4 /*yield*/, (0, utils_1.updatePyth)(input.pythClient, input.tx, [TOKEN, BASE_TOKEN])];
+                    return [4 /*yield*/, (0, utils_1.updatePyth)(pythClient, tx, [TOKEN, BASE_TOKEN])];
                 case 1:
                     _c.sent();
                     cToken = constants_2.tokenType[__1.NETWORK][TOKEN];
                     baseToken = constants_2.tokenType[__1.NETWORK][BASE_TOKEN];
                     if (TOKEN == "SUI") {
-                        _a = __read(input.tx.splitCoins(input.tx.gas, [input.amount]), 1), coin = _a[0];
+                        _a = __read(tx.splitCoins(tx.gas, [input.amount]), 1), coin = _a[0];
                     }
                     else {
                         destination = input.coins.pop();
                         if (input.coins.length > 0) {
-                            input.tx.mergeCoins(destination, input.coins);
+                            tx.mergeCoins(destination, input.coins);
                         }
-                        _b = __read(input.tx.splitCoins(destination, [input.amount]), 1), coin = _b[0];
+                        _b = __read(tx.splitCoins(destination, [input.amount]), 1), coin = _b[0];
                     }
-                    (0, functions_1.increaseCollateral)(input.tx, [cToken, baseToken], {
+                    (0, functions_1.increaseCollateral)(tx, [cToken, baseToken], {
                         version: config.version.perp,
                         registry: config.registry.perp.market,
                         poolRegistry: config.registry.perp.lpPool,
@@ -166,12 +166,12 @@ function increaseCollateral(config, input) {
                         positionId: BigInt(input.position.positionId),
                         collateral: coin,
                     });
-                    return [2 /*return*/, input.tx];
+                    return [2 /*return*/, tx];
             }
         });
     });
 }
-function releaseCollateral(config, input) {
+function releaseCollateral(config, tx, pythClient, input) {
     return __awaiter(this, void 0, void 0, function () {
         var TOKEN, BASE_TOKEN, cToken, baseToken, coin;
         return __generator(this, function (_a) {
@@ -179,12 +179,12 @@ function releaseCollateral(config, input) {
                 case 0:
                     TOKEN = (0, constants_2.typeArgToToken)(input.position.collateralToken.name);
                     BASE_TOKEN = (0, constants_2.typeArgToToken)(input.position.symbol.baseToken.name);
-                    return [4 /*yield*/, (0, utils_1.updatePyth)(input.pythClient, input.tx, [TOKEN, BASE_TOKEN])];
+                    return [4 /*yield*/, (0, utils_1.updatePyth)(pythClient, tx, [TOKEN, BASE_TOKEN])];
                 case 1:
                     _a.sent();
                     cToken = constants_2.tokenType[__1.NETWORK][TOKEN];
                     baseToken = constants_2.tokenType[__1.NETWORK][BASE_TOKEN];
-                    coin = (0, functions_1.releaseCollateral)(input.tx, [cToken, baseToken], {
+                    coin = (0, functions_1.releaseCollateral)(tx, [cToken, baseToken], {
                         version: config.version.perp,
                         registry: config.registry.perp.market,
                         poolRegistry: config.registry.perp.lpPool,
@@ -197,8 +197,8 @@ function releaseCollateral(config, input) {
                         positionId: BigInt(input.position.positionId),
                         releaseAmount: BigInt(input.amount),
                     });
-                    input.tx.transferObjects([coin], input.position.user);
-                    return [2 /*return*/, input.tx];
+                    tx.transferObjects([coin], input.position.user);
+                    return [2 /*return*/, tx];
             }
         });
     });

package/dist/src/typus-perp/user/orderWithBidReceipt.d.ts

@@ -1,10 +1,7 @@
 import { TransactionBlock } from "@mysten/sui.js/transactions";
 import { PythClient, TypusConfig } from "../../utils";
 import { TOKEN } from "../../constants";
-import { Position } from "../position/structs";
-export declare function createTradingOrderWithBidReceipt(config: TypusConfig, input: {
-    pythClient: PythClient;
-    tx: TransactionBlock;
+export declare function createTradingOrderWithBidReceipt(config: TypusConfig, tx: TransactionBlock, pythClient: PythClient, input: {
     cToken: TOKEN;
     tradingToken: TOKEN;
     isLong: boolean;
@@ -14,9 +11,12 @@ export declare function createTradingOrderWithBidReceipt(config: TypusConfig, in
     bidReceipt: string;
     share: string | null;
 }): Promise<TransactionBlock>;
-export declare function reduceOptionCollateralPositionSize(config: TypusConfig, input: {
-    pythClient: PythClient;
-    tx: TransactionBlock;
-    position: Position;
-    size: string | null;
+export declare function reduceOptionCollateralPositionSize(config: TypusConfig, tx: TransactionBlock, pythClient: PythClient, input: {
+    cToken: TOKEN;
+    tradingToken: TOKEN;
+    bToken: string;
+    share: string | null;
+    index: string;
+    user: string;
+    bidReceipt: string;
 }): Promise<TransactionBlock>;

package/dist/src/typus-perp/user/orderWithBidReceipt.js

@@ -43,7 +43,7 @@ var utils_1 = require("../../utils");
 var constants_1 = require("../../constants");
 var __1 = require("..");
 var typus_dov_single_v2_1 = require("../../typus-dov-single-v2/");
-function createTradingOrderWithBidReceipt(config, input) {
+function createTradingOrderWithBidReceipt(config, tx, pythClient, input) {
     return __awaiter(this, void 0, void 0, function () {
         var TOKEN, BASE_TOKEN, cToken, bToken, baseToken, collateralBidReceipt;
         return __generator(this, function (_a) {
@@ -51,15 +51,15 @@ function createTradingOrderWithBidReceipt(config, input) {
                 case 0:
                     TOKEN = input.cToken;
                     BASE_TOKEN = input.tradingToken;
-                    return [4 /*yield*/, (0, utils_1.updatePyth)(input.pythClient, input.tx, [TOKEN, BASE_TOKEN])];
+                    return [4 /*yield*/, (0, utils_1.updatePyth)(pythClient, tx, [TOKEN, BASE_TOKEN])];
                 case 1:
                     _a.sent();
                     cToken = constants_1.tokenType[__1.NETWORK][TOKEN];
                     bToken = constants_1.tokenType[__1.NETWORK][input.bToken];
                     baseToken = constants_1.tokenType[__1.NETWORK][BASE_TOKEN];
-                    (0, utils_1.updateOracleWithPyth)(input.pythClient, input.tx, config.package.oracle, config.oracle[BASE_TOKEN.toLocaleLowerCase()], BASE_TOKEN, "USDC");
+                    (0, utils_1.updateOracleWithPyth)(pythClient, tx, config.package.oracle, config.oracle[BASE_TOKEN.toLocaleLowerCase()], BASE_TOKEN, "USDC");
                     if (input.share) {
-                        collateralBidReceipt = (0, typus_dov_single_v2_1.getSplitBidReceiptTx)(config, input.tx, {
+                        collateralBidReceipt = (0, typus_dov_single_v2_1.getSplitBidReceiptTx)(config, tx, {
                             index: input.index,
                             receipts: [input.bidReceipt],
                             share: input.share,
@@ -69,7 +69,7 @@ function createTradingOrderWithBidReceipt(config, input) {
                     else {
                         collateralBidReceipt = input.bidReceipt;
                     }
-                    (0, functions_1.createTradingOrderWithBidReceipt)(input.tx, [cToken, bToken, baseToken], {
+                    (0, functions_1.createTradingOrderWithBidReceipt)(tx, [cToken, bToken, baseToken], {
                         version: config.version.perp,
                         registry: config.registry.perp.market,
                         poolRegistry: config.registry.perp.lpPool,
@@ -88,56 +88,57 @@ function createTradingOrderWithBidReceipt(config, input) {
                         collateralBidReceipt: collateralBidReceipt,
                         user: input.user,
                     });
-                    return [2 /*return*/, input.tx];
+                    return [2 /*return*/, tx];
             }
         });
     });
 }
-function reduceOptionCollateralPositionSize(config, input) {
+function reduceOptionCollateralPositionSize(config, tx, pythClient, input) {
     return __awaiter(this, void 0, void 0, function () {
+        var TOKEN, BASE_TOKEN, cToken, bToken, baseToken, collateralBidReceipt;
         return __generator(this, function (_a) {
-            // const TOKEN = input.cToken;
-            // const BASE_TOKEN = input.tradingToken;
-            // await updatePyth(input.pythClient, input.tx, [TOKEN, BASE_TOKEN]);
-            // const cToken = tokenType[NETWORK][TOKEN];
-            // const bToken = tokenType[NETWORK][input.bToken];
-            // const baseToken = tokenType[NETWORK][BASE_TOKEN];
-            // updateOracleWithPyth(input.pythClient, input.tx, config.package.oracle, config.oracle[BASE_TOKEN.toLocaleLowerCase()], BASE_TOKEN, "USDC");
-            // // split bid receipt
-            // var collateralBidReceipt;
-            // if (input.share) {
-            //     collateralBidReceipt = getSplitBidReceiptTx({
-            //         tx: input.tx,
-            //         typusFrameworkOriginPackageId: config.packageOrigin.framework,
-            //         typusDovSinglePackageId: config.package.dovSingle,
-            //         typusDovSingleRegistry: config.registry.dov.dovSingle,
-            //         index: input.index,
-            //         receipts: [input.bidReceipt],
-            //         share: input.share,
-            //         recipient: input.user,
-            //     });
-            // } else {
-            //     collateralBidReceipt = input.bidReceipt;
-            // }
-            // _reduceOptionCollateralPositionSize(input.tx, [cToken, bToken, baseToken], {
-            //     version: config.version.perp,
-            //     registry: config.registry.perp.market,
-            //     poolRegistry: config.registry.perp.lpPool,
-            //     marketIndex: BigInt(0),
-            //     poolIndex: BigInt(0),
-            //     pythState: pythStateId[NETWORK],
-            //     oracleCToken: priceInfoObjectIds[NETWORK][TOKEN],
-            //     oracleTradingSymbol: priceInfoObjectIds[NETWORK][BASE_TOKEN],
-            //     clock: CLOCK,
-            //     typusEcosystemVersion: config.version.typus,
-            //     typusUserRegistry: config.registry.typus.user,
-            //     typusLeaderboardRegistry: config.registry.typus.leaderboard,
-            //     dovRegistry: config.registry.dov.dovSingle,
-            //     typusOracle: config.oracle[BASE_TOKEN.toLocaleLowerCase()],
-            //     positionId: BigInt(123),
-            //     orderSize: null,
-            // });
-            return [2 /*return*/, input.tx];
+            switch (_a.label) {
+                case 0:
+                    TOKEN = input.cToken;
+                    BASE_TOKEN = input.tradingToken;
+                    return [4 /*yield*/, (0, utils_1.updatePyth)(pythClient, tx, [TOKEN, BASE_TOKEN])];
+                case 1:
+                    _a.sent();
+                    cToken = constants_1.tokenType[__1.NETWORK][TOKEN];
+                    bToken = constants_1.tokenType[__1.NETWORK][input.bToken];
+                    baseToken = constants_1.tokenType[__1.NETWORK][BASE_TOKEN];
+                    (0, utils_1.updateOracleWithPyth)(pythClient, tx, config.package.oracle, config.oracle[BASE_TOKEN.toLocaleLowerCase()], BASE_TOKEN, "USDC");
+                    if (input.share) {
+                        collateralBidReceipt = (0, typus_dov_single_v2_1.getSplitBidReceiptTx)(config, tx, {
+                            index: input.index,
+                            receipts: [input.bidReceipt],
+                            share: input.share,
+                            recipient: input.user,
+                        });
+                    }
+                    else {
+                        collateralBidReceipt = input.bidReceipt;
+                    }
+                    (0, functions_1.reduceOptionCollateralPositionSize)(tx, [cToken, bToken, baseToken], {
+                        version: config.version.perp,
+                        registry: config.registry.perp.market,
+                        poolRegistry: config.registry.perp.lpPool,
+                        marketIndex: BigInt(0),
+                        poolIndex: BigInt(0),
+                        pythState: utils_1.pythStateId[__1.NETWORK],
+                        oracleCToken: utils_1.priceInfoObjectIds[__1.NETWORK][TOKEN],
+                        oracleTradingSymbol: utils_1.priceInfoObjectIds[__1.NETWORK][BASE_TOKEN],
+                        clock: constants_1.CLOCK,
+                        typusEcosystemVersion: config.version.typus,
+                        typusUserRegistry: config.registry.typus.user,
+                        typusLeaderboardRegistry: config.registry.typus.leaderboard,
+                        dovRegistry: config.registry.dov.dovSingle,
+                        typusOracle: config.oracle[BASE_TOKEN.toLocaleLowerCase()],
+                        positionId: BigInt(123),
+                        orderSize: null,
+                    });
+                    return [2 /*return*/, tx];
+            }
         });
     });
 }

package/dist/src/typus-perp/user/tlp.d.ts

@@ -2,39 +2,31 @@ import { TransactionBlock } from "@mysten/sui.js/transactions";
 import { LiquidityPool } from "../lp-pool/structs";
 import { PythClient, TypusConfig } from "../../utils";
 import { TOKEN } from "../../constants";
-export declare function mintStakeLp(config: TypusConfig, input: {
-    pythClient: PythClient;
-    tx: TransactionBlock;
+export declare function mintStakeLp(config: TypusConfig, tx: TransactionBlock, pythClient: PythClient, input: {
     lpPool: LiquidityPool;
     coins: string[];
     cTOKEN: TOKEN;
     amount: string;
     userShareId: string | null;
 }): Promise<TransactionBlock>;
-export declare function unstakeBurn(config: TypusConfig, input: {
-    pythClient: PythClient;
-    tx: TransactionBlock;
+export declare function unstakeBurn(config: TypusConfig, tx: TransactionBlock, pythClient: PythClient, input: {
     lpPool: LiquidityPool;
     cTOKEN: TOKEN;
     userShareId: string;
     share: string | null;
     user: string;
 }): Promise<TransactionBlock>;
-export declare function swap(config: TypusConfig, input: {
-    pythClient: PythClient;
-    tx: TransactionBlock;
+export declare function swap(config: TypusConfig, tx: TransactionBlock, pythClient: PythClient, input: {
     coins: string[];
     FROM_TOKEN: TOKEN;
     TO_TOKEN: TOKEN;
     amount: string;
     user: string;
 }): Promise<TransactionBlock>;
-export declare function unsubscribe(config: TypusConfig, input: {
-    tx: TransactionBlock;
+export declare function unsubscribe(config: TypusConfig, tx: TransactionBlock, input: {
     userShareId: string;
     share: string | null;
 }): Promise<TransactionBlock>;
-export declare function harvest(config: TypusConfig, input: {
-    tx: TransactionBlock;
+export declare function harvest(config: TypusConfig, tx: TransactionBlock, input: {
     userShareId: string;
 }): Promise<TransactionBlock>;