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

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

@@ -0,0 +1 @@
+{"version":3,"file":"useHoldingStream.d.ts","sourceRoot":"","sources":["../../src/orderly/useHoldingStream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAM7C,eAAO,MAAM,gBAAgB;;;;CAuD5B,CAAC"}

package/lib/orderly/useHoldingStream.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useHoldingStream = void 0;
+const usePrivateQuery_1 = require("../usePrivateQuery");
+const react_1 = require("react");
+const useWS_1 = require("../useWS");
+const subscription_1 = __importDefault(require("swr/subscription"));
+const useHoldingStream = () => {
+    const ws = (0, useWS_1.useWS)();
+    const { data, isLoading, mutate } = (0, usePrivateQuery_1.usePrivateQuery)("/v1/client/holding", {
+        formatter: (data) => {
+            return data.holding;
+        },
+    });
+    const usdc = (0, react_1.useMemo)(() => {
+        const usdc = data?.find((item) => item.token === "USDC");
+        return usdc;
+    }, [data]);
+    (0, subscription_1.default)("holding", (_, { next }) => {
+        const unsubscribe = ws.privateSubscribe({
+            id: "balance",
+            event: "subscribe",
+            topic: "balance",
+            ts: Date.now(),
+        }, {
+            onMessage: (data) => {
+                const holding = data?.balances ?? {};
+                if (holding) {
+                    mutate((prevData) => {
+                        return prevData?.map((item) => {
+                            const token = holding[item.token];
+                            return {
+                                ...item,
+                                frozen: token.frozen,
+                                holding: token.holding,
+                            };
+                        });
+                    });
+                    next(holding);
+                }
+            },
+        });
+        return () => unsubscribe();
+    });
+    return {
+        data,
+        usdc,
+        isLoading,
+    };
+};
+exports.useHoldingStream = useHoldingStream;

package/lib/orderly/useIndexPrice.d.ts

@@ -0,0 +1,2 @@
+export declare const useIndexPrice: (symbol: string) => import("swr/subscription").SWRSubscriptionResponse<any, any>;
+//# sourceMappingURL=useIndexPrice.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useIndexPrice.d.ts","sourceRoot":"","sources":["../../src/orderly/useIndexPrice.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa,WAAY,MAAM,iEAe3C,CAAC"}

package/lib/orderly/useIndexPrice.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIndexPrice = void 0;
+const useWS_1 = require("../useWS");
+const subscription_1 = __importDefault(require("swr/subscription"));
+const useIndexPrice = (symbol) => {
+    // WARNING: force change perp to spot, because there is no perp now
+    symbol = symbol.replace("PERP", "SPOT");
+    const ws = (0, useWS_1.useWS)();
+    return (0, subscription_1.default)(`${symbol}@indexprice`, (key, { next }) => {
+        const unsubscribe = ws.subscribe(`${symbol}@indexprice`, {
+            onMessage: (message) => {
+                next(null, message.price);
+            },
+        });
+        return () => {
+            unsubscribe?.();
+        };
+    });
+};
+exports.useIndexPrice = useIndexPrice;

package/lib/orderly/useLeverage.d.ts

@@ -0,0 +1,2 @@
+export declare const useLeverage: () => any;
+//# sourceMappingURL=useLeverage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLeverage.d.ts","sourceRoot":"","sources":["../../src/orderly/useLeverage.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,WAAW,QAAO,GA8B9B,CAAC"}

package/lib/orderly/useLeverage.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLeverage = void 0;
+const react_1 = require("react");
+const useMutation_1 = require("../useMutation");
+const usePrivateQuery_1 = require("../usePrivateQuery");
+const ramda_1 = require("ramda");
+const useQuery_1 = require("../useQuery");
+const useLeverage = () => {
+    const { data, mutate } = (0, usePrivateQuery_1.usePrivateQuery)("/v1/client/info");
+    const [update, { isMutating }] = (0, useMutation_1.useMutation)("/v1/client/leverage");
+    const { data: config } = (0, useQuery_1.useQuery)("/v1/public/config");
+    const updateLeverage = (0, react_1.useCallback)((data) => {
+        return update(data).then((res) => {
+            if (res.success) {
+                return mutate();
+            }
+            else {
+                throw new Error(res.message);
+            }
+            // return res
+        });
+    }, []);
+    return [
+        (0, ramda_1.prop)("max_leverage", data),
+        {
+            update: updateLeverage,
+            isMutating,
+            // config: [1, 2, 3, 4, 5, 10, 15, 20],
+            config: config
+                ? config?.available_futures_leverage
+                    ?.split(",")
+                    .map((item) => parseInt(item))
+                : [],
+        },
+    ];
+};
+exports.useLeverage = useLeverage;

package/lib/orderly/useMarginRatio.d.ts

@@ -0,0 +1,7 @@
+export type MarginRatioReturn = {
+    marginRatio: number;
+    currentLeverage: number;
+    mmr: number | null;
+};
+export declare const useMarginRatio: () => MarginRatioReturn;
+//# sourceMappingURL=useMarginRatio.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMarginRatio.d.ts","sourceRoot":"","sources":["../../src/orderly/useMarginRatio.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,iBAAiB,GAAG;IAE9B,WAAW,EAAE,MAAM,CAAC;IAEpB,eAAe,EAAE,MAAM,CAAC;IAExB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,cAAc,QAAO,iBAwCjC,CAAC"}

package/lib/orderly/useMarginRatio.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMarginRatio = void 0;
+const react_1 = require("react");
+const perp_1 = require("@orderly.network/perp");
+const usePositionStream_1 = require("./usePositionStream");
+const useMarkPricesStream_1 = require("./useMarkPricesStream");
+const useCollateral_1 = require("./useCollateral");
+const utils_1 = require("@orderly.network/utils");
+const useMarginRatio = () => {
+    const [{ rows, aggregated }] = (0, usePositionStream_1.usePositionStream)();
+    const { data: markPrices } = (0, useMarkPricesStream_1.useMarkPricesStream)();
+    const { totalCollateral } = (0, useCollateral_1.useCollateral)();
+    const marginRatio = (0, react_1.useMemo)(() => {
+        if (!rows || !markPrices || !totalCollateral || rows.length === 0) {
+            return 0;
+        }
+        const ratio = perp_1.account.totalMarginRatio({
+            totalCollateral: totalCollateral,
+            markPrices: markPrices,
+            positions: rows ?? [],
+        });
+        return ratio;
+    }, [rows, markPrices, totalCollateral]);
+    const currentLeverage = (0, react_1.useMemo)(() => {
+        return perp_1.account.currentLeverage(marginRatio);
+    }, [marginRatio]);
+    // MMR
+    const mmr = (0, react_1.useMemo)(() => {
+        if (!rows || rows.length <= 0)
+            return null;
+        let positionsMM = utils_1.zero;
+        // const positionsNotional = positions.totalNotional(rows);
+        for (let index = 0; index < rows.length; index++) {
+            const item = rows[index];
+            positionsMM = positionsMM.add(item.mm);
+        }
+        return perp_1.account.MMR({
+            positionsMMR: positionsMM.toNumber(),
+            positionsNotional: aggregated.notional,
+        });
+    }, [rows, aggregated]);
+    return { marginRatio, currentLeverage, mmr };
+};
+exports.useMarginRatio = useMarginRatio;

package/lib/orderly/useMarkPrice.d.ts

@@ -0,0 +1,4 @@
+export declare const useMarkPrice: (symbol: string) => {
+    data: number;
+};
+//# sourceMappingURL=useMarkPrice.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMarkPrice.d.ts","sourceRoot":"","sources":["../../src/orderly/useMarkPrice.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY,WAAY,MAAM;;CA8B1C,CAAC"}

package/lib/orderly/useMarkPrice.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMarkPrice = void 0;
+const react_1 = require("react");
+const useWS_1 = require("../useWS");
+// import useSWRSubscription from "swr/subscription";
+const useMarkPrice = (symbol) => {
+    const ws = (0, useWS_1.useWS)();
+    const [price, setPrice] = (0, react_1.useState)(0);
+    (0, react_1.useEffect)(() => {
+        const unsubscribe = ws.subscribe(`${symbol}@markprice`, {
+            onMessage: (message) => {
+                setPrice(message.price);
+            },
+        });
+        return () => {
+            unsubscribe?.();
+        };
+    }, [symbol]);
+    // return useSWRSubscription(`${symbol}@markprice`, (key, { next }) => {
+    //   const unsubscribe = ws.subscribe(`${symbol}@markprice`, {
+    //     onMessage: (message: any) => {
+    //       next(null, message.price);
+    //     },
+    //   });
+    //   return () => {
+    //     // console.log("_____________________ unsubscribe _________ ", symbol);
+    //     unsubscribe?.();
+    //   };
+    // });
+    return { data: price };
+};
+exports.useMarkPrice = useMarkPrice;

package/lib/orderly/useMarkPricesStream.d.ts

@@ -0,0 +1,2 @@
+export declare const useMarkPricesStream: () => import("swr/subscription").SWRSubscriptionResponse<any, any>;
+//# sourceMappingURL=useMarkPricesStream.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMarkPricesStream.d.ts","sourceRoot":"","sources":["../../src/orderly/useMarkPricesStream.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB,oEA4B/B,CAAC"}

package/lib/orderly/useMarkPricesStream.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMarkPricesStream = void 0;
+const subscription_1 = __importDefault(require("swr/subscription"));
+const useWS_1 = require("../useWS");
+const useMarkPricesStream = () => {
+    const ws = (0, useWS_1.useWS)();
+    return (0, subscription_1.default)("markPrices", (key, { next }) => {
+        const unsubscribe = ws.subscribe(
+        // { event: "subscribe", topic: "markprices" },
+        "markprices", {
+            onMessage: (message) => {
+                const data = Object.create(null);
+                for (let index = 0; index < message.length; index++) {
+                    const element = message[index];
+                    data[element.symbol] = element.price;
+                }
+                next(null, data);
+            },
+            // onUnsubscribe: () => {
+            //   return "markprices";
+            // },
+            onError: (error) => { },
+        });
+        return () => {
+            unsubscribe?.();
+        };
+    });
+};
+exports.useMarkPricesStream = useMarkPricesStream;

package/lib/orderly/useMarketTradeStream.d.ts

@@ -0,0 +1,9 @@
+import { API } from "@orderly.network/types";
+export interface MarketTradeStreamOptions {
+    limit?: number;
+}
+export declare const useMarketTradeStream: (symbol: string, options?: MarketTradeStreamOptions) => {
+    data: API.Trade[];
+    isLoading: boolean;
+};
+//# sourceMappingURL=useMarketTradeStream.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMarketTradeStream.d.ts","sourceRoot":"","sources":["../../src/orderly/useMarketTradeStream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAI7C,MAAM,WAAW,wBAAwB;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,oBAAoB,WACvB,MAAM,YACL,wBAAwB;;;CA8DlC,CAAC"}

package/lib/orderly/useMarketTradeStream.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMarketTradeStream = void 0;
+const useWS_1 = require("../useWS");
+const react_1 = require("react");
+const useMarketTradeStream = (symbol, options = {}) => {
+    if (!symbol) {
+        throw new Error("useTradeStream: symbol is required");
+    }
+    const [trades, setTrades] = (0, react_1.useState)([]);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const { limit = 50 } = options;
+    const ws = (0, useWS_1.useWS)();
+    (0, react_1.useEffect)(() => {
+        setIsLoading(true);
+        setTrades(() => []);
+        ws.onceSubscribe({
+            id: `${symbol}@trade`,
+            event: "request",
+            params: {
+                type: "trade",
+                symbol: symbol,
+                limit,
+            },
+        }, {
+            onMessage: (data) => {
+                setIsLoading(false);
+                setTrades(() => data);
+            },
+        });
+    }, [symbol]);
+    (0, react_1.useEffect)(() => {
+        const unsubscript = ws.subscribe({
+            id: `${symbol}@trade`,
+            event: "subscribe",
+            topic: `${symbol}@trade`,
+            ts: Date.now(),
+        }, {
+            onMessage: (data) => {
+                setTrades((prev) => {
+                    const arr = [{ ...data, ts: Date.now() }, ...prev];
+                    if (arr.length > limit) {
+                        arr.pop();
+                    }
+                    return arr;
+                });
+            },
+        });
+        return () => {
+            unsubscript?.();
+        };
+    }, [symbol]);
+    return { data: trades, isLoading };
+};
+exports.useMarketTradeStream = useMarketTradeStream;

package/lib/orderly/useMarkets.d.ts

@@ -0,0 +1,36 @@
+import { API } from "@orderly.network/types";
+export declare enum MarketsType {
+    FAVORITES = 0,
+    RECENT = 1,
+    ALL = 2
+}
+export interface FavoriteTab {
+    name: string;
+    id: number;
+}
+export interface Favorite {
+    name: string;
+    tabs: FavoriteTab[];
+}
+export interface Recent {
+    name: string;
+}
+export declare const useMarkets: (type: MarketsType) => readonly [import("@orderly.network/types").WSMessage.Ticker[], {
+    readonly favoriteTabs: FavoriteTab[];
+    readonly favorites: {
+        tabs: FavoriteTab[];
+        name: string;
+    }[];
+    readonly recent: Recent[];
+    readonly addToHistory: (symbol: API.MarketInfoExt) => void;
+    readonly updateFavoriteTabs: (tab: FavoriteTab | FavoriteTab[], operator?: {
+        add?: boolean;
+        update?: boolean;
+        delete?: boolean;
+    }) => void;
+    readonly updateSymbolFavoriteState: (symbol: API.MarketInfoExt, tab: FavoriteTab | FavoriteTab[], del?: boolean) => void;
+    readonly pinToTop: (symbol: API.MarketInfoExt) => void;
+    readonly getLastSelFavTab: () => FavoriteTab;
+    readonly updateSelectedFavoriteTab: (tab: FavoriteTab) => void;
+}];
+//# sourceMappingURL=useMarkets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMarkets.d.ts","sourceRoot":"","sources":["../../src/orderly/useMarkets.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAI7C,oBAAY,WAAW;IACnB,SAAS,IAAA;IACT,MAAM,IAAA;IACN,GAAG,IAAA;CACN;AAuBD,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,QAAQ;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,WAAW,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,MAAM;IACnB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,UAAU,SAAU,WAAW;;;;cARlC,MAAM;;;oCAuNkB,IAAI,aAAa;uCAhJd,WAAW,GAAG,WAAW,EAAE,aAAa;QACrE,GAAG,CAAC,EAAE,OAAO,CAAC;QACd,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,MAAM,CAAC,EAAE,OAAO,CAAC;KACpB;iDAgJ0C,IAAI,aAAa,OAAO,WAAW,GAAG,WAAW,EAAE,QAAO,OAAO;gCAMlF,IAAI,aAAa;;8CA6BH,WAAW;EAsBtD,CAAA"}

package/lib/orderly/useMarkets.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMarkets = exports.MarketsType = void 0;
+const react_1 = require("react");
+const useMarketsStream_1 = require("./useMarketsStream");
+const orderlyContext_1 = require("../orderlyContext");
+const useSymbolsInfo_1 = require("./useSymbolsInfo");
+var MarketsType;
+(function (MarketsType) {
+    MarketsType[MarketsType["FAVORITES"] = 0] = "FAVORITES";
+    MarketsType[MarketsType["RECENT"] = 1] = "RECENT";
+    MarketsType[MarketsType["ALL"] = 2] = "ALL";
+})(MarketsType || (exports.MarketsType = MarketsType = {}));
+const useMarkets = (type) => {
+    const marketsKey = "markets";
+    const { data } = (0, useMarketsStream_1.useMarketsStream)();
+    const { configStore } = (0, react_1.useContext)(orderlyContext_1.OrderlyContext);
+    // {"PERP_ETH_USDC": {}, ...}
+    const publicInfo = (0, useSymbolsInfo_1.useSymbolsInfo)();
+    if (!configStore.get(marketsKey)) {
+        const jsonStr = localStorage.getItem(marketsKey);
+        if (jsonStr) {
+            configStore.set(marketsKey, JSON.parse(jsonStr));
+        }
+        else {
+            const defaultTab = { name: "Popular", id: 1 };
+            configStore.set(marketsKey, {
+                recent: [],
+                favorites: [
+                    { name: "PERP_ETH_USDC", tabs: [{ ...defaultTab }] },
+                    { name: "PERP_BTC_USDC", tabs: [{ ...defaultTab }] },
+                ],
+                favoriteTabs: [{ ...defaultTab }],
+                lastSelectFavoriteTab: { ...defaultTab }
+            });
+        }
+    }
+    const getFavoriteTabs = (0, react_1.useMemo)(() => {
+        // @ts-ignore
+        const tabs = configStore.get(marketsKey)["favoriteTabs"];
+        return (tabs || [{ name: "Popular", id: 1 }]);
+    }, []);
+    const getFavorites = (0, react_1.useMemo)(() => {
+        // @ts-ignore
+        const curData = (configStore.get(marketsKey)["favorites"] || []);
+        const tabs = getFavoriteTabs;
+        const result = [];
+        for (let index = 0; index < curData.length; index++) {
+            const favData = curData[index];
+            var favTabs = favData.tabs.filter((tab) => tabs.findIndex((item) => tab.id === item.id) !== -1);
+            if (favTabs.length > 0) {
+                result.push({ ...favData, tabs: favTabs });
+            }
+        }
+        configStore.set(marketsKey, { ...configStore.getOr(marketsKey, {}), favorites: result });
+        // localStorage.setItem(marketsKey, JSON.stringify(configStore.get(marketsKey)));
+        return result;
+    }, [configStore]);
+    const getRecent = (0, react_1.useMemo)(() => {
+        // @ts-ignore
+        const curData = configStore.get(marketsKey)["recent"];
+        return (curData || []).filter((e) => e);
+    }, []);
+    const [favoriteTabs, setFavoriteTabs] = (0, react_1.useState)(getFavoriteTabs);
+    const [favorites, setFavorites] = (0, react_1.useState)(getFavorites);
+    const [recent, setRecent] = (0, react_1.useState)(getRecent);
+    const updateFavoriteTabs = (tab, operator) => {
+        const saveTabs = (tabs) => {
+            setFavoriteTabs(tabs);
+            configStore.set(marketsKey, {
+                ...configStore.getOr(marketsKey, {}),
+                "favoriteTabs": tabs
+            });
+        };
+        if (Array.isArray(tab)) {
+            saveTabs(tab);
+            return;
+        }
+        var tabs = [...favoriteTabs];
+        const index = tabs.findIndex((item) => item.id === tab.id);
+        if (operator?.add) {
+            tabs.push(tab);
+        }
+        else if (operator?.update) {
+            if (index !== -1) {
+                tabs[index] = tab;
+            }
+        }
+        else if (operator?.delete) {
+            if (index !== -1) {
+                tabs.splice(index, 1);
+            }
+        }
+        saveTabs(tabs);
+    };
+    const setRecentData = (symbol) => {
+        const curData = [...recent];
+        const index = curData.findIndex((item) => item.name == symbol.symbol);
+        if (index !== -1) {
+            curData.splice(index, 1);
+        }
+        curData.unshift({ name: symbol.symbol });
+        configStore.set(marketsKey, {
+            ...configStore.getOr(marketsKey, {}),
+            "recent": curData
+        });
+        setRecent(curData);
+    };
+    const setFavoritesData = (symbol, tab, remove = false) => {
+        const curData = [...favorites];
+        const index = curData.findIndex((item) => item.name == symbol.symbol);
+        if (index === -1) { // can not find
+            if (Array.isArray(tab)) {
+                if (tab.length > 0) {
+                    curData.unshift({ name: symbol.symbol, tabs: tab });
+                }
+            }
+            else {
+                if (!remove) {
+                    // insert
+                    curData.unshift({ name: symbol.symbol, tabs: [tab] });
+                }
+            }
+        }
+        else {
+            const favorite = curData[index];
+            if (Array.isArray(tab)) {
+                if (tab.length === 0) {
+                    // remove
+                    curData.splice(index, 1);
+                }
+                else {
+                    // overrides
+                    curData[index] = { ...favorite, tabs: tab };
+                }
+            }
+            else {
+                if (remove) {
+                    const tabs = favorite.tabs.filter((tab) => tab.id != tab.id);
+                    if (tabs.length === 0) { // del favorite
+                        curData.splice(index, 1);
+                    }
+                    else {
+                        curData[index] = { ...favorite, tabs };
+                    }
+                }
+                else { // insert
+                    const tabs = favorite.tabs;
+                    tabs.push(tab);
+                    curData[index] = { ...favorite, tabs };
+                }
+            }
+        }
+        configStore.set(marketsKey, {
+            ...configStore.getOr(marketsKey, {}),
+            "favorites": curData
+        });
+        setFavorites(() => curData);
+    };
+    const getData = (type) => {
+        // get data
+        const localData = type === MarketsType.FAVORITES ? [...favorites] : [...recent];
+        // filter
+        const keys = localData.map((item) => item.name);
+        const filter = type == MarketsType.ALL ?
+            data :
+            data?.filter((item) => keys.includes(item.symbol));
+        const favoritesData = [...favorites];
+        const favoriteKeys = favoritesData.map((item) => item.name);
+        if (filter) {
+            for (let index = 0; index < filter.length; index++) {
+                const element = filter[index];
+                const isFavorite = type == MarketsType.FAVORITES ?
+                    true :
+                    (favoriteKeys.includes(element.symbol));
+                const fIndex = favoritesData.findIndex((item) => item.name === element.symbol);
+                const tabs = fIndex === -1 ? [] : favoritesData[fIndex].tabs;
+                let imr = undefined;
+                if (publicInfo) {
+                    imr = publicInfo?.[element.symbol]("base_imr");
+                }
+                filter[index] = {
+                    ...filter[index],
+                    // @ts-ignore
+                    isFavorite,
+                    tabs,
+                    leverage: imr ? 1 / imr : undefined
+                };
+            }
+        }
+        return filter;
+    };
+    const addToHistory = (symbol) => {
+        setRecentData(symbol);
+    };
+    const updateSymbolFavoriteState = (symbol, tab, del = false) => {
+        setFavoritesData(symbol, tab, del);
+    };
+    const markets = getData(type);
+    const pinToTop = (symbol) => {
+        const index = favorites.findIndex((item) => item.name === symbol.symbol);
+        if (index !== -1) {
+            const element = favorites[index];
+            const list = [...favorites];
+            list.splice(index, 1);
+            list.unshift(element);
+            configStore.set(marketsKey, {
+                ...configStore.getOr(marketsKey, {}),
+                "favorites": list
+            });
+            setFavorites(list);
+        }
+    };
+    const tabs = (0, react_1.useMemo)(() => {
+        return favoriteTabs;
+    }, [favoriteTabs]);
+    const getLastSelFavTab = () => {
+        // @ts-ignore
+        const curData = configStore.get(marketsKey)["lastSelectedFavoriteTab"];
+        return (curData || { name: "Popular", id: 1 });
+    };
+    const updateSelectedFavoriteTab = (tab) => {
+        configStore.set(marketsKey, {
+            ...configStore.getOr(marketsKey, {}),
+            lastSelectedFavoriteTab: tab
+        });
+    };
+    return [
+        markets || [],
+        {
+            favoriteTabs: tabs,
+            favorites,
+            recent,
+            addToHistory,
+            // updateFavoriteTabs("tab", operator: {add/update/delete})
+            updateFavoriteTabs,
+            updateSymbolFavoriteState,
+            pinToTop,
+            getLastSelFavTab,
+            updateSelectedFavoriteTab,
+        },
+    ];
+};
+exports.useMarkets = useMarkets;

package/lib/orderly/useMarketsStream.d.ts

@@ -0,0 +1,5 @@
+import { WSMessage } from "@orderly.network/types";
+export declare const useMarketsStream: () => {
+    data: WSMessage.Ticker[] | null;
+};
+//# sourceMappingURL=useMarketsStream.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMarketsStream.d.ts","sourceRoot":"","sources":["../../src/orderly/useMarketsStream.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGnD,eAAO,MAAM,gBAAgB;;CA4D5B,CAAC"}