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

package/esm/orderly/useDeposit.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="react" />
+import { API, NetworkId } from "@orderly.network/types";
+export type useDepositOptions = {
+    address?: string;
+    decimals?: number;
+    networkId?: NetworkId;
+    srcChainId?: number;
+    srcToken?: string;
+    quantity?: string;
+};
+export declare const useDeposit: (options?: useDepositOptions) => {
+    /** orderly support chain dst */
+    dst: {
+        symbol: string;
+        address: string | undefined;
+        decimals: number | undefined;
+        chainId: number;
+        network: string;
+    };
+    balance: string;
+    allowance: string;
+    isNativeToken: boolean;
+    balanceRevalidating: boolean;
+    allowanceRevalidating: boolean;
+    /** input quantiy */
+    quantity: string;
+    /** orderly deposit fee, unit: wei */
+    depositFee: bigint;
+    /** enquiring depositFee status on chain */
+    depositFeeRevalidating: boolean;
+    approve: (amount?: string) => Promise<void | undefined>;
+    deposit: () => Promise<any>;
+    fetchBalances: (tokens: API.TokenInfo[]) => Promise<void>;
+    fetchBalance: (address: string, decimals?: number) => Promise<string>;
+    /** set input quantity */
+    setQuantity: import("react").Dispatch<import("react").SetStateAction<string>>;
+};
+//# sourceMappingURL=useDeposit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDeposit.d.ts","sourceRoot":"","sources":["../../src/orderly/useDeposit.ts"],"names":[],"mappings":";AAEA,OAAO,EACL,GAAG,EAMH,SAAS,EAEV,MAAM,wBAAwB,CAAC;AAMhC,MAAM,MAAM,iBAAiB,GAAG;IAE9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,UAAU,aAAc,iBAAiB;IA4TlD,gCAAgC;;;;;;;;;;;;;IAOhC,oBAAoB;;IAEpB,qCAAqC;;IAErC,2CAA2C;;uBApI3B,MAAM;;4BAhGyB,IAAI,SAAS,EAAE;4BAvC9C,MAAM,aAAa,MAAM;IAiRzC,yBAAyB;;CAG5B,CAAC"}

package/esm/orderly/useDeposit.js

@@ -0,0 +1,270 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useAccount } from "../useAccount";
+import { ARBITRUM_MAINNET_CHAINID, ARBITRUM_TESTNET_CHAINID, AccountStatusEnum, DEPOSIT_FEE_RATE, isNativeTokenChecker, } from "@orderly.network/types";
+import { Decimal } from "@orderly.network/utils";
+import { useChains } from "./useChains";
+import { useConfig } from "../useConfig";
+import { useDebouncedCallback } from "use-debounce";
+export const useDeposit = (options) => {
+    const networkId = useConfig("networkId");
+    const [balanceRevalidating, setBalanceRevalidating] = useState(false);
+    const [allowanceRevalidating, setAllowanceRevalidating] = useState(false);
+    const [_, { findByChainId }] = useChains(undefined);
+    const [quantity, setQuantity] = useState("");
+    const [depositFee, setDepositFee] = useState(0n);
+    const [depositFeeRevalidating, setDepositFeeRevalidating] = useState(false);
+    const [balance, setBalance] = useState("0");
+    const [allowance, setAllowance] = useState("0");
+    const { account, state } = useAccount();
+    const prevAddress = useRef();
+    const getBalanceListener = useRef();
+    const targetChain = useMemo(() => {
+        let chain;
+        // Orderly testnet supported chain
+        if (networkId === "testnet") {
+            chain = findByChainId(ARBITRUM_TESTNET_CHAINID);
+        }
+        else {
+            chain = findByChainId(options?.srcChainId);
+            // if is orderly un-supported chain
+            if (!chain?.network_infos?.bridgeless) {
+                // Orderly mainnet supported chain
+                chain = findByChainId(ARBITRUM_MAINNET_CHAINID);
+            }
+        }
+        return chain;
+    }, [networkId, findByChainId, options?.srcChainId]);
+    const dst = useMemo(() => {
+        if (!targetChain) {
+            throw new Error("dst chain not found");
+        }
+        const USDC = targetChain?.token_infos.find((token) => token.symbol === "USDC");
+        return {
+            symbol: "USDC",
+            address: USDC?.address,
+            decimals: USDC?.decimals,
+            chainId: targetChain.network_infos.chain_id,
+            network: targetChain.network_infos.shortName,
+        };
+    }, [targetChain]);
+    const isNativeToken = useMemo(() => isNativeTokenChecker(options?.address || ""), [options?.address]);
+    const fetchBalanceHandler = useCallback(async (address, decimals) => {
+        let balance;
+        if (!!address && isNativeTokenChecker(address)) {
+            balance = await account.assetsManager.getNativeBalance({
+                decimals,
+            });
+        }
+        else {
+            balance = await account.assetsManager.getBalance(address, { decimals });
+        }
+        return balance;
+    }, []);
+    const fetchBalance = useCallback(async (
+    // token contract address
+    address, 
+    // format decimals
+    decimals) => {
+        if (!address)
+            return;
+        try {
+            // if (balanceRevalidating) return;
+            const balance = await fetchBalanceHandler(address, decimals);
+            setBalance(() => balance);
+        }
+        catch (e) {
+            console.warn("----- refresh balance error -----", e);
+            setBalance(() => "0");
+        }
+    }, [state]);
+    const fetchBalances = useCallback(async (tokens) => {
+        const tasks = [];
+        for (const token of tokens) {
+            // native token skip
+            if (isNativeTokenChecker(token.address)) {
+                continue;
+            }
+            tasks.push(account.assetsManager.getBalanceByAddress(token.address));
+        }
+        const balances = await Promise.all(tasks);
+        // const balances = await account.assetsManager.getBalances(tokens);
+        // setBalance(() => balances);
+    }, []);
+    const getAllowance = async (address, vaultAddress) => {
+        // if (!address || !vaultAddress) return;
+        const key = `${address}-${vaultAddress}`;
+        if (prevAddress.current === key)
+            return;
+        if (!address || !vaultAddress)
+            return;
+        if (address && isNativeTokenChecker(address))
+            return;
+        // if (allowanceRevalidating) return;
+        // setAllowanceRevalidating(true);
+        prevAddress.current = key;
+        const allowance = await account.assetsManager.getAllowance(address, vaultAddress);
+        setAllowance(() => allowance);
+        // setAllowanceRevalidating(false);
+        return allowance;
+    };
+    const getAllowanceByDefaultAddress = async (address) => {
+        if (prevAddress.current === address)
+            return;
+        if (!address || isNativeTokenChecker(address))
+            return;
+        prevAddress.current = address;
+        const allowance = await account.assetsManager.getAllowance(address);
+        setAllowance(() => allowance);
+    };
+    const queryBalance = useDebouncedCallback((tokenAddress, decimals) => {
+        fetchBalance(options?.address, options?.decimals).finally(() => {
+            setBalanceRevalidating(false);
+        });
+    }, 100);
+    const queryAllowance = useDebouncedCallback((tokenAddress, vaultAddress) => {
+        getAllowance(tokenAddress, vaultAddress);
+    }, 100);
+    useEffect(() => {
+        if (state.status < AccountStatusEnum.Connected)
+            return;
+        setBalanceRevalidating(true);
+        // fetchBalance(options?.address, options?.decimals).finally(() => {
+        //   setBalanceRevalidating(false);
+        // });
+        queryBalance(options?.address, options?.decimals);
+        if (dst.chainId !== options?.srcChainId) {
+            queryAllowance(options?.address);
+        }
+        else {
+            if (dst.symbol !== options?.srcToken) {
+                queryAllowance(options?.address);
+            }
+            else {
+                getAllowanceByDefaultAddress(options?.address);
+            }
+        }
+    }, [
+        state.status,
+        options?.address,
+        options?.srcChainId,
+        options?.srcToken,
+        account.address,
+        dst.chainId,
+        dst.symbol,
+    ]);
+    const approve = useCallback(async (amount) => {
+        if (!options?.address) {
+            throw new Error("address is required");
+        }
+        return account.assetsManager
+            .approve(options.address, amount)
+            .then((result) => {
+            return account.walletClient
+                ?.pollTransactionReceiptWithBackoff(result.hash)
+                .then((receipt) => {
+                if (receipt.status === 1) {
+                    account.assetsManager
+                        .getAllowance(options.address)
+                        .then((allowance) => {
+                        setAllowance(() => allowance);
+                    });
+                }
+            });
+        });
+    }, [account, getAllowance, options, dst]);
+    const deposit = useCallback(async () => {
+        // only support orderly deposit
+        return account.assetsManager
+            .deposit(quantity, depositFee)
+            .then((res) => {
+            account.assetsManager
+                .getAllowance(options?.address)
+                .then((allowance) => {
+                setAllowance(() => allowance);
+            });
+            setBalance((value) => new Decimal(value).sub(quantity).toString());
+            return res;
+        });
+    }, [account, fetchBalance, quantity, depositFee]);
+    const loopGetBalance = async () => {
+        getBalanceListener.current && clearTimeout(getBalanceListener.current);
+        getBalanceListener.current = setTimeout(async () => {
+            try {
+                const balance = await fetchBalanceHandler(options?.address, options?.decimals);
+                setBalance(balance);
+                loopGetBalance();
+            }
+            catch (err) {
+                console.log("fetchBalanceHandler error", err);
+            }
+        }, 3000);
+    };
+    const getDepositFee = useCallback(async (quantity) => {
+        return account.assetsManager.getDepositFee(quantity, targetChain?.network_infos);
+    }, [account, targetChain]);
+    const enquiryDepositFee = useCallback(() => {
+        if (isNaN(Number(quantity)) || !quantity) {
+            setDepositFee(0n);
+            setDepositFeeRevalidating(false);
+            return;
+        }
+        setDepositFeeRevalidating(true);
+        getDepositFee(quantity)
+            .then((res = 0n) => {
+            const fee = BigInt(new Decimal(res.toString())
+                .mul(DEPOSIT_FEE_RATE)
+                .toFixed(0, Decimal.ROUND_UP)
+                .toString());
+            setDepositFee(fee);
+            console.log("getDepositFee", fee);
+        })
+            .catch((error) => {
+            console.log("getDepositFee error", error);
+        })
+            .finally(() => {
+            setDepositFeeRevalidating(false);
+        });
+    }, [quantity]);
+    useEffect(() => {
+        enquiryDepositFee();
+    }, [quantity]);
+    useEffect(() => {
+        if (!options?.address) {
+            return;
+        }
+        loopGetBalance();
+        return () => {
+            getBalanceListener.current && clearTimeout(getBalanceListener.current);
+        };
+        // account.walletClient.on(
+        //   // {
+        //   //   address: options?.address,
+        //   // },
+        //   "block",
+        //   (log: any, event: any) => {
+        //     console.log("account.walletClient.on", log, event);
+        //   }
+        // );
+    }, [options?.address, options?.decimals]);
+    return {
+        /** orderly support chain dst */
+        dst,
+        balance,
+        allowance,
+        isNativeToken,
+        balanceRevalidating,
+        allowanceRevalidating,
+        /** input quantiy */
+        quantity,
+        /** orderly deposit fee, unit: wei */
+        depositFee,
+        /** enquiring depositFee status on chain */
+        depositFeeRevalidating,
+        approve,
+        deposit,
+        fetchBalances,
+        fetchBalance: fetchBalanceHandler,
+        /** set input quantity */
+        setQuantity,
+    };
+};

package/esm/orderly/useFundingRate.d.ts

@@ -0,0 +1,11 @@
+export declare const useFundingRate: (symbol: string) => {
+    est_funding_rate: string;
+    countDown: string;
+    symbol?: string | undefined;
+    est_funding_rate_timestamp?: number | undefined;
+    last_funding_rate?: number | undefined;
+    last_funding_rate_timestamp?: number | undefined;
+    next_funding_time?: number | undefined;
+    sum_unitary_funding?: number | undefined;
+};
+//# sourceMappingURL=useFundingRate.d.ts.map

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

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

package/esm/orderly/useFundingRate.js

@@ -0,0 +1,40 @@
+import { useQuery } from "../useQuery";
+import { useEffect, useState } from "react";
+import { timeConvertString } from "@orderly.network/utils";
+export const useFundingRate = (symbol) => {
+    if (!symbol) {
+        throw new Error("useFuturesForSymbol requires a symbol");
+    }
+    const [countDown, setCountDown] = useState("00:00:00");
+    const { data } = useQuery(`/v1/public/funding_rate/${symbol}`, {
+        fallbackData: {
+            est_funding_rate: 0,
+            next_funing_time: 0,
+        },
+    });
+    useEffect(() => {
+        if (!data)
+            return;
+        const { next_funding_time } = data;
+        if (!next_funding_time || next_funding_time <= 0) {
+            return;
+        }
+        const timer = setInterval(() => {
+            const diff = new Date(next_funding_time).getTime() - Date.now();
+            const result = timeConvertString(diff);
+            if (result.length === 3) {
+                setCountDown(`${result[0].toString().padStart(2, "0")}:${result[1]
+                    .toString()
+                    .padStart(2, "0")}:${result[2].toString().padStart(2, "0")}`);
+            }
+        }, 1000);
+        return () => {
+            clearInterval(timer);
+        };
+    }, [data]);
+    return {
+        ...data,
+        est_funding_rate: (Number(data?.est_funding_rate ?? 0) * 100).toFixed(4),
+        countDown,
+    };
+};

package/esm/orderly/useFundingRates.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"useFundingRates.d.ts","sourceRoot":"","sources":["../../src/orderly/useFundingRates.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe,WAwB3B,CAAC"}

package/esm/orderly/useFundingRates.js

@@ -0,0 +1,21 @@
+import { useQuery } from "../useQuery";
+import { createGetter } from "../utils/createGetter";
+export const useFundingRates = () => {
+    const { data } = useQuery(`/v1/public/funding_rates`, {
+        focusThrottleInterval: 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];
+                obj[item.symbol] = item;
+            }
+            return obj;
+        },
+    });
+    // @ts-ignore
+    return createGetter(data);
+};

package/esm/orderly/useHoldingStream.d.ts

@@ -0,0 +1,7 @@
+import { API } from "@orderly.network/types";
+export declare const useHoldingStream: () => {
+    data: API.Holding[] | undefined;
+    usdc: API.Holding | undefined;
+    isLoading: boolean;
+};
+//# sourceMappingURL=useHoldingStream.d.ts.map

package/esm/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/esm/orderly/useHoldingStream.js

@@ -0,0 +1,47 @@
+import { usePrivateQuery } from "../usePrivateQuery";
+import { useMemo } from "react";
+import { useWS } from "../useWS";
+import useSWRSubscription from "swr/subscription";
+export const useHoldingStream = () => {
+    const ws = useWS();
+    const { data, isLoading, mutate } = usePrivateQuery("/v1/client/holding", {
+        formatter: (data) => {
+            return data.holding;
+        },
+    });
+    const usdc = useMemo(() => {
+        const usdc = data?.find((item) => item.token === "USDC");
+        return usdc;
+    }, [data]);
+    useSWRSubscription("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,
+    };
+};

package/esm/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/esm/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/esm/orderly/useIndexPrice.js

@@ -0,0 +1,17 @@
+import { useWS } from "../useWS";
+import useSWRSubscription from "swr/subscription";
+export const useIndexPrice = (symbol) => {
+    // WARNING: force change perp to spot, because there is no perp now
+    symbol = symbol.replace("PERP", "SPOT");
+    const ws = useWS();
+    return useSWRSubscription(`${symbol}@indexprice`, (key, { next }) => {
+        const unsubscribe = ws.subscribe(`${symbol}@indexprice`, {
+            onMessage: (message) => {
+                next(null, message.price);
+            },
+        });
+        return () => {
+            unsubscribe?.();
+        };
+    });
+};

package/esm/orderly/useLeverage.d.ts

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

package/esm/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/esm/orderly/useLeverage.js

@@ -0,0 +1,34 @@
+import { useCallback } from "react";
+import { useMutation } from "../useMutation";
+import { usePrivateQuery } from "../usePrivateQuery";
+import { prop } from "ramda";
+import { useQuery } from "../useQuery";
+export const useLeverage = () => {
+    const { data, mutate } = usePrivateQuery("/v1/client/info");
+    const [update, { isMutating }] = useMutation("/v1/client/leverage");
+    const { data: config } = useQuery("/v1/public/config");
+    const updateLeverage = useCallback((data) => {
+        return update(data).then((res) => {
+            if (res.success) {
+                return mutate();
+            }
+            else {
+                throw new Error(res.message);
+            }
+            // return res
+        });
+    }, []);
+    return [
+        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))
+                : [],
+        },
+    ];
+};

package/esm/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/esm/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/esm/orderly/useMarginRatio.js

@@ -0,0 +1,41 @@
+import { useMemo } from "react";
+import { account } from "@orderly.network/perp";
+import { usePositionStream } from "./usePositionStream";
+import { useMarkPricesStream } from "./useMarkPricesStream";
+import { useCollateral } from "./useCollateral";
+import { zero } from "@orderly.network/utils";
+export const useMarginRatio = () => {
+    const [{ rows, aggregated }] = usePositionStream();
+    const { data: markPrices } = useMarkPricesStream();
+    const { totalCollateral } = useCollateral();
+    const marginRatio = useMemo(() => {
+        if (!rows || !markPrices || !totalCollateral || rows.length === 0) {
+            return 0;
+        }
+        const ratio = account.totalMarginRatio({
+            totalCollateral: totalCollateral,
+            markPrices: markPrices,
+            positions: rows ?? [],
+        });
+        return ratio;
+    }, [rows, markPrices, totalCollateral]);
+    const currentLeverage = useMemo(() => {
+        return account.currentLeverage(marginRatio);
+    }, [marginRatio]);
+    // MMR
+    const mmr = useMemo(() => {
+        if (!rows || rows.length <= 0)
+            return null;
+        let positionsMM = zero;
+        // const positionsNotional = positions.totalNotional(rows);
+        for (let index = 0; index < rows.length; index++) {
+            const item = rows[index];
+            positionsMM = positionsMM.add(item.mm);
+        }
+        return account.MMR({
+            positionsMMR: positionsMM.toNumber(),
+            positionsNotional: aggregated.notional,
+        });
+    }, [rows, aggregated]);
+    return { marginRatio, currentLeverage, mmr };
+};

package/esm/orderly/useMarkPrice.d.ts

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

package/esm/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/esm/orderly/useMarkPrice.js

@@ -0,0 +1,29 @@
+import { useEffect, useState } from "react";
+import { useWS } from "../useWS";
+// import useSWRSubscription from "swr/subscription";
+export const useMarkPrice = (symbol) => {
+    const ws = useWS();
+    const [price, setPrice] = useState(0);
+    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 };
+};

package/esm/orderly/useMarkPricesStream.d.ts

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

package/esm/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/esm/orderly/useMarkPricesStream.js

@@ -0,0 +1,26 @@
+import useSWRSubscription from "swr/subscription";
+import { useWS } from "../useWS";
+export const useMarkPricesStream = () => {
+    const ws = useWS();
+    return useSWRSubscription("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?.();
+        };
+    });
+};

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