@orderly.network/hooks 1.1.4-rc.8 → 1.1.4

package/lib/orderly/useOrderEntry.js

@@ -0,0 +1,508 @@
+"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");
+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");
+        }
+        if (!symbolOrOrder.side) {
+            throw new types_1.SDKError("Order side is required");
+        }
+        if (!symbolOrOrder.order_type) {
+            throw new types_1.SDKError("order_type is required");
+        }
+    }
+    const prevOrderData = (0, react_1.useRef)(null);
+    // Cache data from the last calculate
+    const orderDataCache = (0, react_1.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) => {
+        askAndBid.current = data;
+    }, 200);
+    const { freeCollateral, totalCollateral, positions, accountInfo } = (0, useCollateral_1.useCollateral)();
+    const symbolInfo = (0, useSymbolsInfo_1.useSymbolsInfo)();
+    // const tokenInfo = useTokenInfo();
+    const symbol = (0, react_1.useMemo)(() => {
+        if (typeof symbolOrOrder === "string") {
+            return symbolOrOrder;
+        }
+        return symbolOrOrder.symbol;
+    }, [symbolOrOrder]);
+    const optionsValue = (0, react_1.useMemo)(() => {
+        if (typeof sideOrOptions === "object") {
+            return sideOrOptions;
+        }
+        return options;
+    }, [sideOrOptions]);
+    const isReduceOnly = (0, react_1.useMemo)(() => {
+        if (typeof reduceOnly === "boolean") {
+            return reduceOnly;
+        }
+        if (typeof symbolOrOrder === "object") {
+            return !!symbolOrOrder.reduce_only;
+        }
+        return false;
+    }, [symbolOrOrder, reduceOnly]);
+    const sideValue = (0, react_1.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"), [symbolInfo]);
+    const baseMMR = (0, react_1.useMemo)(() => symbolInfo[symbol]("base_mmr"), [symbolInfo]);
+    const { data: markPrice } = (0, useMarkPrice_1.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_1.useMaxQty)(symbol, sideValue, isReduceOnly);
+    const parseString2Number = (order, key) => {
+        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, "");
+    };
+    // just for performance optimization
+    const needParse = (0, react_1.useMemo)(() => {
+        if (typeof symbolOrOrder === "string") {
+            return null;
+        }
+        return (0, ramda_1.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_1.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();
+        }
+        if (typeof symbolOrOrder.order_price === "string") {
+            parseString2Number(symbolOrOrder, "order_price");
+        }
+        if (typeof symbolOrOrder.total === "string") {
+            parseString2Number(symbolOrOrder, "total");
+        }
+        if (typeof symbolOrOrder.trigger_price === "string") {
+            parseString2Number(symbolOrOrder, "trigger_price");
+        }
+        // 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,
+    ]);
+    const isStopOrder = parsedData?.order_type === types_1.OrderType.STOP_LIMIT ||
+        parsedData?.order_type === types_1.OrderType.STOP_MARKET;
+    const [doCreateOrder, { data, error, reset, isMutating }] = (0, useMutation_1.useMutation)(isStopOrder ? "/v1/algo/order" : "/v1/order");
+    // const maxQty = 3;
+    const createOrder = (values) => {
+        if (!values.symbol) {
+            throw new types_1.SDKError("symbol is error");
+        }
+        if (!values.side) {
+            throw new types_1.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");
+        }
+        const orderCreator = createOrder_1.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 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) {
+                    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_1.omit)(["order_type_ext"], {
+                        // ...values,
+                        // ...omit(["order_price"], values),
+                        ...data,
+                    })).then((res) => {
+                        // console.log("res::::", res);
+                        // resolve(res);
+                        if (res.success) {
+                            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_1.SDKError("The reduceOny parameter of hook does not match your order data"));
+        }
+        return createOrder({
+            ...values,
+            symbol,
+        });
+    };
+    const submit = (0, react_1.useCallback)(() => {
+        if (!parsedData) {
+            throw new types_1.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 }]);
+        return newValues;
+    }, [markPrice]);
+    // const estLiqPrice = useMemo(() => {}, []);
+    const validator = (values) => {
+        const creator = createOrder_1.OrderFactory.create(values.order_type);
+        return creator?.validate(values, {
+            symbol: symbolInfo[symbol](),
+            // token: tokenInfo[symbol](),
+            maxQty,
+            markPrice: markPrice,
+        });
+    };
+    const formattedOrder = (0, react_1.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_1.useEffect)(() => {
+        if (!markPrice)
+            return;
+        // validate order data;
+        validator(formattedOrder)?.then((err) => {
+            setErrors(err);
+        });
+    }, [
+        formattedOrder.broker_id,
+        formattedOrder.order_quantity,
+        formattedOrder.total,
+        formattedOrder.trigger_price,
+        markPrice,
+    ]);
+    //====== update orderbook ask0/bid0 ======
+    (0, react_1.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.");
+            }
+        }
+        else {
+            if (!optionsValue?.watchOrderbook) {
+                return;
+            }
+        }
+        ee.on("orderbook:update", onOrderbookUpdate);
+        return () => {
+            ee.off("orderbook_update", onOrderbookUpdate);
+        };
+    }, [optionsValue?.watchOrderbook]);
+    (0, react_1.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_1.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;
+        /**
+         * 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 = askAndBid.current[0];
+            }
+            else {
+                price = askAndBid.current[1];
+            }
+        }
+        else {
+            // LIMIT order
+            if (symbolOrOrder.side === types_1.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_1.OrderSide.SELL) {
+            quantity = -quantity;
+        }
+        return { price, quantity };
+    };
+    const estLiqPrice = (0, react_1.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 liqPrice = perp_1.order.estLiqPrice({
+            markPrice,
+            baseIMR,
+            baseMMR,
+            totalCollateral,
+            positions,
+            IMR_Factor: accountInfo["imr_factor"][symbol],
+            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_1.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({
+            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,
+            // clearErrors,
+        },
+        metaState: {
+            dirty: fieldDirty.current,
+            submitted: submitted.current,
+            errors,
+        },
+        symbolConfig: symbolInfo[symbol](),
+    };
+}
+exports.useOrderEntry = useOrderEntry;

package/lib/orderly/useOrderStream.d.ts

@@ -0,0 +1,38 @@
+import { OrderSide, OrderEntity, OrderStatus } from "@orderly.network/types";
+export interface UserOrdersReturn {
+    data: any[];
+    loading: boolean;
+    update: (order: any) => void;
+    cancel: (order: any) => void;
+}
+type Params = {
+    symbol?: string;
+    status?: OrderStatus;
+    size?: number;
+    side?: OrderSide;
+};
+export declare const useOrderStream: (params: Params) => readonly [any[] | null, {
+    readonly total: any;
+    readonly isLoading: boolean;
+    readonly refresh: import("swr/_internal").KeyedMutator<any[]>;
+    readonly loadMore: () => void;
+    readonly cancelAllOrders: () => void;
+    readonly updateOrder: (orderId: string, order: OrderEntity) => Promise<any>;
+    readonly cancelOrder: (orderId: number, symbol?: string) => Promise<any>;
+    readonly updateAlgoOrder: (orderId: string, order: OrderEntity) => Promise<any>;
+    readonly cancelAlgoOrder: (orderId: number, symbol?: string) => Promise<any>;
+    readonly errors: {
+        readonly cancelOrder: unknown;
+        readonly updateOrder: unknown;
+        readonly cancelAlgoOrder: unknown;
+        readonly updateAlgoOrder: unknown;
+    };
+    readonly submitting: {
+        readonly cancelOrder: boolean;
+        readonly updateOrder: boolean;
+        readonly cancelAlgoOrder: boolean;
+        readonly updateAlglOrder: boolean;
+    };
+}];
+export {};
+//# sourceMappingURL=useOrderStream.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useOrderStream.d.ts","sourceRoot":"","sources":["../../src/orderly/useOrderStream.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,SAAS,EACT,WAAW,EACX,WAAW,EAEZ,MAAM,wBAAwB,CAAC;AAQhC,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IAC7B,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;CAC9B;AAID,KAAK,MAAM,GAAG;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,SAAS,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,cAAc,WAAY,MAAM;;;;;;oCAyHD,MAAM,SAAS,WAAW;oCAoD1B,MAAM,WAAW,MAAM;wCA7CnB,MAAM,SAAS,WAAW;wCAoD1B,MAAM,WAAW,MAAM;;;;;;;;;;;;;EAkCtE,CAAC"}