@orderly.network/hooks 0.0.53 → 0.0.55

package/dist/index.d.mts

@@ -0,0 +1,451 @@
+import useSWR, { SWRConfiguration, SWRResponse } from 'swr';
+export { SWRConfig, SWRConfiguration, default as useSWR } from 'swr';
+import { SWRMutationConfiguration, SWRMutationResponse } from 'swr/mutation';
+import * as _orderly_network_core from '@orderly.network/core';
+import { Account, AccountState, ConfigStore, OrderlyKeyStore, getWalletAdapterFunc, IContract, EventEmitter } from '@orderly.network/core';
+import * as react from 'react';
+import react__default, { FC, PropsWithChildren } from 'react';
+export { default as useConstant } from 'use-constant';
+import { WS } from '@orderly.network/net';
+import { OrderSide, OrderEntity, API, WSMessage } from '@orderly.network/types';
+import * as swr__internal from 'swr/_internal';
+import * as swr_subscription from 'swr/subscription';
+export * from 'use-debounce';
+
+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> & {
+    formatter?: ((data: any) => R) | undefined;
+    init?: RequestInit | undefined;
+}) | undefined) => SWRMutationResponse;
+
+type HTTP_METHOD = "POST" | "PUT" | "DELETE";
+declare const useMutation: <T, E>(url: string, method?: HTTP_METHOD, options?: SWRMutationConfiguration<T, E> | undefined) => [any, any];
+
+/**
+ * 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 useBoolean: (initialValue?: boolean) => [boolean, {
+    setTrue: () => void;
+    setFalse: () => void;
+    toggle: () => void;
+}];
+
+declare const useTradingView: () => {};
+
+declare const usePrivateObserve: <T>() => {
+    data: T | undefined;
+};
+
+declare const useTopicObserve: <T>(topic: string) => {
+    data: T | undefined;
+};
+
+declare const useAccount: () => {
+    account: Account;
+    state: AccountState;
+    login: (address: string) => void;
+    createOrderlyKey: (remember: boolean) => Promise<string>;
+    createAccount: () => Promise<string>;
+    disconnect: () => Promise<void>;
+    connect: () => Promise<any>;
+    setChain: (chainId: number) => Promise<any>;
+};
+
+declare const useAccountInstance: () => Account;
+
+interface OrderlyAppConfig {
+    logoUrl: string;
+    theme: any;
+}
+type AppStateErrors = {
+    ChainNetworkNotSupport: boolean;
+    IpNotSupport: boolean;
+    NetworkError: boolean;
+};
+interface OrderlyContextState extends OrderlyAppConfig {
+    fetcher?: (url: string, init: RequestInit) => Promise<any>;
+    apiBaseUrl: string;
+    klineDataUrl: string;
+    configStore: ConfigStore;
+    keyStore: OrderlyKeyStore;
+    getWalletAdapter: getWalletAdapterFunc;
+    contractManager: IContract;
+    networkId: string;
+    brokerId: string;
+    onWalletConnect?: () => Promise<any>;
+    onWalletDisconnect?: () => Promise<any>;
+    onSetChain?: (chainId: number) => Promise<any>;
+    errors: AppStateErrors;
+}
+declare const OrderlyContext: react.Context<OrderlyContextState>;
+declare const OrderlyProvider: react.Provider<OrderlyContextState>;
+
+declare const useAppState: () => {
+    errors: AppStateErrors;
+};
+
+declare const usePreLoadData: () => {
+    error: any;
+    done: boolean;
+};
+
+declare const useEventEmitter: (channel?: string) => EventEmitter<string | symbol, any>;
+
+declare function useSessionStorage<T>(key: string, initialValue: T): [T, (data: any) => void];
+
+declare function useLocalStorage<T>(key: string, initialValue: T): [T, any];
+
+type useRunOnceProps = {
+    fn: () => any;
+    sessionKey?: string;
+};
+declare const useRunOnce: react__default.FC<useRunOnceProps>;
+
+declare const DataSourceProvider: FC<PropsWithChildren>;
+
+declare const useWS: () => WS;
+
+declare const useConfig: () => _orderly_network_core.ConfigStore;
+
+type OrderBookItem = number[];
+type OrderbookData = {
+    asks: OrderBookItem[];
+    bids: OrderBookItem[];
+};
+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) => ({
+    asks: OrderBookItem[];
+    bids: OrderBookItem[];
+    markPrice: any;
+    middlePrice: any[];
+    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;
+})[];
+
+interface OrderEntryReturn {
+    onSubmit: (values: OrderEntity) => Promise<any>;
+    maxQty: number;
+    freeCollateral: number;
+    markPrice: number;
+    symbolConfig: API.SymbolExt;
+    helper: {
+        calculate: (values: any, field: string, value: any) => any;
+        validator: (values: any) => any;
+    };
+}
+type UseOrderEntryOptions = {
+    commify?: boolean;
+    validate?: (data: OrderEntity) => {
+        [P in keyof OrderEntity]?: string;
+    } | null | undefined;
+};
+/**
+ * 创建订单
+ * @param symbol
+ * @returns
+ */
+declare const useOrderEntry: (symbol: string, side: OrderSide, reduceOnly?: boolean, options?: UseOrderEntryOptions) => OrderEntryReturn;
+
+interface MarketInfo {
+}
+declare const useFetures: () => {
+    data: MarketInfo[] | undefined;
+    sortBy: (key: string) => void;
+    filterBy: (key: string) => void;
+    isLoading: boolean;
+    error: any;
+};
+
+declare const useSymbolsInfo: () => any;
+
+declare const useAccountInfo: () => swr__internal.SWRResponse<API.AccountInfo, any, any>;
+
+declare const useTokenInfo: () => 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 useLeverage: () => ({
+    update: (data: any) => any;
+} | undefined)[];
+
+declare const useTickerStream: (symbol: string) => any;
+
+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, options?: SWRConfiguration) => any[];
+
+declare enum OrderStatus {
+    FILLED = "FILLED",
+    PARTIAL_FILLED = "PARTIAL_FILLED",
+    CANCELED = "CANCELED",
+    NEW = "NEW",
+    COMPLETED = "COMPLETED"
+}
+declare const useOrderStream: ({ status, symbol, side, size, }?: {
+    symbol?: string | undefined;
+    status?: OrderStatus | undefined;
+    size?: number | undefined;
+    side?: OrderSide | undefined;
+}) => (any[] | {
+    cancelAllOrders: () => void;
+    updateOrder: (orderId: string, order: OrderEntity) => any;
+    cancelOrder: (orderId: string, symbol?: string) => any;
+} | null)[];
+
+interface MarketTradeStreamOptions {
+    limit?: number;
+}
+declare const useMarketTradeStream: (symbol: string, options?: MarketTradeStreamOptions) => {
+    data: API.Trade[];
+    isLoading: boolean;
+};
+
+type CollateralOutputs = {
+    totalCollateral: number;
+    freeCollateral: number;
+    totalValue: number;
+    availableBalance: number;
+    unsettledPnL: number;
+};
+/**
+ * 用户保证金
+ * @returns
+ */
+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;
+};
+
+type inputOptions = {
+    filter?: (item: API.Chain) => boolean;
+    pick?: "dexs" | "network_infos" | "token_infos";
+    crossEnabled?: boolean;
+    wooSwapEnabled?: boolean;
+};
+declare const useChains: (networkId?: "testnet" | "mainnet", options?: inputOptions & SWRConfiguration) => 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;
+};
+
+type useDepositOptions = {
+    address?: string;
+    decimals?: number;
+};
+declare const useDeposit: (options?: useDepositOptions) => {
+    dst: {
+        symbol: string;
+        address: string;
+        decimals: number;
+        network: string;
+        chainId: number;
+    };
+    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) => 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 useBalance: () => any;
+
+declare const usePrivateDataObserver: () => void;
+
+declare const useExecutionReport: () => any;
+
+interface Info {
+    symbol: string;
+    quote_min: number;
+    quote_max: number;
+    quote_tick: number;
+    base_min: number;
+    base_max: number;
+    base_tick: number;
+    min_notional: number;
+    price_range: number;
+    created_time: number;
+    updated_time: number;
+}
+/**
+ * useInfo
+ * @returns
+ */
+declare const useInfo: () => swr__internal.SWRResponse<Info[], any, any>;
+
+interface Token {
+    token: string;
+    token_account_id: string;
+    decimals: number;
+    minimum_increment: number;
+}
+/**
+ * useToken
+ * @description get token info
+ */
+declare const useToken: () => swr__internal.SWRResponse<Token[], any, any>;
+
+interface FundingRate {
+    symbol: string;
+    est_funding_rate: number;
+    est_funding_rate_timestamp: number;
+    last_funding_rate: number;
+    last_funding_rate_timestamp: number;
+    next_funding_time: number;
+    sum_unitary_funding: number;
+}
+/**
+ * FundingRate
+ * @param symbol
+ */
+declare const useFundingRateBySymbol: (symbol: string) => swr__internal.SWRResponse<FundingRate, any, any>;
+
+declare const index_useFundingRateBySymbol: typeof useFundingRateBySymbol;
+declare const index_useInfo: typeof useInfo;
+declare const index_useToken: typeof useToken;
+declare namespace index {
+  export {
+    index_useFundingRateBySymbol as useFundingRateBySymbol,
+    index_useInfo as useInfo,
+    index_useToken as useToken,
+  };
+}
+
+declare const useWooSwapQuery: () => {
+    query: (inputs: any) => Promise<any> | undefined;
+    loading: boolean;
+};
+
+declare const useWooCrossSwapQuery: () => {
+    query: (inputs: any) => Promise<any> | undefined;
+    loading: boolean;
+};
+
+declare enum MessageStatus {
+    INITIALIZING = "WAITTING",
+    INFLIGHT = "INFLIGHT",
+    DELIVERED = "DELIVERED",
+    FAILED = "FAILED"
+}
+declare const useCrossSwap: () => {
+    swap: (inputs: {
+        address: string;
+        src: {
+            fromToken: string;
+            fromAmount: string;
+            bridgeToken: string;
+            minBridgeAmount: string;
+        };
+        dst: {
+            chainId: string;
+            bridgedToken: string;
+            toToken: string;
+            minToAmount: string;
+            airdropNativeAmount: string;
+        };
+    }) => Promise<{} | undefined>;
+    loading: boolean;
+    status: MessageStatus;
+    message: any;
+};
+
+declare const useSwap: () => {
+    swap: (inputs: {
+        fromToken: string;
+        fromAmount: string;
+        toToken: string;
+        minToAmount: string;
+    }) => Promise<{} | undefined>;
+    loading: boolean;
+};
+
+export { AppStateErrors, DataSourceProvider, OrderStatus, OrderlyAppConfig, OrderlyContext, OrderlyContextState, OrderlyProvider, index as apis, useAccount, useAccountInfo, useAccountInstance, useAppState, useBalance, useBoolean, useChain, useChains, useCollateral, useConfig, useCrossSwap, useDeposit, useEventEmitter, useExecutionReport, useFetures, useFundingRate, useHoldingStream, useLazyQuery, useLeverage, useLocalStorage, useMarginRatio, useMarkPrice, useMarkPricesStream, useMarketTradeStream, useMarketsStream, useMaxQty, useMutation, useOrderEntry, useOrderStream, useOrderbookStream, usePositionStream, usePreLoadData, usePrivateDataObserver, usePrivateObserve, usePrivateQuery, useQuery, useRunOnce, useSessionStorage, useSwap, useSymbolsInfo, useTickerStream, useTokenInfo, useTopicObserve, useTradingView, useWS, useWalletSubscription, useWithdraw, useWooCrossSwapQuery, useWooSwapQuery };