@orderly.network/hooks 1.2.0 → 1.3.2

package/lib/orderly/useOrderEntry.js

@@ -1,64 +1,75 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useOrderEntry = void 0;
-const react_1 = require("react");
-const types_1 = require("@orderly.network/types");
-const useSymbolsInfo_1 = require("./useSymbolsInfo");
-const utils_1 = require("@orderly.network/utils");
-const useMutation_1 = require("../useMutation");
-const ramda_1 = require("ramda");
-const orderEntryHelper_1 = require("../utils/orderEntryHelper");
-const useCollateral_1 = require("./useCollateral");
-const useMaxQty_1 = require("./useMaxQty");
-const createOrder_1 = require("../utils/createOrder");
-const useMarkPrice_1 = require("./useMarkPrice");
-const perp_1 = require("@orderly.network/perp");
-const useEventEmitter_1 = require("../useEventEmitter");
-const use_debounce_1 = require("use-debounce");
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useOrderEntry", {
+    enumerable: true,
+    get: function() {
+        return useOrderEntry;
+    }
+});
+const _react = require("react");
+const _types = require("@orderly.network/types");
+const _useSymbolsInfo = require("./useSymbolsInfo");
+const _utils = require("@orderly.network/utils");
+const _useMutation = require("../useMutation");
+const _ramda = require("ramda");
+const _orderEntryHelper = require("../utils/orderEntryHelper");
+const _useCollateral = require("./useCollateral");
+const _useMaxQty = require("./useMaxQty");
+const _createOrder = require("../utils/createOrder");
+const _useMarkPrice = require("./useMarkPrice");
+const _perp = require("@orderly.network/perp");
+const _useEventEmitter = require("../useEventEmitter");
+const _usedebounce = require("use-debounce");
 function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
     // if symbolOrOrder is string, then it's deprecated
     let isNewVersion = false;
     if (typeof symbolOrOrder === "object") {
         isNewVersion = true;
         if (!symbolOrOrder.symbol) {
-            throw new types_1.SDKError("symbol is required");
+            throw new _types.SDKError("symbol is required");
         }
         if (!symbolOrOrder.side) {
-            throw new types_1.SDKError("Order side is required");
+            throw new _types.SDKError("Order side is required");
         }
         if (!symbolOrOrder.order_type) {
-            throw new types_1.SDKError("order_type is required");
+            throw new _types.SDKError("order_type is required");
         }
     }
-    const prevOrderData = (0, react_1.useRef)(null);
+    const prevOrderData = (0, _react.useRef)(null);
     // Cache data from the last calculate
-    const orderDataCache = (0, react_1.useRef)(null);
+    const orderDataCache = (0, _react.useRef)(null);
     //
-    const notSupportData = (0, react_1.useRef)({});
-    const [errors, setErrors] = (0, react_1.useState)(null);
-    const ee = (0, useEventEmitter_1.useEventEmitter)();
-    const fieldDirty = (0, react_1.useRef)({});
-    const submitted = (0, react_1.useRef)(false);
-    const askAndBid = (0, react_1.useRef)([]); // 0: ask0, 1: bid0
-    const onOrderbookUpdate = (0, use_debounce_1.useDebouncedCallback)((data) => {
+    const notSupportData = (0, _react.useRef)({});
+    const [errors, setErrors] = (0, _react.useState)(null);
+    const ee = (0, _useEventEmitter.useEventEmitter)();
+    const fieldDirty = (0, _react.useRef)({});
+    const submitted = (0, _react.useRef)(false);
+    const askAndBid = (0, _react.useRef)([]); // 0: ask0, 1: bid0
+    const onOrderbookUpdate = (0, _usedebounce.useDebouncedCallback)((data)=>{
         askAndBid.current = data;
     }, 200);
-    const { freeCollateral, totalCollateral, positions, accountInfo } = (0, useCollateral_1.useCollateral)();
-    const symbolInfo = (0, useSymbolsInfo_1.useSymbolsInfo)();
+    const { freeCollateral, totalCollateral, positions, accountInfo } = (0, _useCollateral.useCollateral)();
+    const symbolInfo = (0, _useSymbolsInfo.useSymbolsInfo)();
     // const tokenInfo = useTokenInfo();
-    const symbol = (0, react_1.useMemo)(() => {
+    const symbol = (0, _react.useMemo)(()=>{
         if (typeof symbolOrOrder === "string") {
             return symbolOrOrder;
         }
         return symbolOrOrder.symbol;
-    }, [symbolOrOrder]);
-    const optionsValue = (0, react_1.useMemo)(() => {
+    }, [
+        symbolOrOrder
+    ]);
+    const optionsValue = (0, _react.useMemo)(()=>{
         if (typeof sideOrOptions === "object") {
             return sideOrOptions;
         }
         return options;
-    }, [sideOrOptions]);
-    const isReduceOnly = (0, react_1.useMemo)(() => {
+    }, [
+        sideOrOptions
+    ]);
+    const isReduceOnly = (0, _react.useMemo)(()=>{
         if (typeof reduceOnly === "boolean") {
             return reduceOnly;
         }
@@ -66,35 +77,46 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
             return !!symbolOrOrder.reduce_only;
         }
         return false;
-    }, [symbolOrOrder, reduceOnly]);
-    const sideValue = (0, react_1.useMemo)(() => {
+    }, [
+        symbolOrOrder,
+        reduceOnly
+    ]);
+    const sideValue = (0, _react.useMemo)(()=>{
         if (typeof symbolOrOrder === "object") {
             return symbolOrOrder.side;
         }
         // if (typeof sideOrOptions === "string") {
         return sideOrOptions;
-        // }
-    }, [symbolOrOrder, sideOrOptions]);
-    const baseDP = (0, react_1.useMemo)(() => (0, utils_1.getPrecisionByNumber)(symbolInfo[symbol]("base_tick", 0)), [symbolInfo]);
-    const quoteDP = (0, react_1.useMemo)(() => {
-        return (0, utils_1.getPrecisionByNumber)(symbolInfo[symbol]("quote_tick", 0));
-    }, [symbolInfo]);
-    const baseIMR = (0, react_1.useMemo)(() => symbolInfo[symbol]("base_imr", 0), [symbolInfo]);
-    const baseMMR = (0, react_1.useMemo)(() => symbolInfo[symbol]("base_mmr", 0), [symbolInfo]);
-    const { data: markPrice } = (0, useMarkPrice_1.useMarkPrice)(symbol);
+    // }
+    }, [
+        symbolOrOrder,
+        sideOrOptions
+    ]);
+    const baseDP = (0, _react.useMemo)(()=>(0, _utils.getPrecisionByNumber)(symbolInfo[symbol]("base_tick", 0)), [
+        symbolInfo
+    ]);
+    const quoteDP = (0, _react.useMemo)(()=>{
+        return (0, _utils.getPrecisionByNumber)(symbolInfo[symbol]("quote_tick", 0));
+    }, [
+        symbolInfo
+    ]);
+    const baseIMR = (0, _react.useMemo)(()=>symbolInfo[symbol]("base_imr", 0), [
+        symbolInfo
+    ]);
+    const baseMMR = (0, _react.useMemo)(()=>symbolInfo[symbol]("base_mmr", 0), [
+        symbolInfo
+    ]);
+    const { data: markPrice } = (0, _useMarkPrice.useMarkPrice)(symbol);
     // const markPrice = 1;
-    const diffOrderEntry = (prev, current) => {
-        if (!prev)
-            return null;
+    const diffOrderEntry = (prev, current)=>{
+        if (!prev) return null;
         let key, value, preValue;
         const keys = Object.keys(current);
-        for (let i = 0; i < keys.length; i++) {
+        for(let i = 0; i < keys.length; i++){
             const k = keys[i];
             let preveValue = prev[k];
             let currentValue = current[k];
-            if (typeof preveValue === "undefined" &&
-                typeof currentValue === "undefined")
-                continue;
+            if (typeof preveValue === "undefined" && typeof currentValue === "undefined") continue;
             // if (k === "order_quantity") {
             //   preveValue = Number(preveValue);
             //   currentValue = Number(currentValue);
@@ -106,14 +128,16 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
                 break;
             }
         }
-        if (!key)
-            return null;
-        return { key, value, preValue };
+        if (!key) return null;
+        return {
+            key,
+            value,
+            preValue
+        };
     };
-    const maxQty = (0, useMaxQty_1.useMaxQty)(symbol, sideValue, isReduceOnly);
-    const parseString2Number = (order, key) => {
-        if (typeof order[key] !== "string")
-            return;
+    const maxQty = (0, _useMaxQty.useMaxQty)(symbol, sideValue, isReduceOnly);
+    const parseString2Number = (order, key, dp)=>{
+        if (typeof order[key] !== "string") return;
         // fix: delete the comma then remove the forward one of the string
         // first find the difference between current value and previous value
         if (order[key] && order[key].startsWith(".")) {
@@ -121,13 +145,22 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
         }
         // order[`${key}_origin`] = order[key];
         order[key] = order[key].replace(/,/g, "");
+        // format input by decimal precision
+        if (dp && order[key].length > 0) {
+            const hasPoint = `${order[key]}`.includes(".");
+            const endOfPoint = `${order[key]}`.endsWith(".");
+            const decimalPart = `${order[key]}`.split(".");
+            if (hasPoint && !endOfPoint) {
+                order[key] = `${decimalPart[0]}.${decimalPart[1].slice(0, quoteDP)}`;
+            }
+        }
     };
     // just for performance optimization
-    const needParse = (0, react_1.useMemo)(() => {
+    const needParse = (0, _react.useMemo)(()=>{
         if (typeof symbolOrOrder === "string") {
             return null;
         }
-        return (0, ramda_1.pick)([
+        return (0, _ramda.pick)([
             "order_price",
             "side",
             "order_quantity",
@@ -137,32 +170,30 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
             "symbol",
             "total",
             "reduce_only",
-            "trigger_price",
-        ])(
-        //@ts-ignore
+            "trigger_price"
+        ])(//@ts-ignore
         symbolOrOrder);
-    }, [symbolOrOrder]);
-    const parsedData = (0, react_1.useMemo)(() => {
+    }, [
+        symbolOrOrder
+    ]);
+    const parsedData = (0, _react.useMemo)(()=>{
         if (typeof symbolOrOrder === "string") {
             return null;
         }
         // clean comma
         if (typeof symbolOrOrder.order_quantity === "string") {
             parseString2Number(symbolOrOrder, "order_quantity");
-        }
-        else if (typeof symbolOrOrder.order_quantity === "number") {
-            symbolOrOrder.order_quantity = new utils_1.Decimal(symbolOrOrder.order_quantity)
-                .toDecimalPlaces(baseDP)
-                .toString();
+        } else if (typeof symbolOrOrder.order_quantity === "number") {
+            symbolOrOrder.order_quantity = new _utils.Decimal(symbolOrOrder.order_quantity).toDecimalPlaces(baseDP).toString();
         }
         if (typeof symbolOrOrder.order_price === "string") {
-            parseString2Number(symbolOrOrder, "order_price");
+            parseString2Number(symbolOrOrder, "order_price", quoteDP);
         }
         if (typeof symbolOrOrder.total === "string") {
-            parseString2Number(symbolOrOrder, "total");
+            parseString2Number(symbolOrOrder, "total", quoteDP);
         }
         if (typeof symbolOrOrder.trigger_price === "string") {
-            parseString2Number(symbolOrOrder, "trigger_price");
+            parseString2Number(symbolOrOrder, "trigger_price", quoteDP);
         }
         // if (typeof symbolOrOrder.trigger_price === "string") {
         //   symbolOrOrder.trigger_price = symbolOrOrder.trigger_price.replace(
@@ -182,72 +213,67 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
         needParse?.reduce_only,
         needParse?.side,
         needParse?.visible_quantity,
+        quoteDP,
+        baseDP
     ]);
-    const isStopOrder = parsedData?.order_type === types_1.OrderType.STOP_LIMIT ||
-        parsedData?.order_type === types_1.OrderType.STOP_MARKET;
-    const [doCreateOrder, { isMutating }] = (0, useMutation_1.useMutation)(isStopOrder ? "/v1/algo/order" : "/v1/order");
+    const isStopOrder = parsedData?.order_type === _types.OrderType.STOP_LIMIT || parsedData?.order_type === _types.OrderType.STOP_MARKET;
+    const [doCreateOrder, { isMutating }] = (0, _useMutation.useMutation)(isStopOrder ? "/v1/algo/order" : "/v1/order");
     // const maxQty = 3;
-    const createOrder = (values) => {
+    const createOrder = (values)=>{
         if (!values.symbol) {
-            throw new types_1.SDKError("symbol is error");
+            throw new _types.SDKError("symbol is error");
         }
         if (!values.side) {
-            throw new types_1.SDKError("side is error");
+            throw new _types.SDKError("side is error");
         }
-        if (!values ||
-            typeof values.order_type === "undefined" ||
-            !(0, ramda_1.includes)(values.order_type, createOrder_1.availableOrderTypes)) {
-            throw new types_1.SDKError("order_type is error");
+        if (!values || typeof values.order_type === "undefined" || !(0, _ramda.includes)(values.order_type, _createOrder.availableOrderTypes)) {
+            throw new _types.SDKError("order_type is error");
         }
-        const orderCreator = createOrder_1.OrderFactory.create(values.order_type_ext ? values.order_type_ext : values.order_type);
+        const orderCreator = _createOrder.OrderFactory.create(values.order_type_ext ? values.order_type_ext : values.order_type);
         if (!orderCreator) {
-            return Promise.reject(new types_1.SDKError("orderCreator is null"));
+            return Promise.reject(new _types.SDKError("orderCreator is null"));
         }
-        return new Promise((resolve, reject) => {
-            return orderCreator
-                .validate(values, {
+        return new Promise((resolve, reject)=>{
+            return orderCreator.validate(values, {
                 symbol: symbolInfo[symbol](),
                 // token: tokenInfo[symbol](),
                 maxQty,
-                markPrice: markPrice,
-            })
-                .then((errors) => {
+                markPrice: markPrice
+            }).then((errors)=>{
                 submitted.current = true;
-                if (errors.order_price ||
-                    errors.order_quantity ||
-                    errors.trigger_price) {
+                if (errors.order_price || errors.order_quantity || errors.trigger_price || errors.total) {
                     setErrors(errors);
                     reject(errors.order_price?.message || errors.order_quantity?.message);
-                    // throw new SDKError(
-                    //   errors.order_price?.message ||
-                    //     errors.order_quantity?.message ||
-                    //     "order validation error"
-                    // );
-                }
-                else {
+                // throw new SDKError(
+                //   errors.order_price?.message ||
+                //     errors.order_quantity?.message ||
+                //     "order validation error"
+                // );
+                } else {
                     const data = orderCreator.create(values, {
                         symbol: symbolInfo[symbol](),
                         maxQty,
-                        markPrice: markPrice,
+                        markPrice: markPrice
                     });
                     // console.log("------------------", values, data);
-                    return doCreateOrder((0, ramda_1.omit)(["order_type_ext"], {
+                    return doCreateOrder((0, _ramda.omit)([
+                        "order_type_ext"
+                    ], {
                         // ...values,
                         // ...omit(["order_price"], values),
-                        ...data,
-                    })).then((res) => {
+                        ...data
+                    })).then((res)=>{
                         // resolve(res);
                         if (res.success) {
                             // TODO: remove when the WS service is fixed
                             if (Array.isArray(res.data.rows)) {
                                 ee.emit("algoOrder:cache", {
                                     ...res.data.rows[0],
-                                    trigger_price: data.trigger_price,
+                                    trigger_price: data.trigger_price
                                 });
                             }
                             resolve(res.data);
-                        }
-                        else {
+                        } else {
                             reject(res);
                         }
                     }, reject);
@@ -256,41 +282,53 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
         });
     };
     /**
-     * submit form，validate values
-     * @param values
-     * @returns
-     */
-    const onSubmit = (values) => {
+   * submit form，validate values
+   * @param values
+   * @returns
+   */ const onSubmit = (values)=>{
         if (typeof reduceOnly === "boolean" && reduceOnly && !values.reduce_only) {
-            return Promise.reject(new types_1.SDKError("The reduceOny parameter of hook does not match your order data"));
+            return Promise.reject(new _types.SDKError("The reduceOny parameter of hook does not match your order data"));
         }
         return createOrder({
             ...values,
-            symbol,
+            symbol
         });
     };
-    const submit = (0, react_1.useCallback)(() => {
+    const submit = (0, _react.useCallback)(()=>{
         if (!parsedData) {
-            throw new types_1.SDKError("Function is not supported, please use onSubmit()");
+            throw new _types.SDKError("Function is not supported, please use onSubmit()");
         }
         return createOrder(parsedData);
-    }, [parsedData]);
-    const calculate = (0, react_1.useCallback)((values, field, value) => {
-        const fieldHandler = (0, orderEntryHelper_1.getCalculateHandler)(field);
-        const newValues = (0, ramda_1.compose)(ramda_1.head, (0, orderEntryHelper_1.orderEntityFormatHandle)(baseDP, quoteDP), fieldHandler, orderEntryHelper_1.baseInputHandle)([values, field, value, markPrice, { baseDP, quoteDP }]);
+    }, [
+        parsedData
+    ]);
+    const calculate = (0, _react.useCallback)((values, field, value)=>{
+        const fieldHandler = (0, _orderEntryHelper.getCalculateHandler)(field);
+        const newValues = (0, _ramda.compose)(_ramda.head, (0, _orderEntryHelper.orderEntityFormatHandle)(baseDP, quoteDP), fieldHandler, _orderEntryHelper.baseInputHandle)([
+            values,
+            field,
+            value,
+            markPrice,
+            {
+                baseDP,
+                quoteDP
+            }
+        ]);
         return newValues;
-    }, [markPrice]);
+    }, [
+        markPrice
+    ]);
     // const estLiqPrice = useMemo(() => {}, []);
-    const validator = (values) => {
-        const creator = createOrder_1.OrderFactory.create(values.order_type);
+    const validator = (values)=>{
+        const creator = _createOrder.OrderFactory.create(values.order_type);
         return creator?.validate(values, {
             symbol: symbolInfo[symbol](),
             // token: tokenInfo[symbol](),
             maxQty,
-            markPrice: markPrice,
+            markPrice: markPrice
         });
     };
-    const formattedOrder = (0, react_1.useMemo)(() => {
+    const formattedOrder = (0, _react.useMemo)(()=>{
         if (!parsedData) {
             return notSupportData.current;
         }
@@ -303,7 +341,7 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
             prevOrderData.current = parsedData;
             orderDataCache.current = {
                 ...parsedData,
-                total: "",
+                total: ""
             };
             return orderDataCache.current;
         }
@@ -327,121 +365,114 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
         prevOrderData.current = parsedData;
         orderDataCache.current = values;
         return values;
-    }, [parsedData, markPrice]);
+    }, [
+        parsedData,
+        markPrice
+    ]);
     /// validator order info
-    (0, react_1.useEffect)(() => {
-        if (!markPrice || symbolInfo.isNil)
-            return;
+    (0, _react.useEffect)(()=>{
+        if (!markPrice || symbolInfo.isNil) return;
         // validate order data;
-        validator(formattedOrder)
-            ?.then((err) => {
+        validator(formattedOrder)?.then((err)=>{
             setErrors(err);
-        })
-            .catch((err) => { });
+        }).catch((err)=>{});
     }, [
         formattedOrder.broker_id,
         formattedOrder.order_quantity,
         formattedOrder.total,
         formattedOrder.trigger_price,
         formattedOrder.order_type,
-        markPrice,
+        markPrice
     ]);
     //====== update orderbook ask0/bid0 ======
-    (0, react_1.useEffect)(() => {
+    (0, _react.useEffect)(()=>{
         if (isNewVersion) {
             if (!optionsValue?.watchOrderbook) {
-                throw new types_1.SDKError("In order to calculate the estimated liquidation price, the `options.watchOrderbook` parameter must be set to true.");
+                throw new _types.SDKError("In order to calculate the estimated liquidation price, the `options.watchOrderbook` parameter must be set to true.");
             }
-        }
-        else {
+        } else {
             if (!optionsValue?.watchOrderbook) {
                 return;
             }
         }
         ee.on("orderbook:update", onOrderbookUpdate);
-        return () => {
+        return ()=>{
             ee.off("orderbook:update", onOrderbookUpdate);
         };
-    }, [optionsValue?.watchOrderbook]);
-    (0, react_1.useEffect)(() => {
+    }, [
+        optionsValue?.watchOrderbook
+    ]);
+    (0, _react.useEffect)(()=>{
         askAndBid.current = [];
-    }, [parsedData?.symbol]);
+    }, [
+        parsedData?.symbol
+    ]);
     //====== end ======
-    const getPriceAndQty = (symbolOrOrder) => {
+    const getPriceAndQty = (symbolOrOrder)=>{
         let quantity = Number(symbolOrOrder.order_quantity);
         const orderPrice = Number(symbolOrOrder.order_price);
         if (isNaN(quantity) || quantity <= 0) {
             return null;
         }
         if (!!options?.watchOrderbook && askAndBid.current.length === 0) {
-            throw new types_1.SDKError("Please check if you are using the `useOrderbookStream` hook or if the orderBook has data.");
+            throw new _types.SDKError("Please check if you are using the `useOrderbookStream` hook or if the orderBook has data.");
         }
-        if ((symbolOrOrder.order_type === types_1.OrderType.LIMIT ||
-            symbolOrOrder.order_type === types_1.OrderType.STOP_LIMIT) &&
-            isNaN(orderPrice))
-            return null;
+        if ((symbolOrOrder.order_type === _types.OrderType.LIMIT || symbolOrOrder.order_type === _types.OrderType.STOP_LIMIT) && isNaN(orderPrice)) return null;
         /**
-         * price
-         * if order_type = market order,
-            order side = long, then order_price_i = ask0
-            order side = short, then order_price_i = bid0
-          if order_type = limit order
-            order side = long
-              limit_price >= ask0, then order_price_i = ask0
-              limit_price < ask0, then order_price_i = limit_price
-            order side = short
-              limit_price <= bid0, then order_price_i = bid0
-              limit_price > ask0, then order_price_i = ask0
-         */
-        let price;
-        if (symbolOrOrder.order_type === types_1.OrderType.MARKET ||
-            symbolOrOrder.order_type === types_1.OrderType.STOP_MARKET) {
-            if (symbolOrOrder.side === types_1.OrderSide.BUY) {
+     * price
+     * if order_type = market order,
+        order side = long, then order_price_i = ask0
+        order side = short, then order_price_i = bid0
+      if order_type = limit order
+        order side = long
+          limit_price >= ask0, then order_price_i = ask0
+          limit_price < ask0, then order_price_i = limit_price
+        order side = short
+          limit_price <= bid0, then order_price_i = bid0
+          limit_price > ask0, then order_price_i = ask0
+     */ let price;
+        if (symbolOrOrder.order_type === _types.OrderType.MARKET || symbolOrOrder.order_type === _types.OrderType.STOP_MARKET) {
+            if (symbolOrOrder.side === _types.OrderSide.BUY) {
                 price = askAndBid.current[0];
-            }
-            else {
+            } else {
                 price = askAndBid.current[1];
             }
-        }
-        else {
+        } else {
             // LIMIT order
-            if (symbolOrOrder.side === types_1.OrderSide.BUY) {
+            if (symbolOrOrder.side === _types.OrderSide.BUY) {
                 if (orderPrice >= askAndBid.current[0]) {
                     price = askAndBid.current[0];
-                }
-                else {
+                } else {
                     price = orderPrice;
                 }
-            }
-            else {
+            } else {
                 if (orderPrice <= askAndBid.current[1]) {
                     price = askAndBid.current[1];
-                }
-                else {
+                } else {
                     price = orderPrice;
                 }
             }
         }
-        if (symbolOrOrder.side === types_1.OrderSide.SELL) {
+        if (symbolOrOrder.side === _types.OrderSide.SELL) {
             quantity = -quantity;
         }
-        return { price, quantity };
+        return {
+            price,
+            quantity
+        };
     };
-    const estLiqPrice = (0, react_1.useMemo)(() => {
-        if (!accountInfo || !parsedData || !markPrice)
-            return null;
+    const estLiqPrice = (0, _react.useMemo)(()=>{
+        if (!accountInfo || !parsedData || !markPrice) return null;
         const result = getPriceAndQty(formattedOrder);
-        if (result === null)
-            return null;
+        if (result === null) return null;
         const { price, quantity } = result;
-        if (!price || !quantity)
-            return null;
-        const orderFee = perp_1.order.orderFee({
+        if (!price || !quantity) return null;
+        const orderFee = _perp.order.orderFee({
             qty: quantity,
             price,
-            futuresTakeFeeRate: Number(accountInfo["futures_taker_fee_rate"]) / 10000,
+            futuresTakeFeeRate: Number(accountInfo["futures_taker_fee_rate"]) / 10000
         });
-        const liqPrice = perp_1.order.estLiqPrice({
+        const liqPrice = _perp.order.estLiqPrice({
             markPrice,
             baseIMR,
             baseMMR,
@@ -452,12 +483,11 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
             newOrder: {
                 qty: quantity,
                 price,
-                symbol: parsedData.symbol,
-            },
+                symbol: parsedData.symbol
+            }
         });
         // console.log("********", liqPrice, markPrice, totalCollateral, result);
-        if (liqPrice <= 0)
-            return null;
+        if (liqPrice <= 0) return null;
         return liqPrice;
     }, [
         markPrice,
@@ -468,22 +498,20 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
         formattedOrder?.order_quantity,
         formattedOrder?.total,
         formattedOrder?.trigger_price,
-        accountInfo,
+        accountInfo
     ]);
-    const estLeverage = (0, react_1.useMemo)(() => {
-        if (!accountInfo || !parsedData)
-            return null;
+    const estLeverage = (0, _react.useMemo)(()=>{
+        if (!accountInfo || !parsedData) return null;
         const result = getPriceAndQty(formattedOrder);
-        if (result === null || !result.price || !result.quantity)
-            return null;
-        const leverage = perp_1.order.estLeverage({
+        if (result === null || !result.price || !result.quantity) return null;
+        const leverage = _perp.order.estLeverage({
             totalCollateral,
             positions,
             newOrder: {
                 symbol: parsedData.symbol,
                 qty: result.quantity,
-                price: result.price,
-            },
+                price: result.price
+            }
         });
         return leverage;
     }, [
@@ -494,7 +522,7 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
         formattedOrder?.order_price,
         formattedOrder?.order_quantity,
         formattedOrder?.total,
-        formattedOrder?.trigger_price,
+        formattedOrder?.trigger_price
     ]);
     return {
         maxQty,
@@ -509,15 +537,15 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
         estLeverage,
         helper: {
             calculate,
-            validator,
-            // clearErrors,
+            validator
         },
         metaState: {
             dirty: fieldDirty.current,
             submitted: submitted.current,
-            errors,
+            errors
         },
-        symbolConfig: symbolInfo[symbol](),
+        symbolConfig: symbolInfo[symbol]()
     };
 }
-exports.useOrderEntry = useOrderEntry;
+
+//# sourceMappingURL=useOrderEntry.js.map