@orderly.network/hooks 1.2.0 → 1.3.2

package/esm/orderly/useOrderEntry.js

@@ -1,10 +1,10 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { OrderSide, OrderType, SDKError, } from "@orderly.network/types";
+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, includes, omit, pick } from "ramda";
-import { baseInputHandle, getCalculateHandler, orderEntityFormatHandle, } from "../utils/orderEntryHelper";
+import { baseInputHandle, getCalculateHandler, orderEntityFormatHandle } from "../utils/orderEntryHelper";
 import { useCollateral } from "./useCollateral";
 import { useMaxQty } from "./useMaxQty";
 import { OrderFactory, availableOrderTypes } from "../utils/createOrder";
@@ -37,25 +37,29 @@ export function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options)
     const fieldDirty = useRef({});
     const submitted = useRef(false);
     const askAndBid = useRef([]); // 0: ask0, 1: bid0
-    const onOrderbookUpdate = useDebouncedCallback((data) => {
+    const onOrderbookUpdate = useDebouncedCallback((data)=>{
         askAndBid.current = data;
     }, 200);
     const { freeCollateral, totalCollateral, positions, accountInfo } = useCollateral();
     const symbolInfo = useSymbolsInfo();
     // const tokenInfo = useTokenInfo();
-    const symbol = useMemo(() => {
+    const symbol = useMemo(()=>{
         if (typeof symbolOrOrder === "string") {
             return symbolOrOrder;
         }
         return symbolOrOrder.symbol;
-    }, [symbolOrOrder]);
-    const optionsValue = useMemo(() => {
+    }, [
+        symbolOrOrder
+    ]);
+    const optionsValue = useMemo(()=>{
         if (typeof sideOrOptions === "object") {
             return sideOrOptions;
         }
         return options;
-    }, [sideOrOptions]);
-    const isReduceOnly = useMemo(() => {
+    }, [
+        sideOrOptions
+    ]);
+    const isReduceOnly = useMemo(()=>{
         if (typeof reduceOnly === "boolean") {
             return reduceOnly;
         }
@@ -63,35 +67,46 @@ export function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options)
             return !!symbolOrOrder.reduce_only;
         }
         return false;
-    }, [symbolOrOrder, reduceOnly]);
-    const sideValue = useMemo(() => {
+    }, [
+        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(() => {
+    // }
+    }, [
+        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]);
+    }, [
+        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;
+    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);
@@ -103,14 +118,16 @@ export 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 = useMaxQty(symbol, sideValue, isReduceOnly);
-    const parseString2Number = (order, key) => {
-        if (typeof order[key] !== "string")
-            return;
+    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(".")) {
@@ -118,9 +135,18 @@ export 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 = useMemo(() => {
+    const needParse = useMemo(()=>{
         if (typeof symbolOrOrder === "string") {
             return null;
         }
@@ -134,32 +160,30 @@ export function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options)
             "symbol",
             "total",
             "reduce_only",
-            "trigger_price",
-        ])(
-        //@ts-ignore
+            "trigger_price"
+        ])(//@ts-ignore
         symbolOrOrder);
-    }, [symbolOrOrder]);
-    const parsedData = useMemo(() => {
+    }, [
+        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();
+        } 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");
+            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(
@@ -179,72 +203,67 @@ export function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options)
         needParse?.reduce_only,
         needParse?.side,
         needParse?.visible_quantity,
+        quoteDP,
+        baseDP
     ]);
-    const isStopOrder = parsedData?.order_type === OrderType.STOP_LIMIT ||
-        parsedData?.order_type === OrderType.STOP_MARKET;
+    const isStopOrder = parsedData?.order_type === OrderType.STOP_LIMIT || parsedData?.order_type === OrderType.STOP_MARKET;
     const [doCreateOrder, { isMutating }] = useMutation(isStopOrder ? "/v1/algo/order" : "/v1/order");
     // const maxQty = 3;
-    const createOrder = (values) => {
+    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" ||
-            !includes(values.order_type, availableOrderTypes)) {
+        if (!values || typeof values.order_type === "undefined" || !includes(values.order_type, availableOrderTypes)) {
             throw new SDKError("order_type is error");
         }
         const orderCreator = OrderFactory.create(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, {
+        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(omit(["order_type_ext"], {
+                    return doCreateOrder(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);
@@ -253,41 +272,53 @@ export 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 SDKError("The reduceOny parameter of hook does not match your order data"));
         }
         return createOrder({
             ...values,
-            symbol,
+            symbol
         });
     };
-    const submit = useCallback(() => {
+    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) => {
+    }, [
+        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 }]);
+        const newValues = compose(head, orderEntityFormatHandle(baseDP, quoteDP), fieldHandler, baseInputHandle)([
+            values,
+            field,
+            value,
+            markPrice,
+            {
+                baseDP,
+                quoteDP
+            }
+        ]);
         return newValues;
-    }, [markPrice]);
+    }, [
+        markPrice
+    ]);
     // const estLiqPrice = useMemo(() => {}, []);
-    const validator = (values) => {
+    const validator = (values)=>{
         const creator = OrderFactory.create(values.order_type);
         return creator?.validate(values, {
             symbol: symbolInfo[symbol](),
             // token: tokenInfo[symbol](),
             maxQty,
-            markPrice: markPrice,
+            markPrice: markPrice
         });
     };
-    const formattedOrder = useMemo(() => {
+    const formattedOrder = useMemo(()=>{
         if (!parsedData) {
             return notSupportData.current;
         }
@@ -300,7 +331,7 @@ export function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options)
             prevOrderData.current = parsedData;
             orderDataCache.current = {
                 ...parsedData,
-                total: "",
+                total: ""
             };
             return orderDataCache.current;
         }
@@ -324,47 +355,50 @@ export function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options)
         prevOrderData.current = parsedData;
         orderDataCache.current = values;
         return values;
-    }, [parsedData, markPrice]);
+    }, [
+        parsedData,
+        markPrice
+    ]);
     /// validator order info
-    useEffect(() => {
-        if (!markPrice || symbolInfo.isNil)
-            return;
+    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 ======
-    useEffect(() => {
+    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 {
+        } else {
             if (!optionsValue?.watchOrderbook) {
                 return;
             }
         }
         ee.on("orderbook:update", onOrderbookUpdate);
-        return () => {
+        return ()=>{
             ee.off("orderbook:update", onOrderbookUpdate);
         };
-    }, [optionsValue?.watchOrderbook]);
-    useEffect(() => {
+    }, [
+        optionsValue?.watchOrderbook
+    ]);
+    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) {
@@ -373,48 +407,38 @@ export function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options)
         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;
+        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) {
+     * 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 {
+            } else {
                 price = askAndBid.current[1];
             }
-        }
-        else {
+        } else {
             // LIMIT order
             if (symbolOrOrder.side === 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;
                 }
             }
@@ -422,21 +446,21 @@ export function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options)
         if (symbolOrOrder.side === OrderSide.SELL) {
             quantity = -quantity;
         }
-        return { price, quantity };
+        return {
+            price,
+            quantity
+        };
     };
-    const estLiqPrice = useMemo(() => {
-        if (!accountInfo || !parsedData || !markPrice)
-            return null;
+    const estLiqPrice = 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;
+        if (!price || !quantity) return null;
         const orderFee = orderUtils.orderFee({
             qty: quantity,
             price,
-            futuresTakeFeeRate: Number(accountInfo["futures_taker_fee_rate"]) / 10000,
+            futuresTakeFeeRate: Number(accountInfo["futures_taker_fee_rate"]) / 10000
         });
         const liqPrice = orderUtils.estLiqPrice({
             markPrice,
@@ -449,12 +473,11 @@ export 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,
@@ -465,22 +488,20 @@ export function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options)
         formattedOrder?.order_quantity,
         formattedOrder?.total,
         formattedOrder?.trigger_price,
-        accountInfo,
+        accountInfo
     ]);
-    const estLeverage = useMemo(() => {
-        if (!accountInfo || !parsedData)
-            return null;
+    const estLeverage = useMemo(()=>{
+        if (!accountInfo || !parsedData) return null;
         const result = getPriceAndQty(formattedOrder);
-        if (result === null || !result.price || !result.quantity)
-            return null;
+        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,
-            },
+                price: result.price
+            }
         });
         return leverage;
     }, [
@@ -491,7 +512,7 @@ export function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options)
         formattedOrder?.order_price,
         formattedOrder?.order_quantity,
         formattedOrder?.total,
-        formattedOrder?.trigger_price,
+        formattedOrder?.trigger_price
     ]);
     return {
         maxQty,
@@ -506,14 +527,15 @@ export 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]()
     };
 }
+
+//# sourceMappingURL=useOrderEntry.js.map