aftermath-ts-sdk 1.1.76 → 1.1.77

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

@@ -68,64 +68,73 @@ class PerpetualsApi {
             return utils_1.Casting.perpetuals.accountObjectFromIndexerResponse(response, inputs.collateralCoinType);
         });
         this.fetchAccountOrderDatas = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const { accountId, orderDatas } = inputs;
-            const orderReceiptEvents = yield this.Provider.indexerCaller.fetchIndexer(`perpetuals/accounts/${accountId}/orders`, undefined, {
-                order_ids: orderDatas.map((order) => String(order.orderId).replaceAll("n", "")),
-            });
-            if (orderReceiptEvents.length !== orderDatas.length)
+            const { accountCapId, orderDatas } = inputs;
+            const orders = yield this.Provider.indexerCaller.fetchIndexer(`perpetuals/accounts/orders`, {
+                account_id: utils_1.Helpers.addLeadingZeroesToType(accountCapId),
+                order_ids: orderDatas.map((orderData) => String(orderData.orderId).replaceAll("n", "")),
+            }, undefined, undefined, undefined, true);
+            if (orders.length !== orderDatas.length)
                 throw new Error("unable to find all orders");
-            return orderReceiptEvents.map((event, index) => {
-                const _a = utils_1.Casting.perpetuals.postedOrderReceiptEventFromOnChain(event), { size: initialSize } = _a, castEvent = __rest(_a, ["size"]);
-                const orderData = orderDatas.find((orderData) => orderData.orderId === castEvent.orderId);
+            return orders.map((order) => {
+                const orderId = BigInt(order.order_id);
+                const initialSize = BigInt(order.initial_size);
+                const orderData = orderDatas.find((orderData) => orderData.orderId === orderId);
                 if (!orderData)
                     throw new Error("unable to find all orders");
-                return Object.assign(Object.assign({}, castEvent), { side: perpetuals_1.Perpetuals.orderIdToSide(castEvent.orderId), filledSize: initialSize - orderData.currentSize, initialSize });
-            });
-        });
-        this.fetchSubscribeToAllEvents = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const { onEvent } = inputs;
-            const unsubscribe = yield this.Provider.provider.subscribeEvent({
-                // filter: {
-                // 	MoveModule: {
-                // 		module: PerpetualsApi.constants.moduleNames.events,
-                // 		package: this.addresses.perpetuals.packages.perpetuals,
-                // 	},
-                // },
-                // filter: {
-                // 	MoveEventModule: {
-                // 		module: PerpetualsApi.constants.moduleNames.events,
-                // 		package: this.addresses.perpetuals.packages.events,
-                // 	},
-                // },
-                filter: {
-                    MoveEventModule: {
-                        module: "interface",
-                        package: this.addresses.perpetuals.packages.events,
-                    },
-                },
-                onMessage: onEvent,
+                return {
+                    marketId: utils_1.Helpers.addLeadingZeroesToType(order.ch_id),
+                    side: perpetuals_1.Perpetuals.orderIdToSide(orderId),
+                    filledSize: initialSize - orderData.currentSize,
+                    initialSize,
+                    orderId,
+                };
             });
-            return unsubscribe;
         });
         this.fetchHistoricalMarketData = (inputs) => __awaiter(this, void 0, void 0, function* () {
             const { marketId, fromTimestamp, toTimestamp, intervalMs } = inputs;
-            const [prices, volumes] = (yield Promise.all([
-                this.Provider.indexerCaller.fetchIndexer(`perpetuals/markets/${marketId}/historical-price`, undefined, {
-                    from: fromTimestamp,
-                    to: toTimestamp,
-                    interval: intervalMs,
-                }),
-                this.Provider.indexerCaller.fetchIndexer(`perpetuals/markets/${marketId}/historical-volume`, undefined, {
-                    from: fromTimestamp,
-                    to: toTimestamp,
-                    interval: intervalMs,
-                }),
-            ]));
-            return { prices, volumes };
+            const response = yield this.Provider.indexerCaller.fetchIndexer(`perpetuals/markets/candle-history`, {
+                ch_id: utils_1.Helpers.addLeadingZeroesToType(marketId),
+                timestamp_ms_from: fromTimestamp,
+                timestamp_ms_to: toTimestamp,
+                resolution_ms: intervalMs,
+            }, undefined, undefined, undefined, true);
+            return response.map((data) => ({
+                timestamp: data.timestamp_ms,
+                open: data.open,
+                close: data.close,
+                high: data.high,
+                low: data.low,
+                volume: data.volume,
+            }));
         });
         // =========================================================================
         //  Inspections
         // =========================================================================
+        this.setPositionLeverage = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            return this.Provider.indexerCaller.fetchIndexer(`perpetuals/account/set-position-leverage`, {
+                wallet_address: utils_1.Helpers.addLeadingZeroesToType(inputs.walletAddress),
+                signature: inputs.signature,
+                bytes: inputs.bytes,
+            }, undefined, undefined, undefined, true);
+        });
+        this.fetchAllPositionLeverages = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            return (yield this.Provider.indexerCaller.fetchIndexer(`perpetuals/accounts/${inputs.accountId}/position-leverages`, undefined, undefined, undefined, undefined, true)).map((data) => ({
+                marketId: data.market_id,
+                leverage: data.leverage,
+            }));
+        });
+        this.fetchPositionLeverages = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            const marketIds = inputs.marketIds.map((objectId) => utils_1.Helpers.addLeadingZeroesToType(objectId));
+            const leverages = yield this.Provider.indexerCaller.fetchIndexer(`perpetuals/accounts/${inputs.accountId}/position-leverages`, undefined, {
+                market_ids: marketIds,
+            }, undefined, undefined, true);
+            return marketIds.map((objectId) => {
+                var _a;
+                return ((_a = leverages.find((leverage) => leverage.market_id === objectId)) !== null && _a !== void 0 ? _a : {
+                    leverage: 1,
+                }).leverage;
+            });
+        });
         this.fetchPreviewOrder = (
         // TODO: remove unused inputs
         inputs) => __awaiter(this, void 0, void 0, function* () {
@@ -160,6 +169,7 @@ class PerpetualsApi {
                     position: response.position,
                     collateralCoinType: inputs.collateralCoinType,
                     marketId: inputs.marketId,
+                    leverage,
                 });
                 return {
                     postedSize,
@@ -873,207 +883,6 @@ class PerpetualsApi {
                 .parse(new Uint8Array(bytes));
             return orderInfos.map((orderInfo) => utils_1.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),
-        // 	// };
-        // };
-        this.createTxAndStartSession = (inputs) => {
-            const { collateralChange, walletAddress, hasPosition } = inputs;
-            const { tx: inputsTx } = inputs, nonTxInputs = __rest(inputs, ["tx"]);
-            const tx = inputsTx !== null && inputsTx !== void 0 ? inputsTx : new transactions_1.Transaction();
-            tx.setSender(walletAddress);
-            if (!hasPosition) {
-                this.createMarketPositionTx(Object.assign(Object.assign({}, nonTxInputs), { tx }));
-            }
-            if (collateralChange > BigInt(0)) {
-                this.allocateCollateralTx(Object.assign(Object.assign({}, nonTxInputs), { tx, amount: collateralChange }));
-            }
-            const sessionPotatoId = this.startSessionTx(Object.assign(Object.assign({}, nonTxInputs), { tx }));
-            return { tx, sessionPotatoId };
-        };
-        this.endSessionAndShareMarket = (inputs) => {
-            const marketId = this.endSessionTx(inputs);
-            this.shareClearingHouseTx(Object.assign(Object.assign({}, inputs), { marketId }));
-        };
         // =========================================================================
         //  Event Types
         // =========================================================================
@@ -1210,83 +1019,92 @@ class PerpetualsApi {
     // =========================================================================
     //  Events
     // =========================================================================
-    fetchAccountCollateralEvents(inputs) {
+    fetchAccountCollateralHistory(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { accountId, cursor, limit } = inputs;
-            return this.Provider.indexerCaller.fetchIndexerEvents(`perpetuals/accounts/${accountId}/events/collateral`, {
-                cursor,
-                limit,
-            }, (event) => {
-                const eventType = event.type;
-                return eventType === this.eventTypes.withdrewCollateral
-                    ? utils_1.Casting.perpetuals.withdrewCollateralEventFromOnChain(event)
-                    : eventType === this.eventTypes.depositedCollateral
-                        ? utils_1.Casting.perpetuals.depositedCollateralEventFromOnChain(event)
-                        : eventType === this.eventTypes.settledFunding
-                            ? utils_1.Casting.perpetuals.settledFundingEventFromOnChain(event)
-                            : eventType === this.eventTypes.allocatedCollateral
-                                ? utils_1.Casting.perpetuals.allocatedCollateralEventFromOnChain(event)
-                                : eventType === this.eventTypes.deallocatedCollateral
-                                    ? utils_1.Casting.perpetuals.deallocatedCollateralEventFromOnChain(event)
-                                    : eventType === this.eventTypes.liquidated
-                                        ? utils_1.Casting.perpetuals.liquidatedEventFromOnChain(event)
-                                        : eventType === this.eventTypes.filledMakerOrder
-                                            ? utils_1.Casting.perpetuals.filledMakerOrderEventFromOnChain(event)
-                                            : utils_1.Casting.perpetuals.filledTakerOrderEventFromOnChain(event);
-            });
-            // // set collateral delta based off of previous event
-            // for (const [index, event] of eventsData.events.entries()) {
-            // 	if (index >= eventsData.events.length - 1) {
-            // 		eventsData.events[index].collateralDelta = event.collateral;
-            // 		continue;
-            // 	}
-            // 	const previousEvent = eventsData.events[index + 1];
-            // 	eventsData.events[index].collateralDelta =
-            // 		Casting.IFixed.iFixedFromNumber(
-            // 			Math.abs(
-            // 				Casting.IFixed.numberFromIFixed(event.collateral)
-            // 			) -
-            // 				Math.abs(
-            // 					Casting.IFixed.numberFromIFixed(
-            // 						previousEvent.collateral
-            // 					)
-            // 				)
-            // 		);
-            // }
-            // // if more events exist then remove last event since unable to calculate collateral delta
-            // if (cursor !== undefined) {
-            // 	eventsData.events = eventsData.events.slice(0, -1);
-            // }
-            // return eventsData;
+            const { accountCapId, cursor, limit } = inputs;
+            const response = yield this.Provider.indexerCaller.fetchIndexer(`perpetuals/accounts/collateral-history`, {
+                account_id: utils_1.Helpers.addLeadingZeroesToType(accountCapId),
+                timestamp_before_ms: cursor !== null && cursor !== void 0 ? cursor : new Date().valueOf(),
+                limit: limit !== null && limit !== void 0 ? limit : PerpetualsApi.constants.defaultLimitStepSize,
+            }, undefined, undefined, undefined, true);
+            const collateralChanges = response.map((data) => (Object.assign({ eventName: data.event_type, timestamp: data.timestamp, txDigest: data.tx_digest }, (data.event_type === "Deposit" ||
+                data.event_type === "Withdraw" ||
+                data.event_type === "Allocate" ||
+                data.event_type === "Deallocate"
+                ? {
+                    collateralChange: BigInt(data.collateral_change),
+                }
+                : {
+                    collateralChangeUsd: Number(data.collateral_change_usd),
+                }))));
+            return {
+                collateralChanges,
+                // TODO: move `nextCursor` finding pattern to helper ?
+                nextCursor: collateralChanges.length > 0
+                    ? collateralChanges[collateralChanges.length - 1].timestamp
+                    : undefined,
+            };
         });
     }
-    fetchAccountOrderEvents(inputs) {
+    fetchAccountOrderHistory(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { accountId, cursor, limit } = inputs;
-            return this.Provider.indexerCaller.fetchIndexerEvents(`perpetuals/accounts/${accountId}/events/order`, {
-                cursor,
-                limit,
-            }, (event) => {
-                const eventType = event.type;
-                return eventType === this.eventTypes.canceledOrder
-                    ? utils_1.Casting.perpetuals.canceledOrderEventFromOnChain(event)
-                    : eventType === this.eventTypes.postedOrderReceipt
-                        ? utils_1.Casting.perpetuals.postedOrderReceiptEventFromOnChain(event)
-                        : eventType === this.eventTypes.liquidated
-                            ? utils_1.Casting.perpetuals.liquidatedEventFromOnChain(event)
-                            : eventType === this.eventTypes.filledMakerOrder
-                                ? utils_1.Casting.perpetuals.filledMakerOrderEventFromOnChain(event)
-                                : utils_1.Casting.perpetuals.filledTakerOrderEventFromOnChain(event);
-            });
+            const { accountCapId, cursor, limit } = inputs;
+            const response = yield this.Provider.indexerCaller.fetchIndexer(`perpetuals/accounts/trade-history`, {
+                account_id: utils_1.Helpers.addLeadingZeroesToType(accountCapId),
+                timestamp_before_ms: cursor !== null && cursor !== void 0 ? cursor : new Date().valueOf(),
+                limit: limit !== null && limit !== void 0 ? limit : PerpetualsApi.constants.defaultLimitStepSize,
+            }, undefined, undefined, undefined, true);
+            const trades = response.map((data) => (Object.assign(Object.assign({ eventName: data.event_type, timestamp: data.timestamp, txDigest: data.tx_digest, marketId: utils_1.Helpers.addLeadingZeroesToType(data.ch_id), side: data.is_ask
+                    ? perpetualsTypes_1.PerpetualsOrderSide.Ask
+                    : perpetualsTypes_1.PerpetualsOrderSide.Bid }, (data.event_type === "Canceled" ||
+                data.event_type === "Posted" ||
+                data.event_type === "FilledMaker"
+                ? {
+                    sizeLots: BigInt(data.size),
+                }
+                : {
+                    size: Number(data.size),
+                })), (data.event_type === "Canceled" ||
+                data.event_type === "Posted" ||
+                data.event_type === "FilledMaker"
+                ? {
+                    orderPrice: BigInt(data.price),
+                }
+                : {
+                    price: Number(data.price),
+                }))));
+            return {
+                trades,
+                // TODO: move `nextCursor` finding pattern to helper ?
+                nextCursor: trades.length > 0
+                    ? trades[trades.length - 1].timestamp
+                    : undefined,
+            };
         });
     }
-    fetchMarketFilledOrderEvents(inputs) {
+    fetchMarketTradeHistory(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
             const { marketId, cursor, limit } = inputs;
-            return this.Provider.indexerCaller.fetchIndexerEvents(`perpetuals/markets/${marketId}/events/filled-order`, {
-                cursor,
-                limit,
-            }, (event) => utils_1.Casting.perpetuals.filledTakerOrderEventFromOnChain(event));
+            const response = yield this.Provider.indexerCaller.fetchIndexer(`perpetuals/markets/trade-history`, {
+                ch_id: utils_1.Helpers.addLeadingZeroesToType(marketId),
+                timestamp_before_ms: cursor !== null && cursor !== void 0 ? cursor : new Date().valueOf(),
+                limit: limit !== null && limit !== void 0 ? limit : PerpetualsApi.constants.defaultLimitStepSize,
+            }, undefined, undefined, undefined, true);
+            const trades = response.map((data) => ({
+                timestamp: data.timestamp,
+                txDigest: data.tx_digest,
+                side: data.is_ask
+                    ? perpetualsTypes_1.PerpetualsOrderSide.Ask
+                    : perpetualsTypes_1.PerpetualsOrderSide.Bid,
+                sizeFilled: data.size_filled,
+                orderPrice: data.order_price,
+            }));
+            return {
+                trades,
+                nextCursor: trades.length > 0
+                    ? trades[trades.length - 1].timestamp
+                    : undefined,
+            };
         });
     }
     // =========================================================================
@@ -1295,15 +1113,10 @@ class PerpetualsApi {
     fetchMarket24hrVolume(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
             const { marketId } = inputs;
-            const response = yield this.Provider.indexerCaller.fetchIndexer(`perpetuals/markets/${marketId}/24hr-volume`);
-            if (response.length === 0)
-                return {
-                    volumeUsd: 0,
-                    volumeBaseAssetAmount: 0,
-                };
+            const response = yield this.Provider.indexerCaller.fetchIndexer(`perpetuals/markets/${marketId}/24hr-volume`, undefined, undefined, undefined, undefined, true);
             return {
-                volumeUsd: response[0].volumeUsd,
-                volumeBaseAssetAmount: response[0].volume,
+                volumeBaseAssetAmount: response.market_volume,
+                volumeUsd: response.market_volume_usd,
             };
         });
     }
@@ -1333,69 +1146,297 @@ PerpetualsApi.constants = {
         clearingHouse: "clearing_house",
         account: "account",
     },
+    defaultLimitStepSize: 256,
 };
+// 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
 // =========================================================================
 PerpetualsApi.bucketOrders = (inputs) => {
     const { orders, side, lotSize, tickSize, priceBucketSize, initialBucketedOrders, } = inputs;
-    let dataPoints = orders.reduce((acc, order) => {
+    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 = Math.round(actualPrice / priceBucketSize) * priceBucketSize;
-        // negative tick size means order filled
+        const roundedPrice = roundPrice(actualPrice, priceBucketSize);
         const size = lotSize * Number(order.size) * (tickSize < 0 ? -1 : 1);
         const sizeUsd = size * actualPrice;
-        const placementIndex = acc.findIndex((dataPoint) => side === perpetualsTypes_1.PerpetualsOrderSide.Ask
-            ? roundedPrice <= dataPoint.price &&
-                roundedPrice > dataPoint.price - priceBucketSize
-            : roundedPrice >= dataPoint.price &&
-                roundedPrice < dataPoint.price + priceBucketSize);
+        const placementIndex = dataPoints.findIndex((dataPoint) => comparePrices(roundedPrice, dataPoint.price, priceBucketSize));
         if (placementIndex < 0) {
-            // no bucket exists; create bucket
-            const insertIndex = acc.findIndex((dataPoint) => side === perpetualsTypes_1.PerpetualsOrderSide.Ask
-                ? roundedPrice <= dataPoint.price
-                : roundedPrice >= dataPoint.price);
             const newDataPoint = {
                 size,
                 sizeUsd,
-                totalSize: 0,
-                totalSizeUsd: 0,
+                totalSize: size,
+                totalSizeUsd: sizeUsd,
                 price: roundedPrice,
             };
-            if (insertIndex === 0) {
-                return [newDataPoint, ...acc];
-            }
-            else if (insertIndex < 0) {
-                return [...acc, newDataPoint];
+            const insertIndex = dataPoints.findIndex((dataPoint) => side === perpetualsTypes_1.PerpetualsOrderSide.Ask
+                ? roundedPrice <= dataPoint.price
+                : roundedPrice >= dataPoint.price);
+            if (insertIndex < 0) {
+                dataPoints.push(newDataPoint);
             }
             else {
-                return [
-                    ...acc.slice(0, insertIndex),
-                    newDataPoint,
-                    ...acc.slice(insertIndex + 1),
-                ];
+                dataPoints.splice(insertIndex, 0, newDataPoint);
             }
         }
         else {
-            // bucket found
-            const newAcc = Array.from(acc);
-            newAcc[placementIndex] = Object.assign(Object.assign({}, newAcc[placementIndex]), { size: newAcc[placementIndex].size + size, totalSize: newAcc[placementIndex].totalSize + size, sizeUsd: newAcc[placementIndex].sizeUsd + sizeUsd, totalSizeUsd: newAcc[placementIndex].totalSizeUsd + sizeUsd });
-            return newAcc;
+            dataPoints[placementIndex].size += size;
+            dataPoints[placementIndex].sizeUsd += sizeUsd;
+            dataPoints[placementIndex].totalSize += size;
+            dataPoints[placementIndex].totalSizeUsd += sizeUsd;
         }
-    }, initialBucketedOrders !== null && initialBucketedOrders !== void 0 ? initialBucketedOrders : []);
-    // remove 0 size buckets
+    });
     dataPoints = dataPoints.filter((data) => data.size > 0 && data.sizeUsd > 0);
-    // compute total sizes
-    for (const [index, data] of dataPoints.entries()) {
-        dataPoints[index] = Object.assign(Object.assign({}, data), { totalSize: index > 0
-                ? dataPoints[index - 1].totalSize + data.size
-                : data.size, totalSizeUsd: index > 0
-                ? dataPoints[index - 1].totalSizeUsd + data.sizeUsd
-                : data.sizeUsd });
+    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();