@orderly.network/hooks 1.0.25-alpha.8 → 1.0.25

package/dist/index.d.mts

@@ -0,0 +1,410 @@
+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 _orderly_network_core from '@orderly.network/core';
+import { AccountState, Account, EventEmitter, ConfigKey, ConfigStore, OrderlyKeyStore, getWalletAdapterFunc, IContract } 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 react_jsx_runtime from 'react/jsx-runtime';
+import * as swr_subscription from 'swr/subscription';
+import { Decimal } from '@orderly.network/utils';
+export * from 'use-debounce';
+
+declare global {
+    interface Window {
+        __ORDERLY_VERSION__?: {
+            [key: string]: string;
+        };
+    }
+}
+declare const _default: "1.0.25";
+
+declare type useQueryOptions<T> = SWRConfiguration & {
+    formatter?: (data: any) => T;
+};
+
+/**
+ * useQuery
+ * @description for public api
+ * @param query
+ * @param options
+ */
+declare const useQuery: <T>(query: Parameters<typeof useSWR>["0"], options?: useQueryOptions<T> | undefined) => SWRResponse<T, any, any>;
+
+/**
+ * useQuery
+ * @description for public api
+ * @param query
+ * @param options
+ */
+declare const useLazyQuery: <T, R = any>(query: Parameters<typeof useSWR>["0"], options?: (SWRMutationConfiguration<any, any, swr__internal.Key, 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>, {
+    readonly data: any;
+    readonly error: E | undefined;
+    readonly reset: () => void;
+    readonly isMutating: boolean;
+}];
+
+/**
+ * usePrivateQuery
+ * @description for private api
+ * @param query
+ * @param options
+ */
+declare const usePrivateQuery: <T>(query: string, options?: useQueryOptions<T> | undefined) => SWRResponse<T, any, any>;
+
+declare const usePrivateInfiniteQuery: (getKey: SWRInfiniteKeyLoader, options?: (SWRInfiniteConfiguration<any, any, swr__internal.BareFetcher<any>> & {
+    formatter?: ((data: any) => any) | undefined;
+}) | undefined) => swr_infinite.SWRInfiniteResponse<any, any>;
+
+declare const useBoolean: (initialValue?: boolean) => [boolean, {
+    setTrue: () => void;
+    setFalse: () => void;
+    toggle: () => void;
+}];
+
+declare const useAccount: () => {
+    account: _orderly_network_core.Account;
+    state: AccountState;
+    createOrderlyKey: (remember: boolean) => Promise<any>;
+    createAccount: () => Promise<any>;
+};
+
+declare const useAccountInstance: () => Account;
+
+declare const usePreLoadData: () => {
+    error: any;
+    done: boolean;
+};
+
+declare const useEventEmitter: () => EventEmitter<string | symbol, any>;
+
+declare function useSessionStorage<T>(key: string, initialValue: T): [T, (data: any) => void];
+
+declare function useLocalStorage<T>(key: string, initialValue: T): [any, (value: T) => void];
+
+declare const useWS: () => WS;
+
+declare const useConfig: <T>(key?: ConfigKey | undefined, defaultValue?: T | undefined) => ConfigStore | T;
+
+interface OrderlyConfigContextState {
+    fetcher?: (url: string, init: RequestInit) => Promise<any>;
+    configStore: ConfigStore;
+    keyStore: OrderlyKeyStore;
+    getWalletAdapter: getWalletAdapterFunc;
+    networkId: NetworkId;
+    /**
+     * @hidden
+     */
+    onlyTestnet?: boolean;
+    /**
+     * @hidden
+     */
+    enableSwapDeposit?: boolean;
+}
+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> & {
+    [K in R]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<R, K>>>;
+}[R];
+interface ConfigProviderProps {
+    configStore?: ConfigStore;
+    keyStore?: OrderlyKeyStore;
+    contracts?: IContract;
+    getWalletAdapter?: getWalletAdapterFunc;
+    brokerId: string;
+    networkId: NetworkId;
+    enableSwapDeposit?: boolean;
+}
+declare const OrderlyConfigProvider: (props: PropsWithChildren<RequireAtLeastOne<ConfigProviderProps, "brokerId" | "configStore">>) => react_jsx_runtime.JSX.Element | null;
+
+declare type ConnectedChain = {
+    id: string;
+};
+interface WalletConnectorContextState {
+    connect: () => Promise<any[]>;
+    disconnect: (options: any) => Promise<any[]>;
+    connecting: boolean;
+    setChain: (options: any) => Promise<any>;
+    chains: any[];
+    wallet: any;
+    connectedChain: ConnectedChain | null;
+    settingChain: boolean;
+}
+declare const WalletConnectorContext: react.Context<WalletConnectorContextState>;
+declare const useWalletConnector: () => WalletConnectorContextState;
+
+declare type OrderBookItem = number[];
+declare type OrderbookData = {
+    asks: OrderBookItem[];
+    bids: OrderBookItem[];
+};
+declare 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) => ({
+    asks: OrderBookItem[];
+    bids: OrderBookItem[];
+    markPrice: any;
+    middlePrice: number[];
+    onDepthChange?: undefined;
+    depth?: undefined;
+    allDepths?: undefined;
+    isLoading?: undefined;
+    onItemClick?: undefined;
+} | {
+    onDepthChange: (depth: number) => void;
+    depth: number | undefined;
+    allDepths: any[];
+    isLoading: boolean;
+    onItemClick: (item: OrderBookItem) => void;
+    asks?: undefined;
+    bids?: undefined;
+    markPrice?: undefined;
+    middlePrice?: undefined;
+})[];
+
+declare type UseOrderEntryOptions = {
+    commify?: 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) => {
+    maxQty: number;
+    freeCollateral: number;
+    markPrice: any;
+    onSubmit: (values: OrderEntity) => Promise<any>;
+    submitting: boolean;
+    helper: {
+        calculate: (values: any, field: string, value: any) => unknown;
+        validator: (values: any) => any;
+    };
+    symbolConfig: any;
+};
+
+declare const useSymbolsInfo: () => Record<string, any>;
+
+declare const useAccountInfo: () => swr__internal.SWRResponse<API.AccountInfo, any, any>;
+
+declare const useMarketsStream: () => {
+    data: WSMessage.Ticker[] | null;
+};
+
+declare const useMarkPricesStream: () => swr_subscription.SWRSubscriptionResponse<any, any>;
+
+declare const useMarkPrice: (symbol: string) => swr_subscription.SWRSubscriptionResponse<any, any>;
+
+declare const useIndexPrice: (symbol: string) => swr_subscription.SWRSubscriptionResponse<any, any>;
+
+declare const useLeverage: () => any;
+
+declare const useTickerStream: (symbol: string) => API.MarketInfo;
+
+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;
+};
+
+declare const usePositionStream: (symbol?: string | undefined, options?: Partial<swr__internal.PublicConfiguration<any, any, swr__internal.BareFetcher<any>>> | undefined) => readonly [{
+    readonly rows: API.PositionExt[] | null;
+    readonly aggregated: any;
+    readonly totalCollateral: Decimal;
+    readonly totalValue: Decimal;
+    readonly totalUnrealizedROI: number;
+}, any, {
+    readonly loading: false;
+    readonly error: any;
+    readonly loadMore: () => void;
+    readonly refresh: () => void;
+}];
+
+declare type Params = {
+    symbol?: string;
+    status?: OrderStatus;
+    size?: number;
+    side?: OrderSide;
+};
+declare const useOrderStream: (params: Params) => readonly [any[] | null, {
+    readonly total: any;
+    readonly isLoading: boolean;
+    readonly loadMore: () => void;
+    readonly cancelAllOrders: () => void;
+    readonly updateOrder: (orderId: string, order: OrderEntity) => Promise<any>;
+    readonly cancelOrder: (orderId: string, symbol?: string | undefined) => Promise<any>;
+    readonly errors: {
+        readonly cancelOrder: unknown;
+        readonly updateOrder: unknown;
+    };
+    readonly submitting: {
+        readonly cancelOrder: boolean;
+        readonly updateOrder: boolean;
+    };
+}];
+
+interface MarketTradeStreamOptions {
+    limit?: number;
+}
+declare const useMarketTradeStream: (symbol: string, options?: MarketTradeStreamOptions) => {
+    data: API.Trade[];
+    isLoading: boolean;
+};
+
+declare type CollateralOutputs = {
+    totalCollateral: number;
+    freeCollateral: number;
+    totalValue: number;
+    availableBalance: number;
+    unsettledPnL: number;
+};
+declare type Options = {
+    dp: number;
+};
+declare const useCollateral: (options?: Options) => CollateralOutputs;
+
+declare const useMaxQty: (symbol: string, side: OrderSide, reduceOnly?: boolean) => number;
+
+declare const useMarginRatio: () => {
+    marginRatio: number;
+    currentLeverage: number;
+};
+
+declare 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[] | {
+    testnet: API.Chain[];
+    mainnet: API.Chain[];
+}, {
+    readonly findByChainId: (chainId: number, field?: string | undefined) => (API.Chain & {
+        nativeToken?: API.TokenInfo | undefined;
+    }) | (<K extends never>(prop: K) => ((API.Chain & {
+        nativeToken?: API.TokenInfo | undefined;
+    }) | undefined)[K]) | undefined;
+    readonly error: any;
+}];
+
+declare const useChain: (token: string) => {
+    chains: API.Chain | null;
+    isLoading: boolean;
+};
+
+declare const useWithdraw: () => {
+    withdraw: (inputs: {
+        chainId: number;
+        token: string;
+        amount: number;
+    }) => Promise<any>;
+    isLoading: boolean;
+    maxAmount: number;
+    availableBalance: number;
+    unsettledPnL: number;
+};
+
+declare type useDepositOptions = {
+    address?: string;
+    decimals?: number;
+    crossChainRouteAddress?: string;
+    depositorAddress?: string;
+    networkId?: NetworkId;
+    srcChainId?: number;
+    srcToken?: string;
+    /**
+     * @hidden
+     */
+    wooSwapEnabled?: boolean;
+};
+declare const useDeposit: (options?: useDepositOptions | undefined) => {
+    dst: {
+        symbol: string;
+        address: string | undefined;
+        decimals: number | undefined;
+        chainId: number;
+        network: string;
+    };
+    balance: string;
+    allowance: string;
+    isNativeToken: boolean;
+    balanceRevalidating: boolean;
+    allowanceRevalidating: boolean;
+    approve: (amount: string | undefined) => Promise<any>;
+    deposit: (amount: string) => Promise<any>;
+    fetchBalances: (tokens: API.TokenInfo[]) => Promise<void>;
+    fetchBalance: (address: string, decimals?: number | undefined) => Promise<string>;
+};
+
+declare const useHoldingStream: () => {
+    data: API.Holding[] | undefined;
+    usdc: API.Holding | undefined;
+    isLoading: boolean;
+};
+
+declare const useWalletSubscription: (options?: {
+    onMessage?: ((data: any) => void) | undefined;
+} | undefined) => swr_subscription.SWRSubscriptionResponse<any, any>;
+
+declare const useSettleSubscription: (options?: {
+    onMessage?: ((data: any) => void) | undefined;
+} | undefined) => swr_subscription.SWRSubscriptionResponse<any, any>;
+
+declare const usePrivateDataObserver: () => void;
+
+declare function useMediaQuery(query: string): boolean;
+
+/** @hidden */
+declare const useWooSwapQuery: () => {
+    query: (inputs: any) => Promise<any> | undefined;
+    loading: boolean;
+};
+
+/** @hidden */
+declare const useWooCrossSwapQuery: () => {
+    query: (inputs: {
+        srcNetwork: string;
+        srcToken: string;
+        amount: bigint;
+        slippage: number;
+        dstToken: string;
+        crossChainRouteAddress: string;
+    }) => Promise<any> | undefined;
+    loading: boolean;
+};
+
+/** @hidden */
+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 };