aftermath-ts-sdk 1.2.52 → 1.2.53

package/dist/packages/perpetuals/api/perpetualsApi.js

@@ -24,8 +24,6 @@ exports.PerpetualsApi = void 0;
 const transactions_1 = require("@mysten/sui/transactions");
 const utils_1 = require("../../../general/utils");
 const sui_1 = require("../../sui");
-const perpetualsTypes_1 = require("../perpetualsTypes");
-const perpetuals_1 = require("../perpetuals");
 const eventsApiHelpers_1 = require("../../../general/apiHelpers/eventsApiHelpers");
 const transactionsApiHelpers_1 = require("../../../general/apiHelpers/transactionsApiHelpers");
 const bcs_1 = require("@mysten/sui/bcs");
@@ -58,7 +56,7 @@ class PerpetualsApi {
         this.allocateCollateralTx = (inputs) => {
             const { tx, collateralCoinType, accountCapId, marketId, amount } = inputs;
             return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.perpetuals.packages.perpetuals, PerpetualsApi.constants.moduleNames.interface, "allocate_collateral"),
+                target: utils_1.Helpers.transactions.createTxTarget(inputs.packageId, PerpetualsApi.constants.moduleNames.interface, "allocate_collateral"),
                 typeArguments: [collateralCoinType],
                 arguments: [
                     tx.sharedObjectRef({
@@ -76,7 +74,7 @@ class PerpetualsApi {
         this.deallocateCollateralTx = (inputs) => {
             const { tx, collateralCoinType, accountCapId, marketId, amount } = inputs;
             return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.perpetuals.packages.perpetuals, PerpetualsApi.constants.moduleNames.interface, "deallocate_collateral"),
+                target: utils_1.Helpers.transactions.createTxTarget(inputs.packageId, PerpetualsApi.constants.moduleNames.interface, "deallocate_collateral"),
                 typeArguments: [collateralCoinType],
                 arguments: [
                     tx.sharedObjectRef({
@@ -95,7 +93,7 @@ class PerpetualsApi {
         this.createMarketPositionTx = (inputs) => {
             const { tx, collateralCoinType, accountCapId, marketId } = inputs;
             return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.perpetuals.packages.perpetuals, PerpetualsApi.constants.moduleNames.interface, "create_market_position"),
+                target: utils_1.Helpers.transactions.createTxTarget(inputs.packageId, PerpetualsApi.constants.moduleNames.interface, "create_market_position"),
                 typeArguments: [collateralCoinType],
                 arguments: [
                     tx.sharedObjectRef({
@@ -112,7 +110,7 @@ class PerpetualsApi {
         this.shareClearingHouseTx = (inputs) => {
             const { tx, collateralCoinType, marketId } = inputs;
             return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.perpetuals.packages.perpetuals, PerpetualsApi.constants.moduleNames.interface, "share_clearing_house"),
+                target: utils_1.Helpers.transactions.createTxTarget(inputs.packageId, PerpetualsApi.constants.moduleNames.interface, "share_clearing_house"),
                 typeArguments: [collateralCoinType],
                 arguments: [
                     typeof marketId === "string" ? tx.object(marketId) : marketId,
@@ -122,7 +120,7 @@ class PerpetualsApi {
         this.startSessionTx = (inputs) => {
             const { tx, collateralCoinType, accountCapId, marketId } = inputs;
             return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.perpetuals.packages.perpetuals, PerpetualsApi.constants.moduleNames.interface, "start_session"),
+                target: utils_1.Helpers.transactions.createTxTarget(inputs.packageId, PerpetualsApi.constants.moduleNames.interface, "start_session"),
                 typeArguments: [collateralCoinType],
                 arguments: [
                     tx.sharedObjectRef({
@@ -142,7 +140,7 @@ class PerpetualsApi {
         this.endSessionTx = (inputs) => {
             const { tx, collateralCoinType, sessionPotatoId } = inputs;
             return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.perpetuals.packages.perpetuals, PerpetualsApi.constants.moduleNames.interface, "end_session"),
+                target: utils_1.Helpers.transactions.createTxTarget(inputs.packageId, PerpetualsApi.constants.moduleNames.interface, "end_session"),
                 typeArguments: [collateralCoinType],
                 arguments: [
                     typeof sessionPotatoId === "string"
@@ -154,7 +152,7 @@ class PerpetualsApi {
         this.placeMarketOrderTx = (inputs) => {
             const { tx, collateralCoinType, sessionPotatoId, side, size } = inputs;
             return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.perpetuals.packages.perpetuals, PerpetualsApi.constants.moduleNames.interface, "place_market_order"),
+                target: utils_1.Helpers.transactions.createTxTarget(inputs.packageId, PerpetualsApi.constants.moduleNames.interface, "place_market_order"),
                 typeArguments: [collateralCoinType],
                 arguments: [
                     typeof sessionPotatoId === "string"
@@ -168,7 +166,7 @@ class PerpetualsApi {
         this.placeLimitOrderTx = (inputs) => {
             const { tx, collateralCoinType, sessionPotatoId, side, size, price, orderType, } = inputs;
             return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.perpetuals.packages.perpetuals, PerpetualsApi.constants.moduleNames.interface, "place_limit_order"),
+                target: utils_1.Helpers.transactions.createTxTarget(inputs.packageId, PerpetualsApi.constants.moduleNames.interface, "place_limit_order"),
                 typeArguments: [collateralCoinType],
                 arguments: [
                     typeof sessionPotatoId === "string"
@@ -184,7 +182,7 @@ class PerpetualsApi {
         this.cancelOrdersTx = (inputs) => {
             const { tx, collateralCoinType, accountCapId, marketId, orderIds } = inputs;
             return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.perpetuals.packages.perpetuals, PerpetualsApi.constants.moduleNames.interface, "cancel_orders"),
+                target: utils_1.Helpers.transactions.createTxTarget(inputs.packageId, PerpetualsApi.constants.moduleNames.interface, "cancel_orders"),
                 typeArguments: [collateralCoinType],
                 arguments: [
                     tx.sharedObjectRef({
@@ -197,6 +195,23 @@ class PerpetualsApi {
                 ],
             });
         };
+        this.reduceOrdersTx = (inputs) => {
+            const { tx, packageId, collateralCoinType, accountCapId, marketId, orderIds, sizesToSubtract, } = inputs;
+            return tx.moveCall({
+                target: utils_1.Helpers.transactions.createTxTarget(packageId, PerpetualsApi.constants.moduleNames.interface, "reduce_orders"),
+                typeArguments: [collateralCoinType],
+                arguments: [
+                    tx.sharedObjectRef({
+                        objectId: marketId,
+                        initialSharedVersion: inputs.marketInitialSharedVersion,
+                        mutable: true,
+                    }),
+                    tx.object(accountCapId),
+                    tx.pure(bcs_1.bcs.vector(bcs_1.bcs.u128()).serialize(orderIds)),
+                    tx.pure(bcs_1.bcs.vector(bcs_1.bcs.u64()).serialize(sizesToSubtract)),
+                ],
+            });
+        };
         this.withdrawCollateralTx = (inputs) => {
             const { tx, collateralCoinType, accountCapId, amount } = inputs;
             return tx.moveCall({
@@ -250,7 +265,7 @@ class PerpetualsApi {
         // 	const { tx, collateralCoinType, sessionPotatoId } = inputs;
         // 	return tx.moveCall({
         // 		target: Helpers.transactions.createTxTarget(
-        // 			this.addresses.perpetuals.packages.perpetuals,
+        // 			inputs.packageId,
         // 			PerpetualsApi.constants.moduleNames.clearingHouse,
         // 			"get_hot_potato_fields"
         // 		),
@@ -311,7 +326,7 @@ class PerpetualsApi {
         this.getPositionTx = (inputs) => {
             const { tx, marketId, collateralCoinType } = inputs;
             return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.perpetuals.packages.perpetuals, PerpetualsApi.constants.moduleNames.clearingHouse, "get_position"),
+                target: utils_1.Helpers.transactions.createTxTarget(inputs.packageId, PerpetualsApi.constants.moduleNames.clearingHouse, "get_position"),
                 typeArguments: [collateralCoinType],
                 arguments: [
                     tx.sharedObjectRef({
@@ -326,7 +341,7 @@ class PerpetualsApi {
         this.getOrderbookTx = (inputs) => {
             const { tx, collateralCoinType } = inputs;
             return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.perpetuals.packages.perpetuals, PerpetualsApi.constants.moduleNames.clearingHouse, "get_orderbook"),
+                target: utils_1.Helpers.transactions.createTxTarget(inputs.packageId, PerpetualsApi.constants.moduleNames.clearingHouse, "get_orderbook"),
                 typeArguments: [collateralCoinType],
                 arguments: [tx.object(inputs.marketId)],
             });
@@ -334,7 +349,7 @@ class PerpetualsApi {
         this.getBookPriceTx = (inputs) => {
             const { tx, marketId, collateralCoinType } = inputs;
             return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.perpetuals.packages.perpetuals, PerpetualsApi.constants.moduleNames.clearingHouse, "get_book_price"),
+                target: utils_1.Helpers.transactions.createTxTarget(inputs.packageId, PerpetualsApi.constants.moduleNames.clearingHouse, "get_book_price"),
                 typeArguments: [collateralCoinType],
                 arguments: [
                     tx.object(marketId),
@@ -349,7 +364,7 @@ class PerpetualsApi {
         this.getBestPriceTx = (inputs) => {
             const { tx, marketId, collateralCoinType } = inputs;
             return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.perpetuals.packages.perpetuals, PerpetualsApi.constants.moduleNames.clearingHouse, "get_best_price"),
+                target: utils_1.Helpers.transactions.createTxTarget(inputs.packageId, PerpetualsApi.constants.moduleNames.clearingHouse, "get_best_price"),
                 typeArguments: [collateralCoinType],
                 arguments: [
                     tx.sharedObjectRef({
@@ -364,7 +379,7 @@ class PerpetualsApi {
         this.inspectOrdersTx = (inputs) => {
             const { tx, orderbookId } = inputs;
             return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.perpetuals.packages.perpetuals, PerpetualsApi.constants.moduleNames.orderbook, "inspect_orders"),
+                target: utils_1.Helpers.transactions.createTxTarget(inputs.packageId, PerpetualsApi.constants.moduleNames.orderbook, "inspect_orders"),
                 typeArguments: [],
                 arguments: [
                     typeof orderbookId === "string"
@@ -379,7 +394,7 @@ class PerpetualsApi {
         this.getOrderSizeTx = (inputs) => {
             const { tx, orderbookId } = inputs;
             return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.perpetuals.packages.perpetuals, PerpetualsApi.constants.moduleNames.orderbook, "get_order_size"),
+                target: utils_1.Helpers.transactions.createTxTarget(inputs.packageId, PerpetualsApi.constants.moduleNames.orderbook, "get_order_size"),
                 typeArguments: [],
                 arguments: [
                     typeof orderbookId === "string"
@@ -407,13 +422,14 @@ class PerpetualsApi {
             return tx;
         });
         this.buildCancelOrderTx = (inputs) => {
-            const { orderId, marketId, marketInitialSharedVersion, collateral, basePriceFeedId, collateralPriceFeedId } = inputs, otherInputs = __rest(inputs, ["orderId", "marketId", "marketInitialSharedVersion", "collateral", "basePriceFeedId", "collateralPriceFeedId"]);
+            const { packageId, orderId, marketId, marketInitialSharedVersion, collateralChange, basePriceFeedId, collateralPriceFeedId } = inputs, otherInputs = __rest(inputs, ["packageId", "orderId", "marketId", "marketInitialSharedVersion", "collateralChange", "basePriceFeedId", "collateralPriceFeedId"]);
             return this.buildCancelOrdersTx(Object.assign(Object.assign({}, otherInputs), { orderDatas: [
                     {
+                        packageId,
                         orderId,
                         marketId,
                         marketInitialSharedVersion,
-                        collateral,
+                        collateralChange,
                         basePriceFeedId,
                         collateralPriceFeedId,
                     },
@@ -435,25 +451,44 @@ class PerpetualsApi {
                 if (orders.length <= 0)
                     continue;
                 const marketInitialSharedVersion = orders[0].marketInitialSharedVersion;
+                const packageId = orders[0].packageId;
                 this.cancelOrdersTx({
                     tx,
                     collateralCoinType,
                     accountCapId,
                     marketId,
                     marketInitialSharedVersion,
+                    packageId,
                     orderIds: orders.map((order) => order.orderId),
                 });
-                // TODO: handle deallocating too much ?
-                this.deallocateCollateralTx({
-                    tx,
-                    accountCapId,
-                    collateralCoinType,
-                    marketId,
-                    marketInitialSharedVersion,
-                    amount: utils_1.Helpers.sumBigInt(orders.map((order) => order.collateral)),
-                    basePriceFeedId: orders[0].basePriceFeedId,
-                    collateralPriceFeedId: orders[0].collateralPriceFeedId,
-                });
+                const netCollateralChange = utils_1.Helpers.sumBigInt(orders.map((order) => order.collateralChange));
+                if (netCollateralChange < BigInt(0)) {
+                    this.deallocateCollateralTx({
+                        tx,
+                        accountCapId,
+                        collateralCoinType,
+                        marketId,
+                        marketInitialSharedVersion,
+                        packageId,
+                        amount: utils_1.Helpers.absBigInt(netCollateralChange),
+                        basePriceFeedId: orders[0].basePriceFeedId,
+                        collateralPriceFeedId: orders[0].collateralPriceFeedId,
+                    });
+                }
+                else if (netCollateralChange > BigInt(0)) {
+                    this.allocateCollateralTx({
+                        tx,
+                        accountCapId,
+                        collateralCoinType,
+                        marketId,
+                        marketInitialSharedVersion,
+                        packageId,
+                        amount: netCollateralChange,
+                    });
+                }
+                else {
+                    // no collateral change
+                }
             }
             return tx;
         };
@@ -499,17 +534,441 @@ class PerpetualsApi {
             });
             return tx;
         };
-        // TODO: add to sdk
         this.buildAllocateCollateralTx = transactionsApiHelpers_1.TransactionsApiHelpers.createBuildTxFunc(this.allocateCollateralTx);
-        // TODO: add to sdk
         this.buildDeallocateCollateralTx = transactionsApiHelpers_1.TransactionsApiHelpers.createBuildTxFunc(this.deallocateCollateralTx);
+        this.buildReduceOrdersTx = (inputs) => {
+            const { walletAddress, collateralChange, accountCapId, collateralCoinType, marketId, marketInitialSharedVersion, packageId, basePriceFeedId, collateralPriceFeedId, orderIds, sizesToSubtract, } = inputs;
+            const tx = new transactions_1.Transaction();
+            tx.setSender(walletAddress);
+            this.reduceOrdersTx({
+                tx,
+                packageId,
+                collateralCoinType,
+                accountCapId,
+                marketId,
+                marketInitialSharedVersion,
+                orderIds,
+                sizesToSubtract,
+            });
+            if (collateralChange < BigInt(0)) {
+                this.deallocateCollateralTx({
+                    tx,
+                    accountCapId,
+                    collateralCoinType,
+                    marketId,
+                    marketInitialSharedVersion,
+                    packageId,
+                    basePriceFeedId,
+                    collateralPriceFeedId,
+                    amount: utils_1.Helpers.absBigInt(collateralChange),
+                });
+            }
+            else if (collateralChange > BigInt(0)) {
+                this.allocateCollateralTx({
+                    tx,
+                    accountCapId,
+                    collateralCoinType,
+                    marketId,
+                    marketInitialSharedVersion,
+                    packageId,
+                    amount: collateralChange,
+                });
+            }
+            else {
+                // no collateral change
+            }
+            return tx;
+        };
         // =========================================================================
         //  Helpers
         // =========================================================================
         this.getAccountCapType = (inputs) => {
-            return `${this.addresses.perpetuals.packages.perpetuals}::${PerpetualsApi.constants.moduleNames.account}::Account<${inputs.collateralCoinType}>`;
+            return `${this.addresses.perpetuals.packages.events}::${PerpetualsApi.constants.moduleNames.account}::Account<${inputs.collateralCoinType}>`;
         };
         // =========================================================================
+        //  Private Helpers
+        // =========================================================================
+        // private fetchOrdersSizes = async (inputs: {
+        // 	orderIds: PerpetualsOrderId[];
+        // 	collateralCoinType: ObjectId;
+        // 	marketId: PerpetualsMarketId;
+        // }): Promise<bigint[]> => {
+        // 	const { orderIds, marketId, collateralCoinType } = inputs;
+        // 	if (orderIds.length <= 0) return [];
+        // 	const tx = new Transaction();
+        // 	const orderbookId = this.getOrderbookTx({
+        // 		tx,
+        // 		collateralCoinType,
+        // 		marketId,
+        // 	});
+        // 	for (const orderId of orderIds) {
+        // 		this.getOrderSizeTx({
+        // 			tx,
+        // 			orderId,
+        // 			orderbookId,
+        // 		});
+        // 	}
+        // 	const { allBytes } =
+        // 		await this.Provider.Inspections().fetchAllBytesFromTx({
+        // 			tx,
+        // 		});
+        // 	const sizes = allBytes
+        // 		.slice(1)
+        // 		.map((bytes) => Casting.bigIntFromBytes(bytes[0]));
+        // 	return sizes;
+        // };
+        // private fetchOrderbookOrders = async (inputs: {
+        // 	collateralCoinType: ObjectId;
+        // 	marketId: PerpetualsMarketId;
+        // 	side: PerpetualsOrderSide;
+        // 	fromPrice: PerpetualsOrderPrice;
+        // 	toPrice: PerpetualsOrderPrice;
+        // }): Promise<PerpetualsOrderInfo[]> => {
+        // 	const { collateralCoinType, marketId, side, fromPrice, toPrice } =
+        // 		inputs;
+        // 	const tx = new Transaction();
+        // 	const orderbookId = this.getOrderbookTx({
+        // 		tx,
+        // 		collateralCoinType,
+        // 		marketId,
+        // 	});
+        // 	this.inspectOrdersTx({ tx, orderbookId, side, fromPrice, toPrice });
+        // 	const bytes =
+        // 		await this.Provider.Inspections().fetchFirstBytesFromTxOutput({
+        // 			tx,
+        // 		});
+        // 	const orderInfos: any[] = bcs
+        // 		.vector(perpetualsRegistry.OrderInfo)
+        // 		.parse(new Uint8Array(bytes));
+        // 	return orderInfos.map((orderInfo) =>
+        // 		Casting.perpetuals.orderInfoFromRaw(orderInfo)
+        // 	);
+        // };
+        // public fetchExecutionPrice = async (
+        // 	inputs: ApiPerpetualsExecutionPriceBody & {
+        // 		collateralCoinType: CoinType;
+        // 		marketId: PerpetualsMarketId;
+        // 	}
+        // ): Promise<ApiPerpetualsExecutionPriceResponse> => {
+        // 	const {
+        // 		// collateral,
+        // 		collateralCoinType,
+        // 		marketId,
+        // 		side,
+        // 		size,
+        // 		price,
+        // 		lotSize,
+        // 		basePriceFeedId,
+        // 		collateralPriceFeedId,
+        // 	} = inputs;
+        // 	// TODO: change this
+        // 	const collateral = BigInt(1000000000000000);
+        // 	// const accountCapId = perpetualsBcsRegistry
+        // 	// 	.ser(`Account<${collateralCoinType}>`, {
+        // 	// 		id: {
+        // 	// 			id: {
+        // 	// 				bytes: "0x0000000000000000000000000000000000000000000000000000000000000321",
+        // 	// 			},
+        // 	// 		},
+        // 	// 		accountId: 0,
+        // 	// 		collateral,
+        // 	// 	})
+        // 	// 	.toBytes();
+        // const depositCoinBytes = perpetualsRegistry.Coin.serialize({
+        // 	id: "0x0000000000000000000000000000000000000000000000000000000000000123",
+        // 	balance: {
+        // 		value: BigInt(1000000000000000),
+        // 	},
+        // }).toBytes();
+        // 	const walletAddress = InspectionsApiHelpers.constants.devInspectSigner;
+        // 	const tx = new Transaction();
+        // 	tx.setSender(walletAddress);
+        // 	const accountCapId = this.createAccountTx({
+        // 		...inputs,
+        // 		tx,
+        // 	});
+        // 	this.depositCollateralTx({
+        // 		tx,
+        // 		collateralCoinType,
+        // 		accountCapId,
+        // 		coinBytes: depositCoinBytes,
+        // 	});
+        // 	const { sessionPotatoId } = this.createTxAndStartSession({
+        // 		tx,
+        // 		accountCapId,
+        // 		collateralCoinType,
+        // 		marketId,
+        // 		walletAddress,
+        // 		basePriceFeedId,
+        // 		collateralPriceFeedId,
+        // 		collateralChange: collateral,
+        // 		hasPosition: false,
+        // 	});
+        // 	this.placeLimitOrderTx({
+        // 		tx,
+        // 		side,
+        // 		size,
+        // 		collateralCoinType,
+        // 		sessionPotatoId,
+        // 		orderType: PerpetualsOrderType.Standard,
+        // 		price:
+        // 			price ??
+        // 			(side === PerpetualsOrderSide.Bid
+        // 				? BigInt("0x7FFFFFFFFFFFFFFF") // 2^63 - 1
+        // 				: BigInt(1)),
+        // 	});
+        // 	this.getHotPotatoFieldsTx({
+        // 		tx,
+        // 		collateralCoinType,
+        // 		sessionPotatoId,
+        // 	});
+        // 	this.endSessionAndTransferAccount({
+        // 		...inputs,
+        // 		tx,
+        // 		sessionPotatoId,
+        // 		walletAddress,
+        // 		collateralChange: BigInt(0),
+        // 	});
+        // 	const { events } =
+        // 		await this.Provider.Inspections().fetchAllBytesFromTx({
+        // 			tx,
+        // 		});
+        // 	const filledTakerEvent = EventsApiHelpers.findCastEventOrUndefined({
+        // 		events,
+        // 		eventType: this.eventTypes.filledTakerOrder,
+        // 		castFunction: Casting.perpetuals.filledTakerOrderEventFromOnChain,
+        // 	});
+        // 	const sizeNum = lotSize * Math.abs(Number(size));
+        // 	if (!filledTakerEvent) {
+        // 		return {
+        // 			executionPrice: 0,
+        // 			sizeFilled: 0,
+        // 			sizePosted: sizeNum,
+        // 			fills: [],
+        // 		};
+        // 	}
+        // 	const filledOrderEvents =
+        // 		Aftermath.helpers.events.findCastEventsOrUndefined({
+        // 			events,
+        // 			eventType: this.eventTypes.filledTakerOrder,
+        // 			castFunction:
+        // 				Casting.perpetuals.filledTakerOrderEventFromOnChain,
+        // 		});
+        // 	const fills: PerpetualsFilledOrderData[] = filledOrderEvents.map(
+        // 		(event) => {
+        // 			const size = Math.abs(
+        // 				Casting.IFixed.numberFromIFixed(event.baseAssetDelta)
+        // 			);
+        // 			const sizeUsd = Math.abs(
+        // 				Casting.IFixed.numberFromIFixed(event.quoteAssetDelta)
+        // 			);
+        // 			const price = sizeUsd / size;
+        // 			return {
+        // 				size,
+        // 				price,
+        // 			};
+        // 		}
+        // 	);
+        // 	const executionPrice = Perpetuals.calcEntryPrice(filledTakerEvent);
+        // 	const sizeFilled = Math.abs(
+        // 		Casting.IFixed.numberFromIFixed(filledTakerEvent.baseAssetDelta)
+        // 	);
+        // 	const sizePosted = sizeNum - sizeFilled;
+        // 	return {
+        // 		executionPrice,
+        // 		sizeFilled,
+        // 		sizePosted,
+        // 		fills,
+        // 	};
+        // 	// const { fillReceipts, postReceipt } =
+        // 	// 	await this.fetchMarketOrderReceipts(inputs);
+        // 	// const sizePosted = postReceipt !== undefined ? postReceipt.size : 0;
+        // 	// if (fillReceipts.length <= 0)
+        // 	// 	return price !== undefined
+        // 	// 		? // simulating limit order
+        // 	// 		  {
+        // 	// 				executionPrice: Perpetuals.orderPriceToPrice({
+        // 	// 					orderPrice: price,
+        // 	// 					lotSize,
+        // 	// 					tickSize,
+        // 	// 				}),
+        // 	// 				sizeFilled: 0,
+        // 	// 				sizePosted: Number(sizePosted),
+        // 	// 		  }
+        // 	// 		: // simulating market order
+        // 	// 		  {
+        // 	// 				executionPrice: 0,
+        // 	// 				sizeFilled: 0,
+        // 	// 				sizePosted: 0,
+        // 	// 		  };
+        // 	// const sizeFilled = Helpers.sumBigInt(
+        // 	// 	fillReceipts.map((receipt) => receipt.size)
+        // 	// );
+        // 	// const executionPrice = fillReceipts.reduce((acc, receipt) => {
+        // 	// 	const orderPrice = PerpetualsOrderUtils.price(
+        // 	// 		receipt.orderId,
+        // 	// 		inputs.side === PerpetualsOrderSide.Ask
+        // 	// 			? PerpetualsOrderSide.Bid
+        // 	// 			: PerpetualsOrderSide.Ask
+        // 	// 	);
+        // 	// 	const orderPriceNum = Perpetuals.orderPriceToPrice({
+        // 	// 		orderPrice,
+        // 	// 		lotSize,
+        // 	// 		tickSize,
+        // 	// 	});
+        // 	// 	return (
+        // 	// 		acc +
+        // 	// 		orderPriceNum * (Number(receipt.size) / Number(sizeFilled))
+        // 	// 	);
+        // 	// }, 0);
+        // 	// return {
+        // 	// 	executionPrice,
+        // 	// 	sizeFilled: Number(sizeFilled),
+        // 	// 	sizePosted: Number(sizePosted),
+        // 	// };
+        // };
+        // private createTxAndStartSession = (inputs: {
+        // 	tx?: Transaction;
+        // 	collateralCoinType: CoinType;
+        // 	accountCapId: ObjectId | TransactionArgument;
+        // 	marketId: PerpetualsMarketId;
+        // 	marketInitialSharedVersion: ObjectVersion;
+        // 	basePriceFeedId: ObjectId;
+        // 	collateralPriceFeedId: ObjectId;
+        // 	walletAddress: SuiAddress;
+        // 	collateralChange: Balance;
+        // 	hasPosition: boolean;
+        // }) => {
+        // 	const { collateralChange, walletAddress, hasPosition } = inputs;
+        // 	const { tx: inputsTx, ...nonTxInputs } = inputs;
+        // 	const tx = inputsTx ?? new Transaction();
+        // 	tx.setSender(walletAddress);
+        // 	if (!hasPosition) {
+        // 		this.createMarketPositionTx({
+        // 			...nonTxInputs,
+        // 			tx,
+        // 		});
+        // 	}
+        // 	if (collateralChange > BigInt(0)) {
+        // 		this.allocateCollateralTx({
+        // 			...nonTxInputs,
+        // 			tx,
+        // 			amount: collateralChange,
+        // 		});
+        // 	}
+        // 	const sessionPotatoId = this.startSessionTx({
+        // 		...nonTxInputs,
+        // 		tx,
+        // 	});
+        // 	return { tx, sessionPotatoId };
+        // };
+        // private endSessionAndShareMarket = (inputs: {
+        // 	tx: Transaction;
+        // 	collateralCoinType: CoinType;
+        // 	sessionPotatoId: ObjectId | TransactionArgument;
+        // }) => {
+        // 	const marketId = this.endSessionTx(inputs);
+        // 	this.shareClearingHouseTx({
+        // 		...inputs,
+        // 		marketId,
+        // 	});
+        // };
+        // =========================================================================
+        //  Public Static Helpers
+        // =========================================================================
+        // public static bucketOrders = (inputs: {
+        // 	orders: PerpetualsOrderInfo[];
+        // 	side: PerpetualsOrderSide;
+        // 	lotSize: number;
+        // 	tickSize: number;
+        // 	priceBucketSize: number;
+        // 	initialBucketedOrders?: OrderbookDataPoint[];
+        // }): OrderbookDataPoint[] => {
+        // 	const {
+        // 		orders,
+        // 		side,
+        // 		lotSize,
+        // 		tickSize,
+        // 		priceBucketSize,
+        // 		initialBucketedOrders,
+        // 	} = inputs;
+        // 	let dataPoints: OrderbookDataPoint[] = initialBucketedOrders ?? [];
+        // 	const roundPrice = (price: number, bucketSize: number): number => {
+        // 		return Math.round(price / bucketSize) * bucketSize;
+        // 	};
+        // 	const comparePrices = (
+        // 		price1: number,
+        // 		price2: number,
+        // 		bucketSize: number
+        // 	): boolean => {
+        // 		return Math.abs(price1 - price2) < bucketSize;
+        // 	};
+        // 	orders.forEach((order) => {
+        // 		const actualPrice = Perpetuals.orderPriceToPrice({
+        // 			lotSize,
+        // 			tickSize: Math.abs(tickSize),
+        // 			orderPrice: order.price,
+        // 		});
+        // 		const roundedPrice = roundPrice(actualPrice, priceBucketSize);
+        // 		const size =
+        // 			lotSize *
+        // 			Math.abs(Number(order.size)) *
+        // 			(tickSize < 0 ? -1 : 1);
+        // 		const sizeUsd = size * actualPrice;
+        // 		const placementIndex = dataPoints.findIndex(
+        // 			(dataPoint: OrderbookDataPoint) =>
+        // 				comparePrices(
+        // 					roundedPrice,
+        // 					dataPoint.price,
+        // 					priceBucketSize
+        // 				)
+        // 		);
+        // 		if (placementIndex < 0) {
+        // 			if (size > 0) {
+        // 				const newDataPoint: OrderbookDataPoint = {
+        // 					size,
+        // 					sizeUsd,
+        // 					totalSize: size,
+        // 					totalSizeUsd: sizeUsd,
+        // 					price: roundedPrice,
+        // 				};
+        // 				const insertIndex = dataPoints.findIndex((dataPoint) =>
+        // 					side === PerpetualsOrderSide.Ask
+        // 						? roundedPrice < dataPoint.price
+        // 						: roundedPrice > dataPoint.price
+        // 				);
+        // 				if (insertIndex < 0) {
+        // 					dataPoints.push(newDataPoint);
+        // 				} else {
+        // 					dataPoints.splice(insertIndex, 0, newDataPoint);
+        // 				}
+        // 			}
+        // 		} else {
+        // 			dataPoints[placementIndex].size += size;
+        // 			dataPoints[placementIndex].sizeUsd += sizeUsd;
+        // 			dataPoints[placementIndex].totalSize += size;
+        // 			dataPoints[placementIndex].totalSizeUsd += sizeUsd;
+        // 		}
+        // 	});
+        // 	dataPoints = dataPoints.filter((data) => data.size >= lotSize);
+        // 	for (let index = 0; index < dataPoints.length; index++) {
+        // 		if (index > 0) {
+        // 			dataPoints[index].totalSize =
+        // 				dataPoints[index - 1].totalSize + dataPoints[index].size;
+        // 			dataPoints[index].totalSizeUsd =
+        // 				dataPoints[index - 1].totalSizeUsd +
+        // 				dataPoints[index].sizeUsd;
+        // 		} else {
+        // 			dataPoints[index].totalSize = dataPoints[index].size;
+        // 			dataPoints[index].totalSizeUsd = dataPoints[index].sizeUsd;
+        // 		}
+        // 	}
+        // 	if (side === PerpetualsOrderSide.Ask) {
+        // 		dataPoints.reverse();
+        // 	}
+        // 	return dataPoints;
+        // };
+        // =========================================================================
         //  Event Types
         // =========================================================================
         this.eventType = (eventName) => eventsApiHelpers_1.EventsApiHelpers.createEventType(this.addresses.perpetuals.packages.events, PerpetualsApi.constants.moduleNames.events, eventName);
@@ -530,6 +989,7 @@ class PerpetualsApi {
             deallocatedCollateral: this.eventType("DeallocatedCollateral"),
             // Liquidation
             liquidated: this.eventType("LiquidatedPosition"),
+            filledTakerOrderLiquidator: this.eventType("FilledTakerOrderLiquidator"),
             // Account
             createdAccount: this.eventType("CreatedAccount"),
             // Order
@@ -537,11 +997,16 @@ class PerpetualsApi {
             postedOrder: this.eventType("PostedOrder"),
             filledMakerOrder: this.eventType("FilledMakerOrder"),
             filledTakerOrder: this.eventType("FilledTakerOrder"),
+            reducedOrder: this.eventType("ReducedOrder"),
             // Order Receipts
             postedOrderReceipt: this.eventType("OrderbookPostReceipt"),
             // Twap
             updatedPremiumTwap: this.eventType("UpdatedPremiumTwap"),
             updatedSpreadTwap: this.eventType("UpdatedSpreadTwap"),
+            // Funding
+            updatedFunding: this.eventType("UpdatedFunding"),
+            // Version
+            updatedMarketVersion: this.eventType("UpdatedClearingHouseVersion"),
         };
         this.moveErrors = {
             [this.addresses.perpetuals.packages.perpetuals]: {
@@ -642,69 +1107,3 @@ PerpetualsApi.constants = {
         account: "account",
     },
 };
-// =========================================================================
-//  Public Static Helpers
-// =========================================================================
-PerpetualsApi.bucketOrders = (inputs) => {
-    const { orders, side, lotSize, tickSize, priceBucketSize, initialBucketedOrders, } = inputs;
-    let dataPoints = initialBucketedOrders !== null && initialBucketedOrders !== void 0 ? initialBucketedOrders : [];
-    const roundPrice = (price, bucketSize) => {
-        return Math.round(price / bucketSize) * bucketSize;
-    };
-    const comparePrices = (price1, price2, bucketSize) => {
-        return Math.abs(price1 - price2) < bucketSize / 2;
-    };
-    orders.forEach((order) => {
-        const actualPrice = perpetuals_1.Perpetuals.orderPriceToPrice({
-            lotSize,
-            tickSize: Math.abs(tickSize),
-            orderPrice: order.price,
-        });
-        const roundedPrice = roundPrice(actualPrice, priceBucketSize);
-        const size = lotSize * Number(order.size) * (tickSize < 0 ? -1 : 1);
-        const sizeUsd = size * actualPrice;
-        const placementIndex = dataPoints.findIndex((dataPoint) => comparePrices(roundedPrice, dataPoint.price, priceBucketSize));
-        if (placementIndex < 0) {
-            const newDataPoint = {
-                size,
-                sizeUsd,
-                totalSize: size,
-                totalSizeUsd: sizeUsd,
-                price: roundedPrice,
-            };
-            const insertIndex = dataPoints.findIndex((dataPoint) => side === perpetualsTypes_1.PerpetualsOrderSide.Ask
-                ? roundedPrice <= dataPoint.price
-                : roundedPrice >= dataPoint.price);
-            if (insertIndex < 0) {
-                dataPoints.push(newDataPoint);
-            }
-            else {
-                dataPoints.splice(insertIndex, 0, newDataPoint);
-            }
-        }
-        else {
-            dataPoints[placementIndex].size += size;
-            dataPoints[placementIndex].sizeUsd += sizeUsd;
-            dataPoints[placementIndex].totalSize += size;
-            dataPoints[placementIndex].totalSizeUsd += sizeUsd;
-        }
-    });
-    dataPoints = dataPoints.filter((data) => data.size > 0 && data.sizeUsd > 0);
-    for (let index = 0; index < dataPoints.length; index++) {
-        if (index > 0) {
-            dataPoints[index].totalSize =
-                dataPoints[index - 1].totalSize + dataPoints[index].size;
-            dataPoints[index].totalSizeUsd =
-                dataPoints[index - 1].totalSizeUsd +
-                    dataPoints[index].sizeUsd;
-        }
-        else {
-            dataPoints[index].totalSize = dataPoints[index].size;
-            dataPoints[index].totalSizeUsd = dataPoints[index].sizeUsd;
-        }
-    }
-    if (side === perpetualsTypes_1.PerpetualsOrderSide.Ask) {
-        dataPoints.reverse();
-    }
-    return dataPoints;
-};