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

package/esm/orderly/usePositionStream.js

@@ -0,0 +1,232 @@
+import { useEffect, useMemo, useState } from "react";
+import { usePrivateQuery } from "../usePrivateQuery";
+import { account, positions } from "@orderly.network/perp";
+import { createGetter } from "../utils/createGetter";
+import { useFundingRates } from "./useFundingRates";
+import { useSymbolsInfo } from "./useSymbolsInfo";
+import { useMarkPricesStream } from "./useMarkPricesStream";
+import { pathOr, propOr } from "ramda";
+import { parseHolding } from "../utils/parseHolding";
+import { zero } from "@orderly.network/utils";
+import { useMarketsStream } from "./useMarketsStream";
+export const usePositionStream = (
+/**
+ * If symbol is passed, only the position of that symbol will be returned.
+ */
+symbol, options) => {
+    const symbolInfo = useSymbolsInfo();
+    const { data: accountInfo } = usePrivateQuery("/v1/client/info");
+    const { data: holding } = usePrivateQuery("/v1/client/holding", {
+        formatter: (data) => {
+            return data.holding;
+        },
+    });
+    const fundingRates = useFundingRates();
+    const { data, error, mutate: refreshPositions, } = usePrivateQuery(`/v1/positions`, {
+        // revalidateOnFocus: false,
+        // revalidateOnReconnect: false,
+        // dedupingInterval: 200,
+        // keepPreviousData: false,
+        // revalidateIfStale: true,
+        ...options,
+        formatter: (data) => data,
+        onError: (err) => { },
+    });
+    const { data: markPrices } = useMarkPricesStream();
+    const [priceMode, setPriceMode] = useState(options?.calcMode || "markPrice");
+    useEffect(() => {
+        if (options?.calcMode && priceMode !== options?.calcMode) {
+            setPriceMode(options?.calcMode);
+        }
+    }, [options?.calcMode]);
+    const { data: tickers } = useMarketsStream();
+    // console.log("mark prices", markPrices);
+    // console.log("tickers", tickers);
+    const tickerPrices = useMemo(() => {
+        const data = Object.create(null);
+        tickers?.forEach((item) => {
+            // @ts-ignore
+            data[item.symbol] = item["24h_close"];
+        });
+        return data;
+    }, [tickers]);
+    const formatedPositions = useMemo(() => {
+        if (!data?.rows || !symbolInfo || !accountInfo)
+            return null;
+        const filteredData = typeof symbol === "undefined" || symbol === ""
+            ? data.rows
+            : data.rows.filter((item) => {
+                return item.symbol === symbol;
+            });
+        let unrealPnL_total = zero, notional_total = zero, unsettlementPnL_total = zero;
+        const formatted = filteredData.map((item) => {
+            // const price = (markPrices as any)[item.symbol] ?? item.mark_price;
+            const unRealizedPrice = propOr(item.mark_price, item.symbol, priceMode === "markPrice" ? markPrices : tickerPrices);
+            const price = propOr(item.mark_price, item.symbol, markPrices);
+            const info = symbolInfo?.[item.symbol];
+            //
+            const notional = positions.notional(item.position_qty, price);
+            const unrealPnl = positions.unrealizedPnL({
+                qty: item.position_qty,
+                openPrice: item?.average_open_price,
+                markPrice: unRealizedPrice,
+            });
+            const imr = account.IMR({
+                maxLeverage: accountInfo.max_leverage,
+                baseIMR: info("base_imr"),
+                IMR_Factor: accountInfo.imr_factor[item.symbol],
+                positionNotional: notional,
+                ordersNotional: 0,
+                IMR_factor_power: 4 / 5,
+            });
+            const unrealPnlROI = positions.unrealizedPnLROI({
+                positionQty: item.position_qty,
+                openPrice: item.average_open_price,
+                IMR: imr,
+                unrealizedPnL: unrealPnl,
+            });
+            const unsettlementPnL = positions.unsettlementPnL({
+                positionQty: item.position_qty,
+                markPrice: price,
+                costPosition: item.cost_position,
+                sumUnitaryFunding: fundingRates[item.symbol]?.("sum_unitary_funding", 0),
+                lastSumUnitaryFunding: item.last_sum_unitary_funding,
+            });
+            unrealPnL_total = unrealPnL_total.add(unrealPnl);
+            notional_total = notional_total.add(notional);
+            unsettlementPnL_total = unsettlementPnL_total.add(unsettlementPnL);
+            return {
+                ...item,
+                mark_price: price,
+                mm: 0,
+                notional,
+                unsettlement_pnl: unsettlementPnL,
+                unrealized_pnl: unrealPnl,
+                unsettled_pnl_ROI: unrealPnlROI,
+            };
+        });
+        return [
+            formatted,
+            {
+                unrealPnL: unrealPnL_total.toNumber(),
+                notional: notional_total.toNumber(),
+                unsettledPnL: unsettlementPnL_total.toNumber(),
+            },
+        ];
+    }, [
+        data?.rows,
+        symbolInfo,
+        accountInfo,
+        markPrices,
+        priceMode,
+        tickerPrices,
+        symbol,
+        holding,
+    ]);
+    // const showSymbol = useCallback((symbol: string) => {
+    //   setVisibleSymbol(symbol);
+    // }, []);
+    const [totalCollateral, totalValue, totalUnrealizedROI] = useMemo(() => {
+        if (!holding || !markPrices) {
+            return [zero, zero, 0];
+        }
+        const unsettlemnedPnL = pathOr(0, [1, "unsettledPnL"])(formatedPositions);
+        const unrealizedPnL = pathOr(0, [1, "unrealPnL"])(formatedPositions);
+        const [USDC_holding, nonUSDC] = parseHolding(holding, markPrices);
+        const totalCollateral = account.totalCollateral({
+            USDCHolding: USDC_holding,
+            nonUSDCHolding: nonUSDC,
+            unsettlementPnL: unsettlemnedPnL,
+        });
+        const totalValue = account.totalValue({
+            totalUnsettlementPnL: unsettlemnedPnL,
+            USDCHolding: USDC_holding,
+            nonUSDCHolding: nonUSDC,
+        });
+        const totalUnrealizedROI = account.totalUnrealizedROI({
+            totalUnrealizedPnL: unrealizedPnL,
+            totalValue: totalValue.toNumber(),
+        });
+        return [totalCollateral, totalValue, totalUnrealizedROI];
+    }, [holding, formatedPositions, markPrices]);
+    const positionsRows = useMemo(() => {
+        if (!formatedPositions)
+            return null;
+        if (!symbolInfo || !accountInfo)
+            return formatedPositions[0];
+        const total = totalCollateral.toNumber();
+        let rows = formatedPositions[0]
+            .filter((item) => item.position_qty !== 0)
+            .map((item) => {
+            const info = symbolInfo?.[item.symbol];
+            const MMR = positions.MMR({
+                baseMMR: info("base_mmr"),
+                baseIMR: info("base_imr"),
+                IMRFactor: accountInfo.imr_factor[item.symbol],
+                positionNotional: item.notional,
+                IMR_factor_power: 4 / 5,
+            });
+            return {
+                ...item,
+                mm: positions.maintenanceMargin({
+                    positionQty: item.position_qty,
+                    markPrice: item.mark_price,
+                    MMR,
+                }),
+                // est_liq_price: positions.liqPrice({
+                //   markPrice: item.mark_price,
+                //   totalCollateral: total,
+                //   positionQty: item.position_qty,
+                //   MMR,
+                // }),
+                mmr: MMR,
+            };
+        });
+        // calculate est_liq_price
+        rows = rows.map((item) => {
+            const est_liq_price = positions.liqPrice({
+                markPrice: item.mark_price,
+                totalCollateral: total,
+                positionQty: item.position_qty,
+                positions: rows,
+                MMR: item.mmr,
+            });
+            return {
+                ...item,
+                est_liq_price,
+            };
+        });
+        return rows;
+    }, [formatedPositions, symbolInfo, accountInfo, totalCollateral]);
+    // useEffect(() => {
+    //   ee.on("positions:changed", () => {
+    //     updatePositions();
+    //   });
+    // }, []);
+    return [
+        {
+            rows: positionsRows,
+            aggregated: {
+                ...(formatedPositions?.[1] ?? {}),
+                unrealPnlROI: totalUnrealizedROI,
+            },
+            totalCollateral,
+            totalValue,
+            totalUnrealizedROI,
+        },
+        createGetter(data, 1),
+        {
+            // close: onClosePosition,
+            loading: false,
+            // showSymbol,
+            error,
+            // loadMore: () => {},
+            refresh: refreshPositions,
+        },
+    ];
+};
+export const pathOr_unsettledPnLPathOr = pathOr(0, [
+    0,
+    "aggregated",
+    "unsettledPnL",
+]);

package/esm/orderly/usePrivateDataObserver.d.ts

@@ -0,0 +1,5 @@
+import { getKeyFunction } from "../dataProvider";
+export declare const usePrivateDataObserver: (options: {
+    getKeysMap: (type: string) => Map<string, getKeyFunction>;
+}) => void;
+//# sourceMappingURL=usePrivateDataObserver.d.ts.map

package/esm/orderly/usePrivateDataObserver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePrivateDataObserver.d.ts","sourceRoot":"","sources":["../../src/orderly/usePrivateDataObserver.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGjD,eAAO,MAAM,sBAAsB;uBAEd,MAAM,KAAK,IAAI,MAAM,EAAE,cAAc,CAAC;UAgI1D,CAAC"}

package/esm/orderly/usePrivateDataObserver.js

@@ -0,0 +1,126 @@
+import { useEffect } from "react";
+import { useWS } from "../useWS";
+import { useSWRConfig } from "swr";
+import { useAccount } from "../useAccount";
+import { unstable_serialize } from "swr/infinite";
+import { useDebouncedCallback } from "use-debounce";
+import { useEventEmitter } from "../useEventEmitter";
+import { parseJSON } from "../utils/json";
+export const usePrivateDataObserver = (options) => {
+    const ws = useWS();
+    const { mutate } = useSWRConfig();
+    const ee = useEventEmitter();
+    const { state } = useAccount();
+    const updateOrders = useDebouncedCallback((data) => {
+        const map = options.getKeysMap("orders");
+        const orderStatus = getSessionStorage("orderly_order_status", "positions");
+        map.forEach((getKey, key) => {
+            if ((orderStatus === "history" && key === "orders") ||
+                (orderStatus === "positions" && key === "orders:NEW") ||
+                key.includes("INCOMPLETE") || // always update pending list
+                key.includes(orderStatus)) {
+                mutate(unstable_serialize((index, prevData) => [
+                    getKey(index, prevData),
+                    state.accountId,
+                ]));
+            }
+        });
+        // update the orders history list;
+        // ee.emit("orders:changed");
+    }, 500);
+    // orders
+    useEffect(() => {
+        if (!state.accountId)
+            return;
+        const unsubscribe = ws.privateSubscribe("executionreport", {
+            onMessage: (data) => {
+                updateOrders(data);
+                ee.emit("orders:changed", data);
+            },
+        });
+        return () => unsubscribe?.();
+    }, [state.accountId]);
+    // algo orders
+    useEffect(() => {
+        if (!state.accountId)
+            return;
+        const unsubscribe = ws.privateSubscribe("algoexecutionreport", {
+            onMessage: (data) => {
+                updateOrders(data);
+                if (Array.isArray(data)) {
+                    data.forEach((item) => ee.emit("orders:changed", { ...item, status: item.algoStatus }));
+                }
+                else {
+                    ee.emit("orders:changed", { ...data, status: data.algoStatus });
+                }
+            },
+        });
+        return () => unsubscribe?.();
+    }, [state.accountId]);
+    // positions
+    useEffect(() => {
+        if (!state.accountId)
+            return;
+        const key = ["/v1/positions", state.accountId];
+        const unsubscribe = ws.privateSubscribe("position", {
+            onMessage: (data) => {
+                const { positions: nextPostions } = data;
+                // console.log("ws----- positions data-----", data);
+                // updatePositions();
+                mutate(key, (prevPositions) => {
+                    // return nextPostions;
+                    if (!!prevPositions) {
+                        return {
+                            ...prevPositions,
+                            rows: prevPositions.rows.map((row) => {
+                                const item = nextPostions.find((item) => item.symbol === row.symbol);
+                                if (item) {
+                                    return {
+                                        symbol: item.symbol,
+                                        position_qty: item.positionQty,
+                                        cost_position: item.costPosition,
+                                        last_sum_unitary_funding: item.lastSumUnitaryFunding,
+                                        pending_long_qty: item.pendingLongQty,
+                                        pending_short_qty: item.pendingShortQty,
+                                        settle_price: item.settlePrice,
+                                        average_open_price: item.averageOpenPrice,
+                                        unsettled_pnl: item.unsettledPnl,
+                                        mark_price: item.markPrice,
+                                        est_liq_price: item.estLiqPrice,
+                                        timestamp: Date.now(),
+                                        imr: item.imr,
+                                        mmr: item.mmr,
+                                        IMR_withdraw_orders: item.imrwithOrders,
+                                        MMR_with_orders: item.mmrwithOrders,
+                                        pnl_24_h: item.pnl24H,
+                                        fee_24_h: item.fee24H,
+                                    };
+                                }
+                                return row;
+                            }),
+                        };
+                    }
+                }, {
+                    revalidate: false,
+                });
+            },
+        });
+        return () => {
+            unsubscribe?.();
+        };
+    }, [state.accountId]);
+};
+const getSessionStorage = (key, initialValue) => {
+    // Prevent build error "window is undefined" but keep keep working
+    if (typeof window === "undefined") {
+        return initialValue;
+    }
+    try {
+        const item = window.sessionStorage.getItem(key);
+        return item ? parseJSON(item) : initialValue;
+    }
+    catch (error) {
+        console.warn(`Error reading sessionStorage key “${key}”:`, error);
+        return initialValue;
+    }
+};

package/esm/orderly/useSettleSubscription.d.ts

@@ -0,0 +1,4 @@
+export declare const useSettleSubscription: (options?: {
+    onMessage?: ((data: any) => void) | undefined;
+} | undefined) => import("swr/subscription").SWRSubscriptionResponse<any, any>;
+//# sourceMappingURL=useSettleSubscription.d.ts.map

package/esm/orderly/useSettleSubscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSettleSubscription.d.ts","sourceRoot":"","sources":["../../src/orderly/useSettleSubscription.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB;wBACb,GAAG,KAAK,IAAI;8EAuBhC,CAAC"}

package/esm/orderly/useSettleSubscription.js

@@ -0,0 +1,20 @@
+import useSWRSubscription from "swr/subscription";
+import { useWS } from "../useWS";
+export const useSettleSubscription = (options) => {
+    const ws = useWS();
+    return useSWRSubscription("settle", (_, { next }) => {
+        const unsubscribe = ws.privateSubscribe({
+            id: "settle",
+            event: "subscribe",
+            topic: "settle",
+            ts: Date.now(),
+        }, {
+            onMessage: (data) => {
+                //
+                options?.onMessage?.(data);
+                next(data);
+            },
+        });
+        return () => unsubscribe();
+    });
+};

package/esm/orderly/useSymbolPriceRange.d.ts

@@ -0,0 +1,13 @@
+export type PriceRange = {
+    min: number;
+    max: number;
+};
+/**
+ * Get the price range for the specified symbol with an optional price
+ *
+ * @param symbol - The symbol to get the price range for
+ * @param price - Optional parameter to set the price
+ * @returns PriceRange | undefined - Returns the PriceRange representing the price range or undefined
+ */
+export declare const useSymbolPriceRange: (symbol: string, side: "BUY" | "SELL", price?: number) => PriceRange | undefined;
+//# sourceMappingURL=useSymbolPriceRange.d.ts.map

package/esm/orderly/useSymbolPriceRange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSymbolPriceRange.d.ts","sourceRoot":"","sources":["../../src/orderly/useSymbolPriceRange.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,UAAU,GAAG;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,WAAY,MAAM,QAAQ,KAAK,GAAG,MAAM,UAAU,MAAM,KAAG,UAAU,GAAG,SAiCvG,CAAA"}

package/esm/orderly/useSymbolPriceRange.js

@@ -0,0 +1,39 @@
+import { Decimal } from "@orderly.network/utils";
+import { useSymbolsInfo } from "./useSymbolsInfo";
+import { useMarkPricesStream } from "./useMarkPricesStream";
+import { useMemo } from "react";
+/**
+ * Get the price range for the specified symbol with an optional price
+ *
+ * @param symbol - The symbol to get the price range for
+ * @param price - Optional parameter to set the price
+ * @returns PriceRange | undefined - Returns the PriceRange representing the price range or undefined
+ */
+export const useSymbolPriceRange = (symbol, side, price) => {
+    const config = useSymbolsInfo();
+    const priceRange = config?.[symbol]("price_range");
+    const priceScrope = config?.[symbol]("price_scope");
+    const { data: prices } = useMarkPricesStream();
+    const markPrice = price || prices?.[symbol];
+    /// max mark_price_i * (1+price_range)
+    /// min mark_price_i * (1-price_range)
+    const range = useMemo(() => {
+        if (config === undefined || markPrice === undefined) {
+            return undefined;
+        }
+        if (priceRange === undefined || Number.isNaN(markPrice)) {
+            return undefined;
+        }
+        if (side === "BUY") {
+            return {
+                max: new Decimal(markPrice).mul((1 + priceRange)).toNumber(),
+                min: new Decimal(markPrice).mul((1 - priceScrope)).toNumber(),
+            };
+        }
+        return {
+            max: new Decimal(markPrice).mul((1 + priceScrope)).toNumber(),
+            min: new Decimal(markPrice).mul((1 - priceRange)).toNumber(),
+        };
+    }, [symbol, side, priceRange, markPrice]);
+    return range;
+};

package/esm/orderly/useSymbolsInfo.d.ts

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

package/esm/orderly/useSymbolsInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSymbolsInfo.d.ts","sourceRoot":"","sources":["../../src/orderly/useSymbolsInfo.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,cAAc,2BAoC1B,CAAC"}

package/esm/orderly/useSymbolsInfo.js

@@ -0,0 +1,33 @@
+import { useQuery } from "../useQuery";
+import { createGetter } from "../utils/createGetter";
+import { getPrecisionByNumber } from "@orderly.network/utils";
+export const useSymbolsInfo = () => {
+    const { data = {} } = useQuery(`/v1/public/info`, {
+        focusThrottleInterval: 1000 * 60 * 60 * 24,
+        dedupingInterval: 1000 * 60 * 60 * 24,
+        revalidateOnFocus: false,
+        formatter(data) {
+            if (!data?.rows || !data?.rows?.length) {
+                return {};
+            }
+            const obj = Object.create(null);
+            for (let index = 0; index < data.rows.length; index++) {
+                const item = data.rows[index];
+                const arr = item.symbol.split("_");
+                const base_dp = getPrecisionByNumber(item.base_tick);
+                const quote_dp = getPrecisionByNumber(item.quote_tick);
+                obj[item.symbol] = {
+                    ...item,
+                    base_dp,
+                    quote_dp,
+                    base: arr[1],
+                    quote: arr[2],
+                    type: arr[0],
+                    name: `${arr[1]}-${arr[0]}`,
+                };
+            }
+            return obj;
+        },
+    });
+    return createGetter(data);
+};

package/esm/orderly/useTickerStream.d.ts

@@ -0,0 +1,3 @@
+import { API } from "@orderly.network/types";
+export declare const useTickerStream: (symbol: string) => API.MarketInfo;
+//# sourceMappingURL=useTickerStream.d.ts.map

package/esm/orderly/useTickerStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTickerStream.d.ts","sourceRoot":"","sources":["../../src/orderly/useTickerStream.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAQ7C,eAAO,MAAM,eAAe,WAAY,MAAM,mBAgG7C,CAAC"}

package/esm/orderly/useTickerStream.js

@@ -0,0 +1,86 @@
+import { useEffect, useMemo, useState } from "react";
+import { useQuery } from "../useQuery";
+import { Decimal } from "@orderly.network/utils";
+import { useWS } from "../useWS";
+import { useMarkPrice } from "./useMarkPrice";
+import { useIndexPrice } from "./useIndexPrice";
+import { useOpenInterest } from "./useOpenInterest";
+import { useFetures } from "../unuse/useFetures";
+export const useTickerStream = (symbol) => {
+    if (!symbol) {
+        throw new Error("useFuturesForSymbol requires a symbol");
+    }
+    const { data: info } = useQuery(`/v1/public/futures/${symbol}`, {
+        revalidateOnFocus: false,
+    });
+    const [ticker, setTicker] = useState();
+    const ws = useWS();
+    useEffect(() => {
+        const unsubscribe = ws.subscribe(
+        // { event: "subscribe", topic: "markprices" },
+        `${symbol}@ticker`, {
+            onMessage: (message) => {
+                if (message.symbol !== symbol)
+                    return;
+                setTicker(message);
+            },
+            // onUnsubscribe: () => {
+            //   return "markprices";
+            // },
+            // onError: (error: any) => {
+            //
+            // },
+        });
+        return () => {
+            setTicker(undefined);
+            unsubscribe?.();
+        };
+    }, [symbol]);
+    const { data: markPrice } = useMarkPrice(symbol);
+    const { data: indexPrice } = useIndexPrice(symbol);
+    const { data: openInterest } = useOpenInterest(symbol);
+    const { data: futures } = useFetures();
+    const value = useMemo(() => {
+        //
+        if (!info)
+            return null;
+        if (!ticker)
+            return info;
+        const futureIndex = futures?.findIndex((item) => item.symbol === symbol);
+        let _oi = openInterest;
+        if (!_oi && futureIndex !== -1 && futures) {
+            // @ts-ignore
+            _oi = futures[futureIndex].open_interest;
+        }
+        const config = {
+            ...info,
+            mark_price: markPrice,
+            index_price: indexPrice,
+            open_interest: _oi,
+        };
+        if (ticker.open !== undefined) {
+            config["24h_open"] = ticker.open;
+        }
+        if (ticker.close !== undefined) {
+            config["24h_close"] = ticker.close;
+        }
+        if (ticker.high !== undefined) {
+            config["24h_high"] = ticker.high;
+        }
+        if (ticker.low !== undefined) {
+            config["24h_low"] = ticker.low;
+        }
+        if (ticker.volume !== undefined) {
+            config["24h_volumn"] = ticker.volume;
+        }
+        if (ticker.close !== undefined && ticker.open !== undefined) {
+            config["change"] = new Decimal(ticker.close)
+                .minus(ticker.open)
+                .div(ticker.open)
+                .toNumber();
+            config["24h_change"] = new Decimal(ticker.close).minus(ticker.open);
+        }
+        return config;
+    }, [info, symbol, ticker, futures, openInterest]);
+    return value;
+};

package/esm/orderly/useWalletSubscription.d.ts

@@ -0,0 +1,4 @@
+export declare const useWalletSubscription: (options?: {
+    onMessage?: ((data: any) => void) | undefined;
+} | undefined) => import("swr/subscription").SWRSubscriptionResponse<any, any>;
+//# sourceMappingURL=useWalletSubscription.d.ts.map

package/esm/orderly/useWalletSubscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWalletSubscription.d.ts","sourceRoot":"","sources":["../../src/orderly/useWalletSubscription.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB;wBACb,GAAG,KAAK,IAAI;8EAuBhC,CAAC"}

package/esm/orderly/useWalletSubscription.js

@@ -0,0 +1,20 @@
+import useSWRSubscription from "swr/subscription";
+import { useWS } from "../useWS";
+export const useWalletSubscription = (options) => {
+    const ws = useWS();
+    return useSWRSubscription("wallet", (_, { next }) => {
+        const unsubscribe = ws.privateSubscribe({
+            id: "wallet",
+            event: "subscribe",
+            topic: "wallet",
+            ts: Date.now(),
+        }, {
+            onMessage: (data) => {
+                //
+                options?.onMessage?.(data);
+                next(null, data);
+            },
+        });
+        return () => unsubscribe();
+    });
+};

package/esm/orderly/useWithdraw.d.ts

@@ -0,0 +1,14 @@
+export declare const useWithdraw: () => {
+    withdraw: (inputs: {
+        chainId: number;
+        token: string;
+        amount: string;
+        allowCrossChainWithdraw: boolean;
+    }) => Promise<any>;
+    isLoading: boolean;
+    maxAmount: number;
+    availableBalance: number;
+    availableWithdraw: number;
+    unsettledPnL: number;
+};
+//# sourceMappingURL=useWithdraw.d.ts.map

package/esm/orderly/useWithdraw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWithdraw.d.ts","sourceRoot":"","sources":["../../src/orderly/useWithdraw.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW;uBAUX;QACP,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,uBAAuB,EAAE,OAAO,CAAC;KAClC,KAAG,QAAQ,GAAG,CAAC;;;;;;CAiEnB,CAAC"}