@orderly.network/hooks 1.0.29 → 1.1.1

package/dist/index.d.mts

@@ -1,16 +1,18 @@
 import useSWR, { SWRConfiguration, SWRResponse } from 'swr';
 export { SWRConfig, SWRConfiguration, default as useSWR } from 'swr';
-import * as swr__internal from 'swr/_internal';
 import { SWRMutationConfiguration, SWRMutationResponse } from 'swr/mutation';
 import * as swr_infinite from 'swr/infinite';
 import { SWRInfiniteKeyLoader, SWRInfiniteConfiguration } from 'swr/infinite';
+import * as swr__internal from 'swr/_internal';
 import * as _orderly_network_core from '@orderly.network/core';
 import { AccountState, Account, EventEmitter, ConfigKey, ConfigStore, OrderlyKeyStore, getWalletAdapterFunc, IContract } from '@orderly.network/core';
+export { WalletAdapter } from '@orderly.network/core';
 export { default as useConstant } from 'use-constant';
 import { WS } from '@orderly.network/net';
 import * as react from 'react';
 import { PropsWithChildren } from 'react';
-import { NetworkId, OrderSide, OrderEntity, API, WSMessage, OrderStatus } from '@orderly.network/types';
+import * as _orderly_network_types from '@orderly.network/types';
+import { NetworkId, OrderEntity, OrderSide, API, WSMessage, OrderStatus } from '@orderly.network/types';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as swr_subscription from 'swr/subscription';
 import { Decimal } from '@orderly.network/utils';
@@ -23,9 +25,9 @@ declare global {
         };
     }
 }
-declare const _default: "1.0.29";
+declare const _default: "1.1.1";
 
-declare type useQueryOptions<T> = SWRConfiguration & {
+type useQueryOptions<T> = SWRConfiguration & {
     formatter?: (data: any) => T;
 };
 
@@ -43,13 +45,13 @@ declare const useQuery: <T>(query: Parameters<typeof useSWR>["0"], options?: use
  * @param query
  * @param options
  */
-declare const useLazyQuery: <T, R = any>(query: Parameters<typeof useSWR>["0"], options?: (SWRMutationConfiguration<any, any, swr__internal.Key, any, any> & {
+declare const useLazyQuery: <T, R = any>(query: Parameters<typeof useSWR>["0"], options?: (SWRMutationConfiguration<any, any> & {
     formatter?: ((data: any) => R) | undefined;
     init?: RequestInit | undefined;
 }) | undefined) => SWRMutationResponse;
 
-declare type HTTP_METHOD = "POST" | "PUT" | "DELETE";
-declare const useMutation: <T, E>(url: string, method?: HTTP_METHOD, options?: SWRMutationConfiguration<T, E, swr__internal.Key, any, any> | undefined) => readonly [(data: any, params?: any, options?: any) => Promise<any>, {
+type HTTP_METHOD = "POST" | "PUT" | "DELETE";
+declare const useMutation: <T, E>(url: string, method?: HTTP_METHOD, options?: SWRMutationConfiguration<T, E> | undefined) => readonly [(data: any, params?: any, options?: any) => Promise<any>, {
     readonly data: any;
     readonly error: E | undefined;
     readonly reset: () => void;
@@ -96,7 +98,7 @@ declare function useLocalStorage<T>(key: string, initialValue: T): [any, (value:
 
 declare const useWS: () => WS;
 
-declare const useConfig: <T>(key?: ConfigKey | undefined, defaultValue?: T | undefined) => ConfigStore | T;
+declare const useConfig: <T>(key?: ConfigKey, defaultValue?: T | undefined) => ConfigStore | T;
 
 interface OrderlyConfigContextState {
     fetcher?: (url: string, init: RequestInit) => Promise<any>;
@@ -116,7 +118,7 @@ interface OrderlyConfigContextState {
 declare const OrderlyContext: react.Context<OrderlyConfigContextState>;
 declare const OrderlyProvider: react.Provider<OrderlyConfigContextState>;
 
-declare type RequireAtLeastOne<T, R extends keyof T = keyof T> = Omit<T, R> & {
+type RequireAtLeastOne<T, R extends keyof T = keyof T> = Omit<T, R> & {
     [K in R]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<R, K>>>;
 }[R];
 interface ConfigProviderProps {
@@ -130,14 +132,27 @@ interface ConfigProviderProps {
 }
 declare const OrderlyConfigProvider: (props: PropsWithChildren<RequireAtLeastOne<ConfigProviderProps, "brokerId" | "configStore">>) => react_jsx_runtime.JSX.Element | null;
 
-declare type ConnectedChain = {
-    id: string;
+type ConnectedChain = {
+    id: number | string;
 };
+type WalletAccount = {
+    address: string;
+};
+interface WalletState {
+    label: string;
+    icon: string;
+    provider: any;
+    accounts: WalletAccount[];
+    chains: ConnectedChain[];
+    instance?: unknown;
+}
 interface WalletConnectorContextState {
-    connect: () => Promise<any[]>;
+    connect: () => Promise<WalletState[]>;
     disconnect: (options: any) => Promise<any[]>;
     connecting: boolean;
-    setChain: (options: any) => Promise<any>;
+    setChain: (options: {
+        chainId: string | number;
+    }) => Promise<any>;
     chains: any[];
     wallet: any;
     connectedChain: ConnectedChain | null;
@@ -146,19 +161,19 @@ interface WalletConnectorContextState {
 declare const WalletConnectorContext: react.Context<WalletConnectorContextState>;
 declare const useWalletConnector: () => WalletConnectorContextState;
 
-declare type OrderBookItem = number[];
-declare type OrderbookData = {
+type OrderBookItem = number[];
+type OrderbookData = {
     asks: OrderBookItem[];
     bids: OrderBookItem[];
 };
-declare type OrderbookOptions = {
+type OrderbookOptions = {
     level?: number;
 };
 /**
  * @name useOrderbookStream
  * @description React hook that returns the current orderbook for a given market
  */
-declare const useOrderbookStream: (symbol: string, initial?: OrderbookData, options?: OrderbookOptions | undefined) => ({
+declare const useOrderbookStream: (symbol: string, initial?: OrderbookData, options?: OrderbookOptions) => ({
     asks: OrderBookItem[];
     bids: OrderBookItem[];
     markPrice: any;
@@ -180,29 +195,58 @@ declare const useOrderbookStream: (symbol: string, initial?: OrderbookData, opti
     middlePrice?: undefined;
 })[];
 
-declare type UseOrderEntryOptions = {
+type UseOrderEntryOptions = {
     commify?: boolean;
+    watchOrderbook?: boolean;
     validate?: (data: OrderEntity) => {
         [P in keyof OrderEntity]?: string;
     } | null | undefined;
 };
-/**
- * Create Order
- * @param symbol
- * @returns
- */
-declare const useOrderEntry: (symbol: string, side: OrderSide, reduceOnly?: boolean, options?: UseOrderEntryOptions | undefined) => {
+type UseOrderEntryMetaState = {
+    errors: {
+        [P in keyof OrderEntity]?: {
+            type: string;
+            message: string;
+        };
+    } | null | undefined;
+    dirty: {
+        [P in keyof OrderEntity]?: boolean;
+    } | null | undefined;
+    submitted: boolean;
+};
+type UseOrderEntryReturn = {
     maxQty: number;
     freeCollateral: number;
-    markPrice: any;
-    onSubmit: (values: OrderEntity) => Promise<any>;
+    markPrice: number;
+    estLiqPrice?: number | null;
+    estLeverage?: number | null;
+    onSubmit: (order: OrderEntity) => Promise<any>;
+    submit: () => Promise<OrderEntity>;
     submitting: boolean;
+    formattedOrder: Partial<OrderEntity>;
     helper: {
-        calculate: (values: any, field: string, value: any) => unknown;
-        validator: (values: any) => any;
+        calculate: (values: Partial<OrderEntity>, field: keyof OrderEntity, value: any) => Partial<OrderEntity>;
+        validator: (values: Partial<OrderEntity>) => any;
     };
-    symbolConfig: any;
+    metaState: UseOrderEntryMetaState;
+    symbolConfig: API.SymbolExt;
 };
+type OrderParams = Required<Pick<OrderEntity, "side" | "order_type" | "symbol">> & Partial<Omit<OrderEntity, "side" | "symbol" | "order_type">>;
+/**
+ * Create Order
+ * @example
+ * ```tsx
+ * const { formattedOrder, onSubmit, helper } = useOrderEntry({
+ *  symbol: "PERP_ETH_USDC",
+ *  side: OrderSide.BUY,
+ *  order_type: OrderType.LIMIT,
+ *  order_price: 10000,
+ *  order_quantity: 1,
+ * });
+ * ```
+ */
+declare function useOrderEntry(order: OrderParams, options?: UseOrderEntryOptions): UseOrderEntryReturn;
+declare function useOrderEntry(symbol: string, side: OrderSide, reduceOnly: boolean): UseOrderEntryReturn;
 
 declare const useSymbolsInfo: () => Record<string, any>;
 
@@ -212,6 +256,41 @@ declare const useMarketsStream: () => {
     data: WSMessage.Ticker[] | null;
 };
 
+declare enum MarketsType {
+    FAVORITES = 0,
+    RECENT = 1,
+    ALL = 2
+}
+interface FavoriteTab {
+    name: string;
+    id: number;
+}
+interface Favorite {
+    name: string;
+    tabs: FavoriteTab[];
+}
+interface Recent {
+    name: string;
+}
+declare const useMarkets: (type: MarketsType) => readonly [_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;
+}];
+
 declare const useMarkPricesStream: () => swr_subscription.SWRSubscriptionResponse<any, any>;
 
 declare const useMarkPrice: (symbol: string) => swr_subscription.SWRSubscriptionResponse<any, any>;
@@ -233,7 +312,10 @@ declare const useFundingRate: (symbol: string) => {
     sum_unitary_funding?: number | undefined;
 };
 
-declare const usePositionStream: (symbol?: string | undefined, options?: Partial<swr__internal.PublicConfiguration<any, any, swr__internal.BareFetcher<any>>> | undefined) => readonly [{
+type PriceMode = "markPrice" | "lastPrice";
+declare const usePositionStream: (symbol?: string, options?: SWRConfiguration & {
+    calcMode?: PriceMode;
+}) => readonly [{
     readonly rows: API.PositionExt[] | null;
     readonly aggregated: any;
     readonly totalCollateral: Decimal;
@@ -242,11 +324,10 @@ declare const usePositionStream: (symbol?: string | undefined, options?: Partial
 }, any, {
     readonly loading: false;
     readonly error: any;
-    readonly loadMore: () => void;
-    readonly refresh: () => void;
+    readonly refresh: swr__internal.KeyedMutator<API.PositionInfo>;
 }];
 
-declare type Params = {
+type Params = {
     symbol?: string;
     status?: OrderStatus;
     size?: number;
@@ -255,17 +336,24 @@ declare type Params = {
 declare const useOrderStream: (params: Params) => readonly [any[] | null, {
     readonly total: any;
     readonly isLoading: boolean;
+    readonly refresh: swr__internal.KeyedMutator<any[]>;
     readonly loadMore: () => void;
     readonly cancelAllOrders: () => void;
     readonly updateOrder: (orderId: string, order: OrderEntity) => Promise<any>;
-    readonly cancelOrder: (orderId: string, symbol?: string | undefined) => Promise<any>;
+    readonly cancelOrder: (orderId: number, symbol?: string) => Promise<any>;
+    readonly updateAlgoOrder: (orderId: string, order: OrderEntity) => Promise<any>;
+    readonly cancelAlgoOrder: (orderId: number, symbol?: string) => Promise<any>;
     readonly errors: {
         readonly cancelOrder: unknown;
         readonly updateOrder: unknown;
+        readonly cancelAlgoOrder: unknown;
+        readonly updateAlgoOrder: unknown;
     };
     readonly submitting: {
         readonly cancelOrder: boolean;
         readonly updateOrder: boolean;
+        readonly cancelAlgoOrder: boolean;
+        readonly updateAlglOrder: boolean;
     };
 }];
 
@@ -277,37 +365,41 @@ declare const useMarketTradeStream: (symbol: string, options?: MarketTradeStream
     isLoading: boolean;
 };
 
-declare type CollateralOutputs = {
+type CollateralOutputs = {
     totalCollateral: number;
     freeCollateral: number;
     totalValue: number;
     availableBalance: number;
     unsettledPnL: number;
+    positions: API.Position[];
+    accountInfo?: API.AccountInfo;
 };
-declare type Options = {
+type Options = {
     dp: number;
 };
 declare const useCollateral: (options?: Options) => CollateralOutputs;
 
 declare const useMaxQty: (symbol: string, side: OrderSide, reduceOnly?: boolean) => number;
 
-declare const useMarginRatio: () => {
+type MarginRatioReturn = {
     marginRatio: number;
     currentLeverage: number;
+    mmr: number | null;
 };
+declare const useMarginRatio: () => MarginRatioReturn;
 
-declare type inputOptions = {
+type inputOptions = {
     filter?: (item: API.Chain) => boolean;
     pick?: "dexs" | "network_infos" | "token_infos";
     crossEnabled?: boolean;
     /** if true, use wooSwap api, else use orderly api only  */
     wooSwapEnabled?: boolean;
 };
-declare const useChains: (networkId?: NetworkId | undefined, options?: inputOptions & SWRConfiguration) => readonly [API.Chain[] | {
+declare const useChains: (networkId?: NetworkId, options?: inputOptions & SWRConfiguration) => readonly [API.Chain[] | {
     testnet: API.Chain[];
     mainnet: API.Chain[];
 }, {
-    readonly findByChainId: (chainId: number, field?: string | undefined) => (API.Chain & {
+    readonly findByChainId: (chainId: number, field?: string) => (API.Chain & {
         nativeToken?: API.TokenInfo | undefined;
     }) | (<K extends never>(prop: K) => ((API.Chain & {
         nativeToken?: API.TokenInfo | undefined;
@@ -324,16 +416,17 @@ declare const useWithdraw: () => {
     withdraw: (inputs: {
         chainId: number;
         token: string;
-        amount: number;
+        amount: string;
         allowCrossChainWithdraw: boolean;
     }) => Promise<any>;
     isLoading: boolean;
     maxAmount: number;
     availableBalance: number;
+    availableWithdraw: number;
     unsettledPnL: number;
 };
 
-declare type useDepositOptions = {
+type useDepositOptions = {
     address?: string;
     decimals?: number;
     crossChainRouteAddress?: string;
@@ -341,12 +434,14 @@ declare type useDepositOptions = {
     networkId?: NetworkId;
     srcChainId?: number;
     srcToken?: string;
+    quantity?: string;
     /**
      * @hidden
      */
     wooSwapEnabled?: boolean;
 };
-declare const useDeposit: (options?: useDepositOptions | undefined) => {
+declare const useDeposit: (options?: useDepositOptions) => {
+    /** orderly support chain dst */
     dst: {
         symbol: string;
         address: string | undefined;
@@ -359,10 +454,18 @@ declare const useDeposit: (options?: useDepositOptions | undefined) => {
     isNativeToken: boolean;
     balanceRevalidating: boolean;
     allowanceRevalidating: boolean;
-    approve: (amount: string | undefined) => Promise<any>;
-    deposit: (amount: string) => Promise<any>;
+    /** input quantiy */
+    quantity: string;
+    /** orderly deposit fee, unit: wei */
+    depositFee: bigint;
+    /** enquiring depositFee status on chain */
+    depositFeeRevalidating: boolean;
+    approve: (amount?: string) => Promise<any>;
+    deposit: () => Promise<any>;
     fetchBalances: (tokens: API.TokenInfo[]) => Promise<void>;
-    fetchBalance: (address: string, decimals?: number | undefined) => Promise<string>;
+    fetchBalance: (address: string, decimals?: number) => Promise<string>;
+    /** set input quantity */
+    setQuantity: react.Dispatch<react.SetStateAction<string>>;
 };
 
 declare const useHoldingStream: () => {
@@ -379,7 +482,24 @@ declare const useSettleSubscription: (options?: {
     onMessage?: ((data: any) => void) | undefined;
 } | undefined) => swr_subscription.SWRSubscriptionResponse<any, any>;
 
-declare const usePrivateDataObserver: () => void;
+type getKeyFunction = (index: number, prevData: any) => string | null;
+
+declare const usePrivateDataObserver: (options: {
+    getKeysMap: (type: string) => Map<string, getKeyFunction>;
+}) => void;
+
+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
+ */
+declare const useSymbolPriceRange: (symbol: string, side: "BUY" | "SELL", price?: number) => PriceRange | undefined;
 
 declare function useMediaQuery(query: string): boolean;
 
@@ -408,4 +528,4 @@ declare const useCrossSwap: () => any;
 /** @hidden */
 declare const useSwap: () => any;
 
-export { ConfigProviderProps, OrderlyConfigContextState, OrderlyConfigProvider, OrderlyContext, OrderlyProvider, WalletConnectorContext, useAccount, useAccountInfo, useAccountInstance, useBoolean, useChain, useChains, useCollateral, useConfig, useCrossSwap, useDeposit, useEventEmitter, useFundingRate, useHoldingStream, useIndexPrice, useLazyQuery, useLeverage, useLocalStorage, useMarginRatio, useMarkPrice, useMarkPricesStream, useMarketTradeStream, useMarketsStream, useMaxQty, useMediaQuery, useMutation, useOrderEntry, useOrderStream, useOrderbookStream, usePositionStream, usePreLoadData, usePrivateDataObserver, usePrivateInfiniteQuery, usePrivateQuery, useQuery, useSessionStorage, useSettleSubscription, useSwap, useSymbolsInfo, useTickerStream, useWS, useWalletConnector, useWalletSubscription, useWithdraw, useWooCrossSwapQuery, useWooSwapQuery, _default as version };
+export { ConfigProviderProps, Favorite, FavoriteTab, MarketsType, OrderlyConfigContextState, OrderlyConfigProvider, OrderlyContext, OrderlyProvider, Recent, UseOrderEntryMetaState, WalletConnectorContext, useAccount, useAccountInfo, useAccountInstance, useBoolean, useChain, useChains, useCollateral, useConfig, useCrossSwap, useDeposit, useEventEmitter, useFundingRate, useHoldingStream, useIndexPrice, useLazyQuery, useLeverage, useLocalStorage, useMarginRatio, useMarkPrice, useMarkPricesStream, useMarketTradeStream, useMarkets, useMarketsStream, useMaxQty, useMediaQuery, useMutation, useOrderEntry, useOrderStream, useOrderbookStream, usePositionStream, usePreLoadData, usePrivateDataObserver, usePrivateInfiniteQuery, usePrivateQuery, useQuery, useSessionStorage, useSettleSubscription, useSwap, useSymbolPriceRange, useSymbolsInfo, useTickerStream, useWS, useWalletConnector, useWalletSubscription, useWithdraw, useWooCrossSwapQuery, useWooSwapQuery, _default as version };