@orderly.network/hooks 1.5.13 → 2.0.0-alpha.0

package/lib/orderly/useOpenInterest.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/orderly/useOpenInterest.ts"],"sourcesContent":["import { useWS } from \"../useWS\";\nimport useSWRSubscription from \"swr/subscription\";\n\nexport const useOpenInterest = (symbol: string) => {\n  const ws = useWS();\n  return useSWRSubscription(`${symbol}@openinterest`, (key, { next }) => {\n    const unsubscribe = ws.subscribe(`${symbol}@openinterest`, {\n      onMessage: (message: any) => {\n        next(null, message.openInterest);\n      },\n    });\n\n    return () => {\n      unsubscribe?.();\n    };\n  });\n};\n"],"names":["useOpenInterest","symbol","ws","useWS","useSWRSubscription","key","next","unsubscribe","subscribe","onMessage","message","openInterest"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAGaA;;;eAAAA;;;uBAHS;qEACS;;;;;;AAExB,MAAMA,kBAAkB,CAACC;IAC9B,MAAMC,KAAKC,IAAAA,YAAK;IAChB,OAAOC,IAAAA,qBAAkB,EAAC,CAAC,EAAEH,OAAO,aAAa,CAAC,EAAE,CAACI,KAAK,EAAEC,IAAI,EAAE;QAChE,MAAMC,cAAcL,GAAGM,SAAS,CAAC,CAAC,EAAEP,OAAO,aAAa,CAAC,EAAE;YACzDQ,WAAW,CAACC;gBACVJ,KAAK,MAAMI,QAAQC,YAAY;YACjC;QACF;QAEA,OAAO;YACLJ;QACF;IACF;AACF"}

package/lib/orderly/useOrderEntry.d.ts

@@ -1,63 +0,0 @@
-import { API, OrderEntity, OrderSide } from "@orderly.network/types";
-export type UseOrderEntryOptions = {
-    commify?: boolean;
-    watchOrderbook?: boolean;
-    validate?: (data: OrderEntity) => {
-        [P in keyof OrderEntity]?: string;
-    } | null | undefined;
-};
-export type UseOrderEntryMetaState = {
-    errors: {
-        [P in keyof OrderEntity]?: {
-            type: string;
-            message: string;
-        };
-    } | null | undefined;
-    dirty: {
-        [P in keyof OrderEntity]?: boolean;
-    } | null | undefined;
-    submitted: boolean;
-};
-export type UseOrderEntryReturn = {
-    maxQty: number;
-    freeCollateral: number;
-    markPrice: number;
-    estLiqPrice?: number | null;
-    estLeverage?: number | null;
-    onSubmit: (order: OrderEntity) => Promise<any>;
-    submit: () => Promise<OrderEntity>;
-    submitting: boolean;
-    formattedOrder: Partial<OrderEntity>;
-    helper: {
-        calculate: (values: Partial<OrderEntity>, field: keyof OrderEntity, value: any) => Partial<OrderEntity>;
-        validator: (values: Partial<OrderEntity>) => any;
-    };
-    metaState: UseOrderEntryMetaState;
-    symbolConfig: API.SymbolExt;
-};
-export type OrderParams = Required<Pick<OrderEntity, "side" | "order_type" | "symbol">> & Partial<Omit<OrderEntity, "side" | "symbol" | "order_type">>;
-/**
- * Create Order
- * @example
- * ```tsx
- * import { useOrderEntry } from "@orderly.network/hooks";
- * import {OrderSide, OrderType} from '@orderly.network/types';
- *
- * const { formattedOrder, onSubmit, helper } = useOrderEntry({
- *  symbol: "PERP_ETH_USDC",
- *  side: OrderSide.BUY,
- *  order_type: OrderType.LIMIT,
- *  order_price: 10000,
- *  order_quantity: 1,
- * },{
- *  // **Note:** it's required
- *  watchOrderbook: true,
- * });
- * ```
- */
-export declare function useOrderEntry(order: OrderParams, options?: UseOrderEntryOptions): UseOrderEntryReturn;
-/**
- * @deprecated
- */
-export declare function useOrderEntry(symbol: string, side: OrderSide, reduceOnly: boolean): UseOrderEntryReturn;
-//# sourceMappingURL=useOrderEntry.d.ts.map

package/lib/orderly/useOrderEntry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useOrderEntry.d.ts","sourceRoot":"","sources":["../../src/orderly/useOrderEntry.ts"],"names":[],"mappings":"AACA,OAAO,EACL,GAAG,EACH,WAAW,EACX,SAAS,EAGV,MAAM,wBAAwB,CAAC;AAoBhC,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,EAAE,CACT,IAAI,EAAE,WAAW,KACd;SAAG,CAAC,IAAI,MAAM,WAAW,CAAC,CAAC,EAAE,MAAM;KAAE,GAAG,IAAI,GAAG,SAAS,CAAC;CAC/D,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EACF;SAAG,CAAC,IAAI,MAAM,WAAW,CAAC,CAAC,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAE;KAAE,GAChE,IAAI,GACJ,SAAS,CAAC;IACd,KAAK,EAAE;SAAG,CAAC,IAAI,MAAM,WAAW,CAAC,CAAC,EAAE,OAAO;KAAE,GAAG,IAAI,GAAG,SAAS,CAAC;IACjE,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAEhC,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5B,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IAC/C,MAAM,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAC;IAEnC,UAAU,EAAE,OAAO,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IACrC,MAAM,EAAE;QACN,SAAS,EAAE,CACT,MAAM,EAAE,OAAO,CAAC,WAAW,CAAC,EAC5B,KAAK,EAAE,MAAM,WAAW,EACxB,KAAK,EAAE,GAAG,KACP,OAAO,CAAC,WAAW,CAAC,CAAC;QAC1B,SAAS,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,WAAW,CAAC,KAAK,GAAG,CAAC;KAGlD,CAAC;IAEF,SAAS,EAAE,sBAAsB,CAAC;IAClC,YAAY,EAAE,GAAG,CAAC,SAAS,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,QAAQ,CAChC,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,YAAY,GAAG,QAAQ,CAAC,CACpD,GACC,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,QAAQ,GAAG,YAAY,CAAC,CAAC,CAAC;AAE/D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,WAAW,EAClB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,mBAAmB,CAAC;AACvB;;GAEG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,SAAS,EACf,UAAU,EAAE,OAAO,GAClB,mBAAmB,CAAC"}

package/lib/orderly/useOrderEntry.js

@@ -1,553 +0,0 @@
-"use strict";
-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 _useMarkPrice = require("./useMarkPrice");
-const _perp = require("@orderly.network/perp");
-const _useEventEmitter = require("../useEventEmitter");
-const _usedebounce = require("use-debounce");
-const _factory = require("../services/orderCreator/factory");
-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.SDKError("symbol is required");
-        }
-        if (!symbolOrOrder.side) {
-            throw new _types.SDKError("Order side is required");
-        }
-        if (!symbolOrOrder.order_type) {
-            throw new _types.SDKError("order_type is required");
-        }
-    }
-    const prevOrderData = (0, _react.useRef)(null);
-    // Cache data from the last calculate
-    const orderDataCache = (0, _react.useRef)(null);
-    //
-    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.useCollateral)();
-    const symbolInfo = (0, _useSymbolsInfo.useSymbolsInfo)();
-    // const tokenInfo = useTokenInfo();
-    const symbol = (0, _react.useMemo)(()=>{
-        if (typeof symbolOrOrder === "string") {
-            return symbolOrOrder;
-        }
-        return symbolOrOrder.symbol;
-    }, [
-        symbolOrOrder
-    ]);
-    const optionsValue = (0, _react.useMemo)(()=>{
-        if (typeof sideOrOptions === "object") {
-            return sideOrOptions;
-        }
-        return options;
-    }, [
-        sideOrOptions
-    ]);
-    const isReduceOnly = (0, _react.useMemo)(()=>{
-        if (typeof reduceOnly === "boolean") {
-            return reduceOnly;
-        }
-        if (typeof symbolOrOrder === "object") {
-            return !!symbolOrOrder.reduce_only;
-        }
-        return false;
-    }, [
-        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.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;
-        let key, value, preValue;
-        const keys = Object.keys(current);
-        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 (k === "order_quantity") {
-            //   preveValue = Number(preveValue);
-            //   currentValue = Number(currentValue);
-            // }
-            if (preveValue !== currentValue) {
-                key = k;
-                value = currentValue;
-                preValue = preveValue;
-                break;
-            }
-        }
-        if (!key) return null;
-        return {
-            key,
-            value,
-            preValue
-        };
-    };
-    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(".")) {
-            order[key] = `0${order[key]}`;
-        }
-        // 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.useMemo)(()=>{
-        if (typeof symbolOrOrder === "string") {
-            return null;
-        }
-        return (0, _ramda.pick)([
-            "order_price",
-            "side",
-            "order_quantity",
-            "visible_quantity",
-            "order_type",
-            "order_type_ext",
-            "symbol",
-            "total",
-            "reduce_only",
-            "trigger_price"
-        ])(//@ts-ignore
-        symbolOrOrder);
-    }, [
-        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.Decimal(symbolOrOrder.order_quantity).toDecimalPlaces(baseDP).toString();
-        }
-        if (typeof symbolOrOrder.order_price === "string") {
-            parseString2Number(symbolOrOrder, "order_price", quoteDP);
-        }
-        if (typeof symbolOrOrder.total === "string") {
-            parseString2Number(symbolOrOrder, "total", quoteDP);
-        }
-        if (typeof symbolOrOrder.trigger_price === "string") {
-            parseString2Number(symbolOrOrder, "trigger_price", quoteDP);
-        }
-        // if (typeof symbolOrOrder.trigger_price === "string") {
-        //   symbolOrOrder.trigger_price = symbolOrOrder.trigger_price.replace(
-        //     /,/g,
-        //     ""
-        //   );
-        // }
-        return symbolOrOrder;
-    }, [
-        needParse?.order_price,
-        needParse?.order_quantity,
-        needParse?.total,
-        needParse?.trigger_price,
-        needParse?.order_type,
-        needParse?.order_type_ext,
-        needParse?.symbol,
-        needParse?.reduce_only,
-        needParse?.side,
-        needParse?.visible_quantity,
-        quoteDP,
-        baseDP
-    ]);
-    const isAlgoOrder = parsedData?.order_type === _types.OrderType.STOP_LIMIT || parsedData?.order_type === _types.OrderType.STOP_MARKET || parsedData?.order_type === _types.OrderType.CLOSE_POSITION;
-    const [doCreateOrder, { isMutating }] = (0, _useMutation.useMutation)(isAlgoOrder ? "/v1/algo/order" : "/v1/order");
-    // const maxQty = 3;
-    const createOrder = (values)=>{
-        if (!values.symbol) {
-            throw new _types.SDKError("symbol is error");
-        }
-        if (!values.side) {
-            throw new _types.SDKError("side is error");
-        }
-        if (!values || typeof values.order_type === "undefined") {
-            throw new _types.SDKError("order_type is error");
-        }
-        const orderCreator = _factory.OrderFactory.create(// @ts-ignore
-        values.order_type_ext ? values.order_type_ext : values.order_type);
-        if (!orderCreator) {
-            return Promise.reject(new _types.SDKError("orderCreator is null"));
-        }
-        return new Promise((resolve, reject)=>{
-            return orderCreator.validate(values, {
-                symbol: symbolInfo[symbol](),
-                // token: tokenInfo[symbol](),
-                maxQty,
-                markPrice: markPrice
-            }).then((errors)=>{
-                submitted.current = true;
-                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 {
-                    const data = orderCreator.create(values, {
-                        symbol: symbolInfo[symbol](),
-                        maxQty,
-                        markPrice: markPrice
-                    });
-                    // console.log("------------------", values, data);
-                    return doCreateOrder((0, _ramda.omit)([
-                        "order_type_ext"
-                    ], {
-                        // ...values,
-                        // ...omit(["order_price"], values),
-                        ...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,
-                            //   });
-                            // }
-                            resolve(res.data);
-                        } else {
-                            reject(res);
-                        }
-                    }, reject);
-                }
-            });
-        });
-    };
-    /**
-   * submit form，validate values
-   * @param values
-   * @returns
-   */ const onSubmit = (values)=>{
-        if (typeof reduceOnly === "boolean" && reduceOnly && !values.reduce_only) {
-            return Promise.reject(new _types.SDKError("The reduceOny parameter of hook does not match your order data"));
-        }
-        return createOrder({
-            ...values,
-            symbol
-        });
-    };
-    const submit = (0, _react.useCallback)(()=>{
-        if (!parsedData) {
-            throw new _types.SDKError("Function is not supported, please use onSubmit()");
-        }
-        return createOrder(parsedData);
-    }, [
-        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
-    ]);
-    // const estLiqPrice = useMemo(() => {}, []);
-    const validator = (values)=>{
-        // @ts-ignore
-        const creator = _factory.OrderFactory.create(values.order_type);
-        return creator?.validate(values, {
-            symbol: symbolInfo[symbol](),
-            // token: tokenInfo[symbol](),
-            maxQty,
-            markPrice: markPrice
-        });
-    };
-    const formattedOrder = (0, _react.useMemo)(()=>{
-        if (!parsedData) {
-            return notSupportData.current;
-        }
-        // prevOrderData.current = symbolOrOrder;
-        if (!prevOrderData.current) {
-            // prevOrderData.current = {
-            //   ...symbolOrOrder,
-            //   total: "",
-            // };
-            prevOrderData.current = parsedData;
-            orderDataCache.current = {
-                ...parsedData,
-                total: ""
-            };
-            return orderDataCache.current;
-        }
-        // diff order entry
-        const item = diffOrderEntry(prevOrderData.current, parsedData);
-        // console.log(prevOrderData.current, symbolOrOrder, item);
-        // console.log(item);
-        if (!item) {
-            return orderDataCache.current;
-        }
-        // set field dirty
-        if (typeof parsedData.order_price !== "undefined") {
-            fieldDirty.current.order_price = true;
-        }
-        if (typeof parsedData.order_quantity !== "undefined") {
-            fieldDirty.current.order_quantity = true;
-        }
-        const values = calculate(parsedData, item.key, item.value);
-        values.isStopOrder = values.order_type?.startsWith("STOP") || false;
-        values.total = values.total || "";
-        prevOrderData.current = parsedData;
-        orderDataCache.current = values;
-        return values;
-    }, [
-        parsedData,
-        markPrice
-    ]);
-    /// validator order info
-    (0, _react.useEffect)(()=>{
-        if (!markPrice || symbolInfo.isNil) return;
-        // validate order data;
-        validator(formattedOrder)?.then((err)=>{
-            setErrors(err);
-        }).catch((err)=>{});
-    }, [
-        formattedOrder.broker_id,
-        formattedOrder.order_quantity,
-        formattedOrder.total,
-        formattedOrder.trigger_price,
-        formattedOrder.order_type,
-        markPrice
-    ]);
-    //====== update orderbook ask0/bid0 ======
-    (0, _react.useEffect)(()=>{
-        if (isNewVersion) {
-            if (!optionsValue?.watchOrderbook) {
-                throw new _types.SDKError("In order to calculate the estimated liquidation price, the `options.watchOrderbook` parameter must be set to true.");
-            }
-        } else {
-            if (!optionsValue?.watchOrderbook) {
-                return;
-            }
-        }
-        ee.on("orderbook:update", onOrderbookUpdate);
-        return ()=>{
-            ee.off("orderbook:update", onOrderbookUpdate);
-        };
-    }, [
-        optionsValue?.watchOrderbook
-    ]);
-    (0, _react.useEffect)(()=>{
-        askAndBid.current = [];
-    }, [
-        parsedData?.symbol
-    ]);
-    //====== end ======
-    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.SDKError("Please check if you are using the `useOrderbookStream` hook or if the orderBook has data.");
-        }
-        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.OrderType.MARKET || symbolOrOrder.order_type === _types.OrderType.STOP_MARKET) {
-            if (symbolOrOrder.side === _types.OrderSide.BUY) {
-                price = askAndBid.current[0];
-            } else {
-                price = askAndBid.current[1];
-            }
-        } else {
-            // LIMIT order
-            if (symbolOrOrder.side === _types.OrderSide.BUY) {
-                if (orderPrice >= askAndBid.current[0]) {
-                    price = askAndBid.current[0];
-                } else {
-                    price = orderPrice;
-                }
-            } else {
-                if (orderPrice <= askAndBid.current[1]) {
-                    price = askAndBid.current[1];
-                } else {
-                    price = orderPrice;
-                }
-            }
-        }
-        if (symbolOrOrder.side === _types.OrderSide.SELL) {
-            quantity = -quantity;
-        }
-        return {
-            price,
-            quantity
-        };
-    };
-    const estLiqPrice = (0, _react.useMemo)(()=>{
-        if (!accountInfo || !parsedData || !markPrice) return null;
-        const result = getPriceAndQty(formattedOrder);
-        if (result === null) return null;
-        const { price, quantity } = result;
-        if (!price || !quantity) return null;
-        const orderFee = _perp.order.orderFee({
-            qty: quantity,
-            price,
-            futuresTakeFeeRate: Number(accountInfo["futures_taker_fee_rate"]) / 10000
-        });
-        const liqPrice = _perp.order.estLiqPrice({
-            markPrice,
-            baseIMR,
-            baseMMR,
-            totalCollateral,
-            positions,
-            IMR_Factor: accountInfo["imr_factor"][symbol],
-            orderFee,
-            newOrder: {
-                qty: quantity,
-                price,
-                symbol: parsedData.symbol
-            }
-        });
-        // console.log("********", liqPrice, markPrice, totalCollateral, result);
-        if (liqPrice <= 0) return null;
-        return liqPrice;
-    }, [
-        markPrice,
-        baseIMR,
-        baseMMR,
-        totalCollateral,
-        formattedOrder?.order_price,
-        formattedOrder?.order_quantity,
-        formattedOrder?.total,
-        formattedOrder?.trigger_price,
-        accountInfo
-    ]);
-    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.order.estLeverage({
-            totalCollateral,
-            positions,
-            newOrder: {
-                symbol: parsedData.symbol,
-                qty: result.quantity,
-                price: result.price
-            }
-        });
-        return leverage;
-    }, [
-        baseIMR,
-        baseMMR,
-        totalCollateral,
-        positions,
-        formattedOrder?.order_price,
-        formattedOrder?.order_quantity,
-        formattedOrder?.total,
-        formattedOrder?.trigger_price
-    ]);
-    return {
-        maxQty,
-        freeCollateral,
-        markPrice,
-        onSubmit,
-        submit,
-        submitting: isMutating,
-        formattedOrder,
-        // errors,
-        estLiqPrice,
-        estLeverage,
-        helper: {
-            calculate,
-            validator
-        },
-        metaState: {
-            dirty: fieldDirty.current,
-            submitted: submitted.current,
-            errors
-        },
-        symbolConfig: symbolInfo[symbol]()
-    };
-}
-
-//# sourceMappingURL=useOrderEntry.js.map