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

package/lib/orderly/useChains.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateTestnetInfo = exports.updateOrderlyChains = exports.fillChainsInfo = exports.useChains = void 0;
+const types_1 = require("@orderly.network/types");
+const react_1 = require("react");
+const useQuery_1 = require("../useQuery");
+const ramda_1 = require("ramda");
+const utils_1 = require("@orderly.network/utils");
+const types_2 = require("@orderly.network/types");
+function useChains(networkId, options = {}) {
+    const { pick: pickField, ...swrOptions } = options;
+    const filterFun = (0, react_1.useRef)(options?.filter);
+    filterFun.current = options?.filter;
+    const chainsMap = (0, react_1.useRef)(new Map());
+    const commonSwrOpts = {
+        revalidateIfStale: false,
+        revalidateOnFocus: false,
+        revalidateOnReconnect: false,
+        // If false, undefined data gets cached against the key.
+        revalidateOnMount: true,
+        // dont duplicate a request w/ same key for 1hr
+        dedupingInterval: 3600000,
+        ...swrOptions,
+    };
+    // only prod env return mainnet chains info
+    // TODO: remove https://api-evm.orderly.org api base
+    const { data: tokenChains, error: tokenError } = (0, useQuery_1.useQuery)("https://api-evm.orderly.org/v1/public/token", { ...commonSwrOpts });
+    // only prod env return mainnet chains info
+    const { data: chainInfos, error: chainInfoErr } = (0, useQuery_1.useQuery)("/v1/public/chain_info", { ...commonSwrOpts });
+    const chains = (0, react_1.useMemo)(() => {
+        const orderlyChainsArr = fillChainsInfo(tokenChains, filterFun.current);
+        let testnetArr = [...types_2.TestnetChains];
+        orderlyChainsArr?.forEach((item) => {
+            const chainId = item.network_infos?.chain_id;
+            chainsMap.current.set(chainId, item);
+            updateTestnetInfo(testnetArr, chainId, item);
+        });
+        testnetArr.forEach((chain) => {
+            chainsMap.current.set(chain.network_infos?.chain_id, chain);
+        });
+        let mainnetArr = [];
+        // TODO: /v1/public/chain_info api data is not match /v1/public/token api data, so it can effect is prod
+        mainnetArr = updateOrderlyChains(orderlyChainsArr, chainInfos, filterFun.current);
+        mainnetArr.forEach((item) => {
+            const chainId = item.network_infos?.chain_id;
+            chainsMap.current.set(chainId, item);
+            updateTestnetInfo(testnetArr, chainId, item);
+        });
+        mainnetArr.sort((a, b) => {
+            return a.network_infos.bridgeless ? -1 : 1;
+        });
+        testnetArr.sort((a, b) => {
+            return a.network_infos.bridgeless ? -1 : 1;
+        });
+        if (!!pickField) {
+            //@ts-ignore
+            testnetArr = testnetArr.map((item) => item[pickField]);
+            //@ts-ignore
+            mainnetArr = mainnetArr.map((item) => item[pickField]);
+        }
+        if (networkId === "mainnet") {
+            return mainnetArr;
+        }
+        if (networkId === "testnet") {
+            return testnetArr;
+        }
+        return {
+            testnet: testnetArr,
+            mainnet: mainnetArr,
+        };
+    }, [networkId, tokenChains, chainInfos, pickField]);
+    const findByChainId = (0, react_1.useCallback)((chainId, field) => {
+        const chain = chainsMap.current.get(chainId);
+        if (chain) {
+            chain.nativeToken =
+                chain.token_infos?.find((item) => item.address === types_2.nativeTokenAddress) ||
+                    {
+                        symbol: chain.network_infos?.currency_symbol,
+                    };
+        }
+        if (typeof field === "string") {
+            return (0, ramda_1.prop)(field, chain);
+        }
+        return chain;
+    }, [chains, chainsMap]);
+    return [
+        chains,
+        {
+            findByChainId,
+            error: tokenError,
+        },
+    ];
+}
+exports.useChains = useChains;
+/** orderly chains array form (/v1/public/token) api */
+function fillChainsInfo(chains, filter) {
+    let _chains = [];
+    chains?.forEach((item) => {
+        item.chain_details.forEach((chain) => {
+            const chainId = Number(chain.chain_id);
+            const chainInfo = types_1.chainsInfoMap.get(chainId);
+            const _chain = {
+                network_infos: {
+                    name: chain.chain_name ?? chainInfo?.chainName ?? "--",
+                    chain_id: chainId,
+                    withdrawal_fee: chain.withdrawal_fee,
+                    cross_chain_withdrawal_fee: chain.cross_chain_withdrawal_fee,
+                    bridgeless: true,
+                },
+                token_infos: [
+                    {
+                        symbol: item.token,
+                        address: chain.contract_address,
+                        decimals: chain.decimals,
+                    },
+                ],
+            };
+            if (typeof filter === "function") {
+                if (!filter(_chain))
+                    return;
+            }
+            _chains.push(_chain);
+        });
+    });
+    return _chains;
+}
+exports.fillChainsInfo = fillChainsInfo;
+/** update network_infos by chain_info api(v1/public/chain_info) */
+function updateOrderlyChains(chains, chainInfos, filter) {
+    const _chains = [];
+    chains.forEach((chain) => {
+        let _chain = { ...chain };
+        const networkInfo = chainInfos?.find((item) => item.chain_id == chain.network_infos.chain_id);
+        if (networkInfo) {
+            const { name, public_rpc_url, currency_symbol, explorer_base_url } = networkInfo;
+            _chain.network_infos = {
+                ..._chain.network_infos,
+                name,
+                shortName: name,
+                public_rpc_url,
+                currency_symbol,
+                bridge_enable: true,
+                mainnet: true,
+                explorer_base_url,
+                est_txn_mins: null,
+            };
+        }
+        if (typeof filter === "function") {
+            if (!filter(_chain))
+                return;
+        }
+        _chains.push(_chain);
+    });
+    return _chains;
+}
+exports.updateOrderlyChains = updateOrderlyChains;
+/** if chain is testnet, update testnet network_infos */
+function updateTestnetInfo(testnetArr, chainId, chain) {
+    if ((0, utils_1.isTestnet)(chainId)) {
+        const index = testnetArr?.findIndex((item) => item.network_infos.chain_id === chainId);
+        if (index > -1) {
+            testnetArr[index] = chain;
+        }
+    }
+}
+exports.updateTestnetInfo = updateTestnetInfo;

package/lib/orderly/useCollateral.d.ts

@@ -0,0 +1,16 @@
+import { type API } from "@orderly.network/types";
+export type CollateralOutputs = {
+    totalCollateral: number;
+    freeCollateral: number;
+    totalValue: number;
+    availableBalance: number;
+    unsettledPnL: number;
+    positions: API.Position[];
+    accountInfo?: API.AccountInfo;
+};
+type Options = {
+    dp: number;
+};
+export declare const useCollateral: (options?: Options) => CollateralOutputs;
+export {};
+//# sourceMappingURL=useCollateral.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCollateral.d.ts","sourceRoot":"","sources":["../../src/orderly/useCollateral.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,GAAG,EAAe,MAAM,wBAAwB,CAAC;AAO/D,MAAM,MAAM,iBAAiB,GAAG;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IAErB,SAAS,EAAE,GAAG,CAAC,QAAQ,EAAE,CAAC;IAC1B,WAAW,CAAC,EAAE,GAAG,CAAC,WAAW,CAAC;CAC/B,CAAC;AAKF,KAAK,OAAO,GAAG;IACb,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF,eAAO,MAAM,aAAa,aACf,OAAO,KACf,iBA0EF,CAAC"}

package/lib/orderly/useCollateral.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCollateral = void 0;
+const react_1 = require("react");
+const usePrivateQuery_1 = require("../usePrivateQuery");
+const usePositionStream_1 = require("./usePositionStream");
+const ramda_1 = require("ramda");
+const perp_1 = require("@orderly.network/perp");
+const types_1 = require("@orderly.network/types");
+const useSymbolsInfo_1 = require("./useSymbolsInfo");
+const utils_1 = require("@orderly.network/utils");
+const useMarkPricesStream_1 = require("./useMarkPricesStream");
+const useHoldingStream_1 = require("./useHoldingStream");
+const useOrderStream_1 = require("./useOrderStream");
+const positionsPath = (0, ramda_1.pathOr)([], [0, "rows"]);
+const totalCollateralPath = (0, ramda_1.pathOr)(0, [0, "totalCollateral"]);
+const useCollateral = (options = { dp: 6 }) => {
+    const { dp } = options;
+    const positions = (0, usePositionStream_1.usePositionStream)();
+    const [orders] = (0, useOrderStream_1.useOrderStream)({ status: types_1.OrderStatus.NEW });
+    const { data: accountInfo } = (0, usePrivateQuery_1.usePrivateQuery)("/v1/client/info");
+    const symbolInfo = (0, useSymbolsInfo_1.useSymbolsInfo)();
+    const { data: markPrices } = (0, useMarkPricesStream_1.useMarkPricesStream)();
+    const { usdc } = (0, useHoldingStream_1.useHoldingStream)();
+    const filterAlgoOrders = orders?.filter((item) => item.algo_order_id === undefined) ?? [];
+    // const { data: holding } = usePrivateQuery<API.Holding[]>(
+    //   "/v1/client/holding",
+    //   {
+    //     formatter: (data) => {
+    //       return data.holding;
+    //     },
+    //   }
+    // );
+    const [totalCollateral, totalValue] = (0, react_1.useMemo)(() => {
+        return [
+            (0, ramda_1.pathOr)(utils_1.zero, [0, "totalCollateral"], positions),
+            (0, ramda_1.pathOr)(utils_1.zero, [0, "totalValue"], positions),
+        ];
+    }, [positions, markPrices]);
+    const totalInitialMarginWithOrders = (0, react_1.useMemo)(() => {
+        if (!accountInfo || !symbolInfo || !markPrices) {
+            return 0;
+        }
+        return perp_1.account.totalInitialMarginWithOrders({
+            positions: positionsPath(positions),
+            orders: filterAlgoOrders,
+            markPrices,
+            IMR_Factors: accountInfo.imr_factor,
+            maxLeverage: accountInfo.max_leverage,
+            symbolInfo,
+        });
+    }, [positions, filterAlgoOrders, markPrices, accountInfo, symbolInfo]);
+    const freeCollateral = (0, react_1.useMemo)(() => {
+        return perp_1.account.freeCollateral({
+            totalCollateral,
+            totalInitialMarginWithOrders,
+        });
+    }, [totalCollateral, totalInitialMarginWithOrders]);
+    const availableBalance = (0, react_1.useMemo)(() => {
+        return perp_1.account.availableBalance({
+            USDCHolding: usdc?.holding ?? 0,
+            unsettlementPnL: (0, usePositionStream_1.pathOr_unsettledPnLPathOr)(positions),
+        });
+    }, [usdc?.holding, (0, usePositionStream_1.pathOr_unsettledPnLPathOr)(positions)]);
+    return {
+        totalCollateral: totalCollateral.toDecimalPlaces(dp).toNumber(),
+        freeCollateral: freeCollateral.toDecimalPlaces(dp).toNumber(),
+        totalValue: totalValue.toDecimalPlaces(dp).toNumber(),
+        availableBalance,
+        unsettledPnL: (0, usePositionStream_1.pathOr_unsettledPnLPathOr)(positions),
+        accountInfo,
+        // @hidden
+        positions: positionsPath(positions),
+    };
+};
+exports.useCollateral = useCollateral;

package/lib/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/lib/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/lib/orderly/useDeposit.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDeposit = void 0;
+const react_1 = require("react");
+const useAccount_1 = require("../useAccount");
+const types_1 = require("@orderly.network/types");
+const utils_1 = require("@orderly.network/utils");
+const useChains_1 = require("./useChains");
+const useConfig_1 = require("../useConfig");
+const use_debounce_1 = require("use-debounce");
+const useDeposit = (options) => {
+    const networkId = (0, useConfig_1.useConfig)("networkId");
+    const [balanceRevalidating, setBalanceRevalidating] = (0, react_1.useState)(false);
+    const [allowanceRevalidating, setAllowanceRevalidating] = (0, react_1.useState)(false);
+    const [_, { findByChainId }] = (0, useChains_1.useChains)(undefined);
+    const [quantity, setQuantity] = (0, react_1.useState)("");
+    const [depositFee, setDepositFee] = (0, react_1.useState)(0n);
+    const [depositFeeRevalidating, setDepositFeeRevalidating] = (0, react_1.useState)(false);
+    const [balance, setBalance] = (0, react_1.useState)("0");
+    const [allowance, setAllowance] = (0, react_1.useState)("0");
+    const { account, state } = (0, useAccount_1.useAccount)();
+    const prevAddress = (0, react_1.useRef)();
+    const getBalanceListener = (0, react_1.useRef)();
+    const targetChain = (0, react_1.useMemo)(() => {
+        let chain;
+        // Orderly testnet supported chain
+        if (networkId === "testnet") {
+            chain = findByChainId(types_1.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(types_1.ARBITRUM_MAINNET_CHAINID);
+            }
+        }
+        return chain;
+    }, [networkId, findByChainId, options?.srcChainId]);
+    const dst = (0, react_1.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 = (0, react_1.useMemo)(() => (0, types_1.isNativeTokenChecker)(options?.address || ""), [options?.address]);
+    const fetchBalanceHandler = (0, react_1.useCallback)(async (address, decimals) => {
+        let balance;
+        if (!!address && (0, types_1.isNativeTokenChecker)(address)) {
+            balance = await account.assetsManager.getNativeBalance({
+                decimals,
+            });
+        }
+        else {
+            balance = await account.assetsManager.getBalance(address, { decimals });
+        }
+        return balance;
+    }, []);
+    const fetchBalance = (0, react_1.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 = (0, react_1.useCallback)(async (tokens) => {
+        const tasks = [];
+        for (const token of tokens) {
+            // native token skip
+            if ((0, types_1.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 && (0, types_1.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 || (0, types_1.isNativeTokenChecker)(address))
+            return;
+        prevAddress.current = address;
+        const allowance = await account.assetsManager.getAllowance(address);
+        setAllowance(() => allowance);
+    };
+    const queryBalance = (0, use_debounce_1.useDebouncedCallback)((tokenAddress, decimals) => {
+        fetchBalance(options?.address, options?.decimals).finally(() => {
+            setBalanceRevalidating(false);
+        });
+    }, 100);
+    const queryAllowance = (0, use_debounce_1.useDebouncedCallback)((tokenAddress, vaultAddress) => {
+        getAllowance(tokenAddress, vaultAddress);
+    }, 100);
+    (0, react_1.useEffect)(() => {
+        if (state.status < types_1.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 = (0, react_1.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 = (0, react_1.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 utils_1.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 = (0, react_1.useCallback)(async (quantity) => {
+        return account.assetsManager.getDepositFee(quantity, targetChain?.network_infos);
+    }, [account, targetChain]);
+    const enquiryDepositFee = (0, react_1.useCallback)(() => {
+        if (isNaN(Number(quantity)) || !quantity) {
+            setDepositFee(0n);
+            setDepositFeeRevalidating(false);
+            return;
+        }
+        setDepositFeeRevalidating(true);
+        getDepositFee(quantity)
+            .then((res = 0n) => {
+            const fee = BigInt(new utils_1.Decimal(res.toString())
+                .mul(types_1.DEPOSIT_FEE_RATE)
+                .toFixed(0, utils_1.Decimal.ROUND_UP)
+                .toString());
+            setDepositFee(fee);
+            console.log("getDepositFee", fee);
+        })
+            .catch((error) => {
+            console.log("getDepositFee error", error);
+        })
+            .finally(() => {
+            setDepositFeeRevalidating(false);
+        });
+    }, [quantity]);
+    (0, react_1.useEffect)(() => {
+        enquiryDepositFee();
+    }, [quantity]);
+    (0, react_1.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,
+    };
+};
+exports.useDeposit = useDeposit;

package/lib/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/lib/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/lib/orderly/useFundingRate.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFundingRate = void 0;
+const useQuery_1 = require("../useQuery");
+const react_1 = require("react");
+const utils_1 = require("@orderly.network/utils");
+const useFundingRate = (symbol) => {
+    if (!symbol) {
+        throw new Error("useFuturesForSymbol requires a symbol");
+    }
+    const [countDown, setCountDown] = (0, react_1.useState)("00:00:00");
+    const { data } = (0, useQuery_1.useQuery)(`/v1/public/funding_rate/${symbol}`, {
+        fallbackData: {
+            est_funding_rate: 0,
+            next_funing_time: 0,
+        },
+    });
+    (0, react_1.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 = (0, utils_1.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,
+    };
+};
+exports.useFundingRate = useFundingRate;

package/lib/orderly/useFundingRates.d.ts

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

package/lib/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/lib/orderly/useFundingRates.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFundingRates = void 0;
+const useQuery_1 = require("../useQuery");
+const createGetter_1 = require("../utils/createGetter");
+const useFundingRates = () => {
+    const { data } = (0, useQuery_1.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 (0, createGetter_1.createGetter)(data);
+};
+exports.useFundingRates = useFundingRates;

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