@orderly.network/hooks 0.0.39 → 0.0.40

package/dist/index.d.mts

@@ -0,0 +1,331 @@
+import useSWR, { SWRConfiguration, SWRResponse } from 'swr';
+export { SWRConfig, SWRConfiguration, default as useSWR } from 'swr';
+import { SWRMutationConfiguration } from 'swr/mutation';
+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';
+
+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>;
+
+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 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>;
+    ready: boolean;
+    onAppTestChange?: (name: string) => void;
+    errors: AppStateErrors;
+}
+declare const OrderlyContext: react.Context<OrderlyContextState>;
+declare const OrderlyProvider: react.Provider<OrderlyContextState>;
+
+declare const useAppState: () => {
+    errors: AppStateErrors;
+    ready: boolean;
+};
+
+declare const usePreLoadData: (onSuccess: (name: string) => void) => void;
+
+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;
+
+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) => ({
+    markPrice: any;
+    middlePrice: any;
+    asks: OrderBookItem[];
+    bids: OrderBookItem[];
+    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;
+})[];
+
+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;
+};
+/**
+ * 用户保证金
+ * @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";
+};
+declare const useChains: (networkId?: "testnet" | "mainnet", options?: inputOptions & SWRConfiguration) => any[];
+
+declare const useHolding: () => {
+    data: API.Holding[] | undefined;
+    usdc: API.Holding | undefined;
+    isLoading: boolean;
+};
+
+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,
+  };
+}
+
+export { AppStateErrors, DataSourceProvider, OrderStatus, OrderlyAppConfig, OrderlyContext, OrderlyContextState, OrderlyProvider, index as apis, useAccount, useAccountInfo, useAccountInstance, useAppState, useBalance, useChains, useCollateral, useEventEmitter, useExecutionReport, useFetures, useFundingRate, useHolding, useLeverage, useLocalStorage, useMarginRatio, useMarkPrice, useMarkPricesStream, useMarketTradeStream, useMarketsStream, useMaxQty, useMutation, useOrderEntry, useOrderStream, useOrderbookStream, usePositionStream, usePreLoadData, usePrivateDataObserver, usePrivateObserve, usePrivateQuery, useQuery, useRunOnce, useSessionStorage, useSymbolsInfo, useTickerStream, useTokenInfo, useTopicObserve, useTradingView, useWS };

package/dist/index.mjs

@@ -6,7 +6,7 @@ import useSWRMutation from 'swr/mutation';
 import useConstant from 'use-constant';
 export { default as useConstant } from 'use-constant';
 import { SimpleDI, Account, EventEmitter } from '@orderly.network/core';
-import { AccountStatusEnum, OrderSide, OrderType } from '@orderly.network/types';
+import { AccountStatusEnum, OrderSide, OrderStatus as OrderStatus$1, OrderType } from '@orderly.network/types';
 import useSWRSubscription from 'swr/subscription';
 import { Decimal, zero, getPrecisionByNumber, timeConvertString } from '@orderly.network/utils';
 import { pathOr, propOr, compose, head, prop } from 'ramda';
@@ -205,8 +205,6 @@ var useAccount = () => {
   const {
     configStore,
     keyStore,
-    walletAdapter,
-    contractManager,
     onWalletConnect,
     onWalletDisconnect,
     onSetChain
@@ -1196,7 +1194,9 @@ var unsettledPnL = pathOr(0, [0, "aggregated", "unsettledPnL"]);
 var useCollateral = (options = { dp: 6 }) => {
   const { dp } = options;
   const positions2 = usePositionStream();
-  const { data: orders } = usePrivateQuery(`/v1/orders`);
+  const { data: orders } = usePrivateQuery(
+    `/v1/orders?status=NEW`
+  );
   const { data: accountInfo } = usePrivateQuery("/v1/client/info");
   const symbolInfo = useSymbolsInfo();
   const { data: markPrices } = useMarkPricesStream();
@@ -1709,13 +1709,13 @@ var usePrivateInfiniteQuery = (getKey, options) => {
   );
   return result;
 };
-var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
-  OrderStatus2["FILLED"] = "FILLED";
-  OrderStatus2["PARTIAL_FILLED"] = "PARTIAL_FILLED";
-  OrderStatus2["CANCELED"] = "CANCELED";
-  OrderStatus2["NEW"] = "NEW";
-  OrderStatus2["COMPLETED"] = "COMPLETED";
-  return OrderStatus2;
+var OrderStatus = /* @__PURE__ */ ((OrderStatus3) => {
+  OrderStatus3["FILLED"] = "FILLED";
+  OrderStatus3["PARTIAL_FILLED"] = "PARTIAL_FILLED";
+  OrderStatus3["CANCELED"] = "CANCELED";
+  OrderStatus3["NEW"] = "NEW";
+  OrderStatus3["COMPLETED"] = "COMPLETED";
+  return OrderStatus3;
 })(OrderStatus || {});
 var useOrderStream = ({
   status,
@@ -1941,14 +1941,40 @@ var usePrivateDataObserver = () => {
   const ee = useEventEmitter();
   const { state } = useAccount();
   useEffect(() => {
-    console.log("subscribe: executionreport");
     const unsubscribe = ws.privateSubscribe("executionreport", {
       onMessage: (data) => {
+        const key = ["/v1/orders?status=NEW", state.accountId];
+        mutate2(key, (orders) => {
+          return Promise.resolve().then(() => {
+            if (!orders) {
+              return orders;
+            }
+            if (data.status === OrderStatus$1.NEW) {
+              return [
+                __spreadProps(__spreadValues({}, data), {
+                  // average_executed_price:data.ava
+                  created_time: data.timestamp,
+                  order_id: data.orderId
+                  // reduce_only
+                }),
+                ...orders
+              ];
+            }
+            if (data.status === OrderStatus$1.CANCELLED) {
+              return orders.filter(
+                (order2) => order2.order_id !== data.orderId
+              );
+            }
+            return orders;
+          }).catch((error) => {
+            console.log("error", error, error.stack);
+          });
+        });
         ee.emit("orders:changed");
       }
     });
     return () => unsubscribe == null ? void 0 : unsubscribe();
-  }, []);
+  }, [state.accountId]);
   useEffect(() => {
     console.log("subscribe: position: %s", state.accountId);
     if (!state.accountId)
@@ -1957,9 +1983,7 @@ var usePrivateDataObserver = () => {
     const unsubscribe = ws.privateSubscribe("position", {
       onMessage: (data) => {
         const { positions: nextPostions } = data;
-        console.info("refresh positions:", nextPostions, state.accountId);
         mutate2(key, (prevPositions) => {
-          console.log("prevPositions:::::", prevPositions);
           if (!!prevPositions) {
             return __spreadProps(__spreadValues({}, prevPositions), {
               rows: prevPositions.rows.map((row) => {