@orderly.network/hooks 0.0.39 → 0.0.41

package/dist/index.d.mts

@@ -0,0 +1,340 @@
+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) => ({
+    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;
+};
+/**
+ * 用户保证金
+ * @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 useChain: (token: string) => {
+    chains: API.Chain | null;
+    isLoading: boolean;
+};
+
+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, useChain, 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, chainsMap, 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';
@@ -84,7 +84,9 @@ var useQuery = (query, options) => {
   return useSWR(
     // `${apiBaseUrl}${query}`,
     query,
-    (url, init) => fetcher(`${apiBaseUrl}${url}`, init, { formatter }),
+    (url, init) => fetcher(url.startsWith("http") ? url : `${apiBaseUrl}${url}`, init, {
+      formatter
+    }),
     swrOptions
   );
 };
@@ -205,8 +207,6 @@ var useAccount = () => {
   const {
     configStore,
     keyStore,
-    walletAdapter,
-    contractManager,
     onWalletConnect,
     onWalletDisconnect,
     onSetChain
@@ -657,9 +657,6 @@ var reduceItems = (depth, level, data, asks = false) => {
       continue;
     const newQuantity = new Decimal(quantity).add(result.length > 0 ? result[result.length - 1][2] : 0).toNumber();
     result.push([price, quantity, newQuantity]);
-    if (i + 1 >= level) {
-      break;
-    }
   }
   return result;
 };
@@ -779,6 +776,7 @@ var useOrderbookStream = (symbol, initial = { asks: [], bids: [] }, options) =>
   const onDepthChange = useCallback((depth2) => {
     setDepth(() => depth2);
   }, []);
+  const prevMiddlePrice = useRef(0);
   const middlePrice = useMemo(() => {
     let asksFrist = 0, bidsFirst = 0;
     if (data.asks.length > 0) {
@@ -791,35 +789,19 @@ var useOrderbookStream = (symbol, initial = { asks: [], bids: [] }, options) =>
       return 0;
     return [asksFrist, bidsFirst, ticker["24h_close"]].sort()[1];
   }, [ticker, data]);
+  useEffect(() => {
+    prevMiddlePrice.current = middlePrice;
+  }, [middlePrice]);
   return [
-    __spreadProps(__spreadValues({}, data), { markPrice, middlePrice }),
+    {
+      asks: data.asks.slice(-level),
+      bids: data.bids.slice(0, level),
+      markPrice,
+      middlePrice: [prevMiddlePrice.current, middlePrice]
+    },
     { onDepthChange, depth, allDepths: depths, isLoading, onItemClick }
   ];
 };
-
-// src/orderly/useTokenInfo.ts
-var useTokenInfo = () => {
-  const { data = {} } = useQuery(
-    "/v1/public/token",
-    {
-      focusThrottleInterval: 1e3 * 60 * 60 * 24,
-      revalidateOnFocus: false,
-      formatter(data2) {
-        var _a;
-        if (!(data2 == null ? void 0 : data2.rows) || !((_a = data2 == null ? void 0 : data2.rows) == null ? void 0 : _a.length)) {
-          return {};
-        }
-        const obj = /* @__PURE__ */ Object.create(null);
-        for (let index = 0; index < data2.rows.length; index++) {
-          const item = data2.rows[index];
-          obj[item.token] = item;
-        }
-        return obj;
-      }
-    }
-  );
-  return createGetter(data);
-};
 var needNumberOnlyFields = ["order_quantity", "order_price", "total"];
 function baseInputHandle(inputs) {
   let [values, input, value, markPrice, config] = inputs;
@@ -1196,7 +1178,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();
@@ -1482,14 +1466,13 @@ var useOrderEntry = (symbol, side, reduceOnly = false, options) => {
   const [doCreateOrder] = useMutation("/v1/order");
   const { freeCollateral } = useCollateral();
   const symbolInfo = useSymbolsInfo();
-  const tokenInfo = useTokenInfo();
   const baseDP = useMemo(
     () => getPrecisionByNumber(symbolInfo[symbol]("base_tick", 0)),
     [symbolInfo]
   );
   const quoteDP = useMemo(() => {
-    return tokenInfo.USDC("decimals", 0);
-  }, [tokenInfo]);
+    return getPrecisionByNumber(symbolInfo[symbol]("quote_tick", 0));
+  }, [symbolInfo]);
   const { data: markPrice } = useMarkPrice(symbol);
   const maxQty = useMaxQty(
     symbol,
@@ -1509,7 +1492,7 @@ var useOrderEntry = (symbol, side, reduceOnly = false, options) => {
     }
     return orderCreator == null ? void 0 : orderCreator.validate(values, {
       symbol: symbolInfo[symbol](),
-      token: tokenInfo[symbol](),
+      // token: tokenInfo[symbol](),
       maxQty,
       markPrice
     }).then(() => {
@@ -1543,7 +1526,7 @@ var useOrderEntry = (symbol, side, reduceOnly = false, options) => {
     const creator = OrderFactory.create(values.order_type);
     return creator == null ? void 0 : creator.validate(values, {
       symbol: symbolInfo[symbol](),
-      token: tokenInfo[symbol](),
+      // token: tokenInfo[symbol](),
       maxQty,
       markPrice
     });
@@ -1597,6 +1580,30 @@ var useFetures = () => {
 var useAccountInfo = () => {
   return usePrivateQuery("/v1/client/info");
 };
+
+// src/orderly/useTokenInfo.ts
+var useTokenInfo = () => {
+  const { data = {} } = useQuery(
+    "/v1/public/token",
+    {
+      focusThrottleInterval: 1e3 * 60 * 60 * 24,
+      revalidateOnFocus: false,
+      formatter(data2) {
+        var _a;
+        if (!(data2 == null ? void 0 : data2.rows) || !((_a = data2 == null ? void 0 : data2.rows) == null ? void 0 : _a.length)) {
+          return {};
+        }
+        const obj = /* @__PURE__ */ Object.create(null);
+        for (let index = 0; index < data2.rows.length; index++) {
+          const item = data2.rows[index];
+          obj[item.token] = item;
+        }
+        return obj;
+      }
+    }
+  );
+  return createGetter(data);
+};
 var useMarketsStream = () => {
   const ws = useWS();
   const { data: futures } = useQuery(`/v1/public/futures`, {
@@ -1709,13 +1716,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,
@@ -1923,6 +1930,25 @@ var useChains = (networkId, options = {}) => {
   );
   return [chains, { findByChainId }];
 };
+var useChain = (token) => {
+  const { data, isLoading } = useQuery("/v1/public/token");
+  const chains = useMemo(() => {
+    if (!data)
+      return null;
+    let item = data.find((chain) => chain.token === token);
+    if (item) {
+      item.chain_details = item.chain_details.map((d) => {
+        var _a;
+        const chain = chainsMap.get(Number(d.chain_id));
+        return __spreadProps(__spreadValues({}, d), {
+          chain_name: (_a = chain == null ? void 0 : chain.chainName) != null ? _a : "--"
+        });
+      });
+    }
+    return item || null;
+  }, [data, token]);
+  return { chains, isLoading };
+};
 var useBalance = () => {
   const ws = useWS();
   const { data } = useSWRSubscription("balance", (_, { next }) => {
@@ -1941,14 +1967,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 +2009,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) => {
@@ -2042,6 +2092,6 @@ var useFundingRateBySymbol = (symbol) => {
   return useQuery(`/public/funding_rate/${symbol}`);
 };
 
-export { DataSourceProvider, OrderStatus, OrderlyContext, OrderlyProvider, apis_exports 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 };
+export { DataSourceProvider, OrderStatus, OrderlyContext, OrderlyProvider, apis_exports as apis, useAccount, useAccountInfo, useAccountInstance, useAppState, useBalance, useChain, 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 };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.mjs.map