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

package/esm/orderly/useOrderEntry.js

@@ -0,0 +1,504 @@
+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, includes, omit, pick } from "ramda";
+import { baseInputHandle, getCalculateHandler, orderEntityFormatHandle, } from "../utils/orderEntryHelper";
+import { useCollateral } from "./useCollateral";
+import { useMaxQty } from "./useMaxQty";
+import { OrderFactory, availableOrderTypes } from "../utils/createOrder";
+import { useMarkPrice } from "./useMarkPrice";
+import { order } from "@orderly.network/perp";
+import { useEventEmitter } from "../useEventEmitter";
+import { useDebouncedCallback } from "use-debounce";
+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"), [symbolInfo]);
+    const baseMMR = useMemo(() => symbolInfo[symbol]("base_mmr"), [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) => {
+        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 = 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");
+        }
+        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 === OrderType.STOP_LIMIT ||
+        parsedData?.order_type === OrderType.STOP_MARKET;
+    const [doCreateOrder, { data, error, reset, isMutating }] = useMutation(isStopOrder ? "/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" ||
+            !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, {
+                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(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 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) => {
+        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)
+            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 ======
+    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 liqPrice = 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 = useMemo(() => {
+        if (!accountInfo || !parsedData)
+            return null;
+        const result = getPriceAndQty(formattedOrder);
+        if (result === null || !result.price || !result.quantity)
+            return null;
+        const leverage = 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](),
+    };
+}

package/esm/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/esm/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"}