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

package/esm/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/esm/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/esm/orderly/useOrderEntry.js

@@ -1,544 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { OrderSide, OrderType, SDKError } from "@orderly.network/types";
-import { useSymbolsInfo } from "./useSymbolsInfo";
-import { Decimal, getPrecisionByNumber } from "@orderly.network/utils";
-import { useMutation } from "../useMutation";
-import { compose, head, omit, pick } from "ramda";
-import { baseInputHandle, getCalculateHandler, orderEntityFormatHandle } from "../utils/orderEntryHelper";
-import { useCollateral } from "./useCollateral";
-import { useMaxQty } from "./useMaxQty";
-// import { availableOrderTypes } from "../utils/createOrder";
-import { useMarkPrice } from "./useMarkPrice";
-import { order as orderUtils } from "@orderly.network/perp";
-import { useEventEmitter } from "../useEventEmitter";
-import { useDebouncedCallback } from "use-debounce";
-import { OrderFactory } from "../services/orderCreator/factory";
-export 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 SDKError("symbol is required");
-        }
-        if (!symbolOrOrder.side) {
-            throw new SDKError("Order side is required");
-        }
-        if (!symbolOrOrder.order_type) {
-            throw new SDKError("order_type is required");
-        }
-    }
-    const prevOrderData = useRef(null);
-    // Cache data from the last calculate
-    const orderDataCache = useRef(null);
-    //
-    const notSupportData = useRef({});
-    const [errors, setErrors] = useState(null);
-    const ee = useEventEmitter();
-    const fieldDirty = useRef({});
-    const submitted = useRef(false);
-    const askAndBid = useRef([]); // 0: ask0, 1: bid0
-    const onOrderbookUpdate = useDebouncedCallback((data)=>{
-        askAndBid.current = data;
-    }, 200);
-    const { freeCollateral, totalCollateral, positions, accountInfo } = useCollateral();
-    const symbolInfo = useSymbolsInfo();
-    // const tokenInfo = useTokenInfo();
-    const symbol = useMemo(()=>{
-        if (typeof symbolOrOrder === "string") {
-            return symbolOrOrder;
-        }
-        return symbolOrOrder.symbol;
-    }, [
-        symbolOrOrder
-    ]);
-    const optionsValue = useMemo(()=>{
-        if (typeof sideOrOptions === "object") {
-            return sideOrOptions;
-        }
-        return options;
-    }, [
-        sideOrOptions
-    ]);
-    const isReduceOnly = useMemo(()=>{
-        if (typeof reduceOnly === "boolean") {
-            return reduceOnly;
-        }
-        if (typeof symbolOrOrder === "object") {
-            return !!symbolOrOrder.reduce_only;
-        }
-        return false;
-    }, [
-        symbolOrOrder,
-        reduceOnly
-    ]);
-    const sideValue = useMemo(()=>{
-        if (typeof symbolOrOrder === "object") {
-            return symbolOrOrder.side;
-        }
-        // if (typeof sideOrOptions === "string") {
-        return sideOrOptions;
-    // }
-    }, [
-        symbolOrOrder,
-        sideOrOptions
-    ]);
-    const baseDP = useMemo(()=>getPrecisionByNumber(symbolInfo[symbol]("base_tick", 0)), [
-        symbolInfo
-    ]);
-    const quoteDP = useMemo(()=>{
-        return getPrecisionByNumber(symbolInfo[symbol]("quote_tick", 0));
-    }, [
-        symbolInfo
-    ]);
-    const baseIMR = useMemo(()=>symbolInfo[symbol]("base_imr", 0), [
-        symbolInfo
-    ]);
-    const baseMMR = useMemo(()=>symbolInfo[symbol]("base_mmr", 0), [
-        symbolInfo
-    ]);
-    const { data: markPrice } = 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 = 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 = useMemo(()=>{
-        if (typeof symbolOrOrder === "string") {
-            return null;
-        }
-        return 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 = 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 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 === OrderType.STOP_LIMIT || parsedData?.order_type === OrderType.STOP_MARKET || parsedData?.order_type === OrderType.CLOSE_POSITION;
-    const [doCreateOrder, { isMutating }] = useMutation(isAlgoOrder ? "/v1/algo/order" : "/v1/order");
-    // const maxQty = 3;
-    const createOrder = (values)=>{
-        if (!values.symbol) {
-            throw new SDKError("symbol is error");
-        }
-        if (!values.side) {
-            throw new SDKError("side is error");
-        }
-        if (!values || typeof values.order_type === "undefined") {
-            throw new SDKError("order_type is error");
-        }
-        const orderCreator = OrderFactory.create(// @ts-ignore
-        values.order_type_ext ? values.order_type_ext : values.order_type);
-        if (!orderCreator) {
-            return Promise.reject(new 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(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 SDKError("The reduceOny parameter of hook does not match your order data"));
-        }
-        return createOrder({
-            ...values,
-            symbol
-        });
-    };
-    const submit = useCallback(()=>{
-        if (!parsedData) {
-            throw new SDKError("Function is not supported, please use onSubmit()");
-        }
-        return createOrder(parsedData);
-    }, [
-        parsedData
-    ]);
-    const calculate = useCallback((values, field, value)=>{
-        const fieldHandler = getCalculateHandler(field);
-        const newValues = compose(head, orderEntityFormatHandle(baseDP, quoteDP), fieldHandler, baseInputHandle)([
-            values,
-            field,
-            value,
-            markPrice,
-            {
-                baseDP,
-                quoteDP
-            }
-        ]);
-        return newValues;
-    }, [
-        markPrice
-    ]);
-    // const estLiqPrice = useMemo(() => {}, []);
-    const validator = (values)=>{
-        // @ts-ignore
-        const creator = OrderFactory.create(values.order_type);
-        return creator?.validate(values, {
-            symbol: symbolInfo[symbol](),
-            // token: tokenInfo[symbol](),
-            maxQty,
-            markPrice: markPrice
-        });
-    };
-    const formattedOrder = 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
-    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 ======
-    useEffect(()=>{
-        if (isNewVersion) {
-            if (!optionsValue?.watchOrderbook) {
-                throw new 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
-    ]);
-    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 SDKError("Please check if you are using the `useOrderbookStream` hook or if the orderBook has data.");
-        }
-        if ((symbolOrOrder.order_type === OrderType.LIMIT || symbolOrOrder.order_type === 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 === OrderType.MARKET || symbolOrOrder.order_type === OrderType.STOP_MARKET) {
-            if (symbolOrOrder.side === OrderSide.BUY) {
-                price = askAndBid.current[0];
-            } else {
-                price = askAndBid.current[1];
-            }
-        } else {
-            // LIMIT order
-            if (symbolOrOrder.side === 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 === OrderSide.SELL) {
-            quantity = -quantity;
-        }
-        return {
-            price,
-            quantity
-        };
-    };
-    const estLiqPrice = 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 = orderUtils.orderFee({
-            qty: quantity,
-            price,
-            futuresTakeFeeRate: Number(accountInfo["futures_taker_fee_rate"]) / 10000
-        });
-        const liqPrice = orderUtils.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 = useMemo(()=>{
-        if (!accountInfo || !parsedData) return null;
-        const result = getPriceAndQty(formattedOrder);
-        if (result === null || !result.price || !result.quantity) return null;
-        const leverage = orderUtils.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