@orderly.network/hooks 0.0.4

package/dist/index.js

@@ -0,0 +1,1514 @@
+'use strict';
+
+var react = require('react');
+var useSWR = require('swr');
+var net = require('@orderly.network/net');
+var useSWRMutation = require('swr/mutation');
+var core = require('@orderly.network/core');
+var useConstant = require('use-constant');
+var rxjsHooks = require('rxjs-hooks');
+var rxjs = require('rxjs');
+var operators = require('rxjs/operators');
+var ramda = require('ramda');
+var utils = require('@orderly.network/utils');
+var types = require('@orderly.network/types');
+var formik = require('formik');
+var futures = require('@orderly.network/futures');
+var useSWRInfinite = require('swr/infinite');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var useSWR__default = /*#__PURE__*/_interopDefault(useSWR);
+var useSWRMutation__default = /*#__PURE__*/_interopDefault(useSWRMutation);
+var useConstant__default = /*#__PURE__*/_interopDefault(useConstant);
+var useSWRInfinite__default = /*#__PURE__*/_interopDefault(useSWRInfinite);
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var OrderlyContext = react.createContext({
+  // configStore: new MemoryConfigStore(),
+});
+var OrderlyProvider = OrderlyContext.Provider;
+var fetcher = (url, init = {}, queryOptions) => net.get(url, init, queryOptions == null ? void 0 : queryOptions.formatter);
+
+// src/useQuery.ts
+var useQuery = (query, options) => {
+  const { apiBaseUrl } = react.useContext(OrderlyContext);
+  const _a = options || {}, { formatter } = _a, swrOptions = __objRest(_a, ["formatter"]);
+  if (!query.startsWith("/public")) {
+    throw new Error("useQuery is only for public api");
+  }
+  if (typeof apiBaseUrl === "undefined") {
+    throw new Error("please add OrderlyProvider to your app");
+  }
+  return useSWR__default.default(
+    `${apiBaseUrl}${query}`,
+    (url, init) => fetcher(url, init, { formatter }),
+    swrOptions
+  );
+};
+var fetcher2 = (url, options) => {
+  return net.post(url, options.arg.data, {
+    headers: __spreadProps(__spreadValues({}, options.arg.signature), {
+      "orderly-account-id": "0x47ab075adca7dfe9dd206eb7c50a10f7b99f4f08fa6c3abd4c170d438e15093b"
+    })
+  });
+};
+var useMutation = (url, options) => {
+  const { apiBaseUrl } = react.useContext(OrderlyContext);
+  if (!url.startsWith("http")) {
+    url = `${apiBaseUrl}${url}`;
+  }
+  const signer = core.getMockSigner();
+  const { trigger, data, error, reset, isMutating } = useSWRMutation__default.default(
+    url,
+    fetcher2,
+    options
+  );
+  const mutation = (data2) => __async(void 0, null, function* () {
+    const payload = {
+      method: "POST",
+      url,
+      data: data2
+    };
+    const signature = yield signer.sign(payload);
+    return trigger({ data: data2, signature });
+  });
+  return {
+    mutation,
+    data,
+    error,
+    reset,
+    isMutating
+  };
+};
+var signatureMiddleware = (useSWRNext) => {
+  return (key, fetcher4, config) => {
+    const extendedFetcher = (url) => __async(void 0, null, function* () {
+      const signer = core.getMockSigner();
+      const payload = {
+        method: "GET",
+        url
+      };
+      const signature = yield signer.sign(payload);
+      return fetcher4(url, {
+        headers: __spreadProps(__spreadValues({}, signature), {
+          "orderly-account-id": "0x47ab075adca7dfe9dd206eb7c50a10f7b99f4f08fa6c3abd4c170d438e15093b"
+        })
+      });
+    });
+    return useSWRNext(key, extendedFetcher, config);
+  };
+};
+var usePrivateQuery = (query, options) => {
+  var _b;
+  const { apiBaseUrl } = react.useContext(OrderlyContext);
+  const _a = options || {}, { formatter } = _a, swrOptions = __objRest(_a, ["formatter"]);
+  const middleware = Array.isArray(options == null ? void 0 : options.use) ? (_b = options == null ? void 0 : options.use) != null ? _b : [] : [];
+  return useSWR__default.default(
+    `${apiBaseUrl}${query}`,
+    (url, init) => fetcher(url, init, { formatter }),
+    __spreadProps(__spreadValues({}, swrOptions), {
+      use: [signatureMiddleware, ...middleware]
+    })
+  );
+};
+
+// src/useTradingView.ts
+var useTradingView = () => {
+  return {};
+};
+var usePrivateObserve = () => {
+  const [data, setData] = react.useState();
+  react.useEffect(() => {
+    return () => {
+    };
+  }, []);
+  return {
+    data
+  };
+};
+var useTopicObserve = (topic) => {
+  const [data, setData] = react.useState();
+  react.useEffect(() => {
+    return () => {
+    };
+  }, []);
+  return {
+    data
+  };
+};
+var useAccount = () => {
+  const { configStore } = react.useContext(OrderlyContext);
+  if (!configStore)
+    throw new Error("configStore is not defined, please use OrderlyProvider");
+  const account3 = useConstant__default.default(() => {
+    let account4 = core.SimpleDI.get("account");
+    if (!account4) {
+      account4 = new core.Account(configStore);
+      core.SimpleDI.registerByName("account", account4);
+    }
+    return account4;
+  });
+  const { data: accountInfo } = usePrivateQuery("/client/info");
+  const state = rxjsHooks.useObservable(
+    () => account3.state$,
+    account3.stateValue
+  );
+  const login = react.useCallback(
+    (address) => {
+      account3.login(address);
+    },
+    [account3]
+  );
+  return {
+    account: state,
+    info: accountInfo,
+    login
+  };
+};
+var WS_NAME = "websocketClient";
+var useWebSocketClient = () => {
+  const ws = useConstant__default.default(() => {
+    let websocketClient = core.SimpleDI.get(WS_NAME);
+    if (!websocketClient) {
+      websocketClient = new net.WebSocketClient({
+        accountId: "0x47ab075adca7dfe9dd206eb7c50a10f7b99f4f08fa6c3abd4c170d438e15093b",
+        networkId: "testnet",
+        onSigntureRequest: (accountId) => __async(void 0, null, function* () {
+          const signer = core.getMockSigner();
+          const timestamp = (/* @__PURE__ */ new Date()).getTime();
+          const result = yield signer.signText(timestamp.toString());
+          return __spreadProps(__spreadValues({}, result), { timestamp });
+        })
+      });
+      core.SimpleDI.registerByName(WS_NAME, websocketClient);
+    }
+    return websocketClient;
+  });
+  return ws;
+};
+var useTickerStream = (symbol) => {
+  if (!symbol) {
+    throw new Error("useFuturesForSymbol requires a symbol");
+  }
+  const { data: info } = useQuery(`/public/futures/${symbol}`);
+  const ws = useWebSocketClient();
+  const ticker = rxjsHooks.useObservable(
+    (_, input$) => input$.pipe(
+      operators.map(([config]) => config),
+      operators.combineLatestWith(ws.observe(`${symbol}@ticker`).pipe(operators.startWith({}))),
+      operators.map(([config, ticker2]) => {
+        if (!config)
+          return config;
+        if (ticker2.close !== void 0) {
+          config["24h_close"] = ticker2.close;
+        }
+        if (ticker2.open !== void 0) {
+          config["24h_open"] = ticker2.open;
+        }
+        if (ticker2.volume !== void 0) {
+          config["24h_volumn"] = ticker2.volume;
+        }
+        if (ticker2.close !== void 0 && ticker2.open !== void 0) {
+          config["change"] = new utils.Decimal(ticker2.close).minus(ticker2.open).div(ticker2.open).toNumber();
+        }
+        return config;
+      })
+    ),
+    null,
+    [info]
+  );
+  return ticker;
+};
+ramda.compose(ramda.defaultTo(0), ramda.head, ramda.last, ramda.pathOr([], ["asks"]));
+ramda.pathOr(0, ["bids", 0, 0]);
+var paddingFn = (len) => Array(len).fill([Number.NaN, Number.NaN, Number.NaN]);
+var asksSortFn = (a, b) => a[0] - b[0];
+var bidsSortFn = (a, b) => b[0] - a[0];
+var reduceItems = (depth, level, data) => {
+  if (!Array.isArray(data) || data.length === 0) {
+    return [];
+  }
+  const result = [];
+  for (let i = 0; i < data.length; i++) {
+    const [price, quantity] = data[i];
+    result.push([price, quantity, quantity + (i > 0 ? result[i - 1][2] : 0)]);
+    if (i + 1 >= level) {
+      break;
+    }
+  }
+  return result;
+};
+var reduceOrderbook = (depth, level, data) => {
+  const asks = reduceItems(depth, level, data.asks).reverse();
+  const bids = reduceItems(depth, level, data.bids);
+  return {
+    asks: asks.length < level ? paddingFn(level - asks.length).concat(asks) : asks,
+    bids: bids.length < level ? bids.concat(paddingFn(level - bids.length)) : bids
+  };
+};
+var mergeItems = (data, update) => {
+  if (data.length === 0)
+    return update;
+  while (update.length > 0) {
+    const item = update.shift();
+    if (item) {
+      const [price, quantity] = item;
+      if (price < data[0][0] && quantity > 0) {
+        data.unshift(item);
+        continue;
+      }
+      const index = data.findIndex(([p], index2) => p === price);
+      if (index === -1) {
+        data.push(item);
+      } else {
+        if (quantity === 0) {
+          data.splice(index, 1);
+          continue;
+        }
+        data[index] = item;
+      }
+    }
+  }
+  return data;
+};
+var mergeOrderbook = (data, update) => {
+  return {
+    asks: mergeItems(data.asks, update.asks).sort(asksSortFn),
+    bids: mergeItems(data.bids, update.bids).sort(bidsSortFn)
+  };
+};
+var useOrderbook = (symbol, initial = { asks: [], bids: [] }, options) => {
+  if (!symbol) {
+    throw new Error("useOrderbook requires a symbol");
+  }
+  const [data, setData] = react.useState(initial);
+  const [depth, setDepth] = react.useState(1e-3);
+  const [level, setLevel] = react.useState(() => {
+    var _a;
+    return (_a = options == null ? void 0 : options.level) != null ? _a : 10;
+  });
+  const ws = useWebSocketClient();
+  const orderbookSubscriberRef = react.useRef();
+  const ticker = useTickerStream(symbol);
+  const orderbookRequest$ = react.useMemo(() => {
+    return ws.observe(
+      {
+        event: "request",
+        params: {
+          type: "orderbook",
+          symbol
+        }
+      },
+      void 0,
+      (message) => message.event === "request"
+    );
+  }, [symbol]);
+  const orderbookUpdate$ = react.useMemo(() => {
+    return ws.observe(`${symbol}@orderbookupdate`, () => ({
+      event: "subscribe",
+      topic: `${symbol}@orderbookupdate`
+    })).pipe(
+      operators.startWith({ asks: [], bids: [] })
+      // filter((message: any) => !!message.success)
+    );
+  }, [symbol]);
+  const orderbookOptions$ = useConstant__default.default(() => {
+    return new rxjs.BehaviorSubject({
+      depth: 1e-3,
+      level: 10
+    });
+  });
+  const markPrice = rxjsHooks.useObservable(
+    (_, input$) => input$.pipe(
+      operators.debounceTime(200),
+      operators.switchMap(([symbol2]) => {
+        return ws.observe(`${symbol2}@markprice`).pipe(operators.map((data2) => data2.price));
+      })
+    ),
+    0,
+    [symbol]
+  );
+  react.useEffect(() => {
+    if (orderbookSubscriberRef.current) {
+      orderbookSubscriberRef.current.unsubscribe();
+    }
+    orderbookSubscriberRef.current = rxjs.merge(orderbookRequest$, orderbookUpdate$).pipe(
+      // tap((data) => console.log(data)),
+      operators.map(
+        (data2) => ramda.pick(["asks", "bids"], data2)
+      ),
+      operators.scan((acc, curr) => {
+        if (!acc.asks && !acc.bids) {
+          return curr;
+        }
+        return mergeOrderbook(acc, curr);
+      }),
+      operators.map((data2) => reduceOrderbook(depth, level, data2))
+    ).subscribe((data2) => {
+      setData(data2);
+    });
+  }, [orderbookRequest$, orderbookUpdate$]);
+  const onDepthChange = react.useCallback((depth2) => {
+    console.log("Orderbook depth has changed:", depth2);
+    orderbookOptions$.next(__spreadProps(__spreadValues({}, orderbookOptions$.value), {
+      depth: depth2
+      // level,
+    }));
+  }, []);
+  const middlePrice = react.useMemo(() => {
+    let asksFrist = 0, bidsFirst = 0;
+    if (data.asks.length > 0) {
+      asksFrist = data.asks[data.bids.length - 1][0];
+    }
+    if (data.bids.length > 0) {
+      bidsFirst = data.bids[0][0];
+    }
+    if (isNaN(asksFrist) || isNaN(bidsFirst) || !ticker)
+      return 0;
+    return [asksFrist, bidsFirst, ticker["24h_close"]].sort()[1];
+  }, [ticker, data]);
+  return [
+    __spreadProps(__spreadValues({}, data), { markPrice, middlePrice }),
+    { onDepthChange, depth }
+  ];
+};
+
+// src/utils/createGetter.ts
+function createGetter(data, depth = 2) {
+  return new Proxy(data || {}, {
+    get(target, property, receiver) {
+      if (depth === 1) {
+        return (defaultValue) => {
+          var _a;
+          if (!target)
+            return defaultValue;
+          return (_a = target[property]) != null ? _a : defaultValue;
+        };
+      }
+      return (key, defaultValue) => {
+        var _a, _b;
+        if (key) {
+          return (_b = (_a = target[property]) == null ? void 0 : _a[key]) != null ? _b : defaultValue;
+        } else {
+          return target[property];
+        }
+      };
+    }
+  });
+}
+
+// src/orderly/useSymbolsInfo.ts
+var useSymbolsInfo = () => {
+  const { data = {} } = useQuery(`/public/info`, {
+    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];
+        const arr = item.symbol.split("_");
+        obj[item.symbol] = __spreadProps(__spreadValues({}, item), {
+          base: arr[1],
+          quote: arr[2],
+          type: arr[0],
+          name: `${arr[1]}-${arr[0]}`
+        });
+      }
+      return obj;
+    }
+  });
+  return createGetter(data);
+};
+
+// src/orderly/useTokenInfo.ts
+var useTokenInfo = () => {
+  const { data = {} } = useQuery(
+    "/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;
+  if (needNumberOnlyFields.includes(input)) {
+    value = value.toString();
+    value = value.replace(/,/g, "");
+    value = value.replace(/[^\d.]/g, "");
+  }
+  return [
+    __spreadProps(__spreadValues({}, values), {
+      [input]: value
+    }),
+    input,
+    value,
+    markPrice,
+    config
+  ];
+}
+function orderEntityFormatHandle(baseTick, quoteTick) {
+  return function(inputs) {
+    const [values, input, value, markPrice, config] = inputs;
+    return [values, input, value, markPrice, config];
+  };
+}
+function priceInputHandle(inputs) {
+  const [values, input, value, markPrice, config] = inputs;
+  if (value === "") {
+    return [__spreadProps(__spreadValues({}, values), { total: "" }), input, value, markPrice, config];
+  }
+  const price = new utils.Decimal(value);
+  const priceDP = price.dp();
+  if (priceDP > config.quoteDP) {
+    price.toDecimalPlaces(config.quoteDP);
+    values.order_price = price.toNumber();
+  }
+  price.toDecimalPlaces(Math.min(priceDP, config.quoteDP));
+  if (!values.order_quantity) {
+    return [values, input, value, markPrice, config];
+  }
+  const total = price.mul(values.order_quantity);
+  const quantityDP = total.dp();
+  total.toDecimalPlaces(Math.min(quantityDP, config.baseDP));
+  return [
+    __spreadProps(__spreadValues({}, values), { total: total.toNumber() }),
+    input,
+    value,
+    markPrice,
+    config
+  ];
+}
+function quantityInputHandle(inputs) {
+  const [values, input, value, markPrice, config] = inputs;
+  if (value === "") {
+    return [__spreadProps(__spreadValues({}, values), { total: "" }), input, value, markPrice, config];
+  }
+  let quantity = new utils.Decimal(value);
+  const quantityDP = quantity.dp();
+  if (quantityDP > config.baseDP) {
+    quantity = quantity.toDecimalPlaces(config.baseDP);
+    values.order_quantity = quantity.toNumber();
+  }
+  let price = markPrice;
+  if (values.order_type === types.OrderType.LIMIT && !!values.order_price) {
+    price = Number(values.order_price);
+  }
+  const total = quantity.mul(price);
+  const totalDP = total.dp();
+  total.todp(Math.min(config.quoteDP, totalDP));
+  return [
+    __spreadProps(__spreadValues({}, values), {
+      total: total.toNumber()
+    }),
+    input,
+    value,
+    markPrice,
+    config
+  ];
+}
+function totalInputHandle(inputs) {
+  const [values, input, value, markPrice, config] = inputs;
+  if (value === "") {
+    return [__spreadProps(__spreadValues({}, values), { order_quantity: "" }), input, value, markPrice, config];
+  }
+  let price = markPrice;
+  if (values.order_type === types.OrderType.LIMIT && !!values.order_price) {
+    price = Number(values.order_price);
+  }
+  let total = new utils.Decimal(value);
+  const totalDP = total.dp();
+  if (totalDP > config.quoteDP) {
+    total = total.toDecimalPlaces(config.quoteDP);
+    values.total = total.toNumber();
+  }
+  const quantity = total.div(price);
+  return [
+    __spreadProps(__spreadValues({}, values), {
+      order_quantity: quantity.toDecimalPlaces(Math.min(config.baseDP, quantity.dp())).toNumber()
+    }),
+    input,
+    value,
+    markPrice,
+    config
+  ];
+}
+function otherInputHandle(inputs) {
+  return inputs;
+}
+var getCalculateHandler = (fieldName) => {
+  switch (fieldName) {
+    case "order_quantity": {
+      return quantityInputHandle;
+    }
+    case "order_price": {
+      return priceInputHandle;
+    }
+    case "total": {
+      return totalInputHandle;
+    }
+    default:
+      return otherInputHandle;
+  }
+};
+
+// src/orderly/useFundingRates.ts
+var useFundingRates = () => {
+  const { data } = useQuery(
+    `/public/funding_rates`,
+    {
+      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.symbol] = item;
+        }
+        return obj;
+      }
+    }
+  );
+  return createGetter(data);
+};
+var useMarkPricesSubject = () => {
+  const ws = useWebSocketClient();
+  return useConstant__default.default(
+    () => ws.observe("markprices").pipe(
+      operators.map((data) => {
+        const prices = {};
+        data.forEach((item) => {
+          prices[item.symbol] = item.price;
+        });
+        return prices;
+      })
+    )
+  );
+};
+
+// src/orderly/usePositionStream.ts
+var usePositionStream = (symbol, options) => {
+  const [visibledSymbol, setVisibleSymbol] = react.useState(
+    symbol
+  );
+  const symbolInfo = useSymbolsInfo();
+  const { info: accountInfo } = useAccount();
+  const fundingRates = useFundingRates();
+  const markPrices$ = useMarkPricesSubject();
+  const { data, error, isLoading } = usePrivateQuery(
+    `/positions`,
+    __spreadProps(__spreadValues({}, options), {
+      formatter: (data2) => data2
+    })
+  );
+  const value = rxjsHooks.useObservable(
+    (_, input$) => input$.pipe(
+      // map((data) => {
+      //   return data[0];
+      // }),
+      operators.combineLatestWith(markPrices$),
+      operators.debounceTime(100),
+      operators.map(([[data2, symbolInfo2, accountInfo2], markPrices]) => {
+        let totalCollateral = 0;
+        return data2 == null ? void 0 : data2.map((item) => {
+          var _a;
+          const price = (_a = markPrices[item.symbol]) != null ? _a : item.mark_price;
+          const info = symbolInfo2 == null ? void 0 : symbolInfo2[item.symbol];
+          const MMR = futures.positions.MMR({
+            baseMMR: info("base_mmr"),
+            baseIMR: info("base_imr"),
+            IMRFactor: accountInfo2.imr_factor[info("base")],
+            positionNotional: futures.positions.notional(item.position_qty, price),
+            IMR_factor_power: 4 / 5
+          });
+          return __spreadProps(__spreadValues({}, item), {
+            mark_price: price,
+            est_liq_price: futures.positions.liqPrice({
+              markPrice: price,
+              totalCollateral,
+              positionQty: item.position_qty,
+              MMR
+            }),
+            notional: futures.positions.notional(
+              item.position_qty,
+              item.average_open_price
+            ),
+            unrealized_pnl: futures.positions.unrealizedPnL({
+              qty: item.position_qty,
+              openPrice: item.average_open_price,
+              markPrice: price
+            })
+          });
+        });
+      })
+    ),
+    void 0,
+    [data == null ? void 0 : data.rows, symbolInfo, accountInfo]
+  );
+  const aggregatedData = react.useMemo(() => {
+    const aggregatedData2 = {
+      unsettledPnL: NaN,
+      unrealPnL: NaN,
+      notional: NaN
+    };
+    if (value && value.length) {
+      aggregatedData2.unrealPnL = futures.positions.totalUnrealizedPnL(value);
+      aggregatedData2.notional = futures.positions.totalNotional(value);
+      aggregatedData2.unsettledPnL = futures.positions.totalUnsettlementPnL(
+        value.map((item) => {
+          var _a;
+          return __spreadProps(__spreadValues({}, item), {
+            sum_unitary_funding: (_a = fundingRates[item.symbol]) == null ? void 0 : _a.call(
+              fundingRates,
+              "sum_unitary_funding",
+              0
+            )
+          });
+        })
+      );
+    }
+    return aggregatedData2;
+  }, [value, fundingRates]);
+  const showSymbol = react.useCallback((symbol2) => {
+    setVisibleSymbol(symbol2);
+  }, []);
+  return [
+    { rows: value, aggregated: aggregatedData },
+    createGetter(data, 1),
+    {
+      close: (qty) => {
+      },
+      loading: false,
+      showSymbol,
+      error,
+      loadMore: () => {
+      },
+      refresh: () => {
+      }
+      // toggleHideOthers,
+      // filter: (filter: string) => {},
+    }
+  ];
+};
+var fetcher3 = (url, init) => net.get(url, init);
+var usePrivateInfiniteQuery = (getKey, options) => {
+  var _a;
+  const middleware = Array.isArray(options == null ? void 0 : options.use) ? (_a = options == null ? void 0 : options.use) != null ? _a : [] : [];
+  const { apiBaseUrl } = react.useContext(OrderlyContext);
+  const result = useSWRInfinite__default.default(
+    (index, prevData) => `${apiBaseUrl}${getKey(index, prevData)}`,
+    fetcher3,
+    __spreadProps(__spreadValues({}, options), {
+      use: [signatureMiddleware, ...middleware]
+    })
+  );
+  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;
+})(OrderStatus || {});
+var useOrderStream = ({
+  status = "NEW" /* NEW */,
+  symbol
+} = {}) => {
+  var _a;
+  const markPrices$ = useMarkPricesSubject();
+  const res = usePrivateInfiniteQuery(
+    (pageIndex, previousPageData) => {
+      const search = new URLSearchParams([
+        ["size", "100"],
+        ["page", `${pageIndex + 1}`],
+        [`status`, status]
+      ]);
+      if (symbol) {
+        search.set(`symbol`, symbol);
+      }
+      return `/orders?${search.toString()}`;
+    },
+    {
+      initialSize: 1,
+      onError: (err) => {
+        console.error("fetch failed::::", err);
+      }
+    }
+  );
+  const orders = rxjsHooks.useObservable(
+    (_, input$) => input$.pipe(
+      operators.map(([data]) => {
+        return data.flat();
+      }),
+      operators.combineLatestWith(markPrices$),
+      operators.map(([data, markPrices]) => {
+        return data.map((item) => {
+          var _a2;
+          return __spreadProps(__spreadValues({}, item), {
+            mark_price: (_a2 = markPrices[item.symbol]) != null ? _a2 : 0
+          });
+        });
+      })
+    ),
+    null,
+    [(_a = res.data) != null ? _a : []]
+  );
+  const cancelAllOrders = react.useCallback(() => {
+  }, [res.data]);
+  const updateOrder = react.useCallback((id, data) => {
+  }, []);
+  const cancelOrder = react.useCallback((id) => {
+  }, []);
+  return [
+    orders,
+    // {
+    //   ...res,
+    //   data: res.data?.reduce((acc, cur) => {
+    //     return [...acc, ...cur];
+    //   }, []),
+    // },
+    {
+      cancelAllOrders,
+      updateOrder,
+      cancelOrder
+    }
+  ];
+};
+var useMarkPriceStream = () => {
+  const markPrice$ = useMarkPricesSubject();
+  return rxjsHooks.useObservable(() => markPrice$, {});
+};
+
+// src/orderly/useCollateral.ts
+var totalUnsettlementPnLPath = ramda.pathOr(0, [0, "aggregated", "unsettledPnL"]);
+var positionsPath = ramda.pathOr([], [0, "rows"]);
+var useCollateral = (dp = 6) => {
+  const positions2 = usePositionStream();
+  const orders = useOrderStream();
+  const { info: accountInfo } = useAccount();
+  const symbolInfo = useSymbolsInfo();
+  const markPrices = useMarkPriceStream();
+  const { data } = usePrivateQuery("/client/holding", {
+    formatter: (data2) => {
+      return data2.holding;
+    }
+  });
+  const totalCollateral = rxjsHooks.useObservable(
+    (_, input$) => rxjs.merge(input$).pipe(
+      operators.debounceTime(100),
+      operators.filter((data2) => !!data2[0]),
+      operators.map(
+        ([data2, unsettlemnedPnL, markPrices2]) => {
+          const nonUSDC = [];
+          let USDC_holding = 0;
+          data2.forEach((item) => {
+            if (item.token === "USDC") {
+              USDC_holding = item.holding;
+            } else {
+              nonUSDC.push({
+                holding: item.holding,
+                // markPrice: markPrices[item.token] ?? 0,
+                markPrice: 0,
+                discount: 0
+              });
+            }
+          });
+          const number = futures.account.totalCollateral({
+            USDCHolding: USDC_holding,
+            nonUSDCHolding: nonUSDC,
+            unsettlementPnL: unsettlemnedPnL
+          });
+          return new utils.Decimal(number);
+        }
+      )
+    ),
+    utils.zero,
+    [data, totalUnsettlementPnLPath(positions2), markPrices]
+  );
+  const totalInitialMarginWithOrders = rxjsHooks.useObservable(
+    (_, input$) => input$.pipe(
+      operators.filter((data2) => !!data2[3] && !!data2[4]),
+      operators.map(([positions3, orders2, markPrices2, accountInfo2, symbolInfo2]) => {
+        var _a;
+        return futures.account.totalInitialMarginWithOrders({
+          positions: positionsPath(positions3),
+          orders: (_a = orders2 == null ? void 0 : orders2[0]) != null ? _a : [],
+          markPrices: markPrices2,
+          IMR_Factors: accountInfo2.imr_factor,
+          maxLeverage: accountInfo2.max_leverage,
+          symbolInfo: symbolInfo2
+        });
+      })
+    ),
+    0,
+    [positions2, orders, markPrices, accountInfo, symbolInfo]
+  );
+  return {
+    totalCollateral: totalCollateral.toDecimalPlaces(dp).toNumber(),
+    freeCollateral: futures.account.freeCollateral({
+      totalCollateral,
+      totalInitialMarginWithOrders
+    }).toDecimalPlaces(dp).toNumber(),
+    totalValue: 0
+  };
+};
+var positionsPath2 = ramda.pathOr([], [0, "rows"]);
+var useMaxQty = (symbol, side, reduceOnly = false) => {
+  var _a;
+  const positions2 = usePositionStream();
+  const orders = useOrderStream();
+  const { info: accountInfo } = useAccount();
+  const symbolInfo = useSymbolsInfo();
+  const { totalCollateral } = useCollateral();
+  const markPrices = useMarkPriceStream();
+  const maxQty = rxjsHooks.useObservable(
+    (_, input$) => input$.pipe(
+      operators.switchMap(
+        ([{ reduceOnly: reduceOnly2 }]) => rxjs.iif(
+          () => reduceOnly2,
+          input$.pipe(
+            operators.filter(([{ positions: positions3 }]) => positions3.length > 0),
+            operators.map(
+              ([
+                {
+                  positions: positions3,
+                  symbol: symbol2,
+                  side: side2
+                }
+              ]) => {
+                const positionQty = futures.account.getQtyFromPositions(
+                  positions3,
+                  symbol2
+                );
+                if (positionQty > 0) {
+                  if (side2 === types.OrderSide.BUY) {
+                    return 0;
+                  } else {
+                    return Math.abs(positionQty);
+                  }
+                }
+                if (positionQty < 0) {
+                  if (side2 === types.OrderSide.BUY) {
+                    return Math.abs(positionQty);
+                  } else {
+                    return 0;
+                  }
+                }
+                return 0;
+              }
+            )
+          ),
+          input$.pipe(
+            operators.filter(
+              ([
+                {
+                  markPrices: markPrices2,
+                  positions: positions3,
+                  orders: orders2,
+                  accountInfo: accountInfo2,
+                  symbolInfo: symbolInfo2,
+                  symbol: symbol2,
+                  side: side2,
+                  totalCollateral: totalCollateral2
+                }
+              ]) => !!symbol2 && !!side2 && !!markPrices2[symbol2] && !!positions3 && !!orders2 && !!accountInfo2 && !!symbolInfo2 && !!totalCollateral2
+            ),
+            // 数据准备
+            operators.map(
+              ([
+                {
+                  markPrices: markPrices2,
+                  positions: positions3,
+                  orders: orders2,
+                  accountInfo: accountInfo2,
+                  symbolInfo: symbolInfo2,
+                  symbol: symbol2,
+                  side: side2,
+                  totalCollateral: totalCollateral2
+                }
+              ]) => {
+                const getSymbolInfo = symbolInfo2[symbol2];
+                const positionQty = futures.account.getQtyFromPositions(
+                  positions3,
+                  symbol2
+                );
+                const buyOrdersQty = futures.account.getQtyFromOrdersBySide(
+                  orders2,
+                  symbol2,
+                  types.OrderSide.BUY
+                );
+                const sellOrdersQty = futures.account.getQtyFromOrdersBySide(
+                  orders2,
+                  symbol2,
+                  types.OrderSide.SELL
+                );
+                const otherPositions = positions3.filter(
+                  (item) => item.symbol !== symbol2
+                );
+                const otherOrders = orders2.filter(
+                  (item) => item.symbol !== symbol2
+                );
+                const otherIMs = futures.account.otherIMs({
+                  orders: otherOrders,
+                  positions: otherPositions,
+                  symbolInfo: symbolInfo2,
+                  markPrices: markPrices2,
+                  IMR_Factors: accountInfo2.imr_factor,
+                  maxLeverage: accountInfo2.max_leverage
+                });
+                return [
+                  side2,
+                  {
+                    markPrice: markPrices2[symbol2],
+                    baseMaxQty: getSymbolInfo("base_max"),
+                    totalCollateral: totalCollateral2,
+                    maxLeverage: accountInfo2.max_leverage,
+                    takerFeeRate: accountInfo2.taker_fee_rate,
+                    baseIMR: getSymbolInfo("base_imr"),
+                    otherIMs,
+                    positionQty,
+                    buyOrdersQty,
+                    sellOrdersQty,
+                    IMR_Factor: accountInfo2.imr_factor[getSymbolInfo("base")]
+                  },
+                  {
+                    dp: getSymbolInfo("base_tick")
+                  }
+                ];
+              }
+            ),
+            operators.map(([side2, inputs, options]) => {
+              const maxQty2 = futures.account.maxQty(side2, inputs);
+              return maxQty2;
+            }),
+            operators.distinct()
+            // tap((data: number) => console.log("************", data))
+          )
+        )
+      )
+    ),
+    0,
+    [
+      {
+        markPrices,
+        positions: positionsPath2(positions2),
+        orders: (_a = orders[0]) != null ? _a : [],
+        accountInfo,
+        symbolInfo,
+        symbol,
+        side,
+        totalCollateral,
+        reduceOnly
+      }
+    ]
+  );
+  return maxQty;
+};
+var { maxPrice, minPrice } = futures.order;
+var BaseOrderCreator = class {
+  baseOrder(data) {
+    const order2 = {
+      // symbol: data.symbol,
+      order_type: !!data.order_type_ext ? data.order_type_ext : data.order_type,
+      side: data.side,
+      // reduce_only: data.reduce_only,
+      order_quantity: data.order_quantity
+    };
+    if (data.visible_quantity === 0) {
+      order2.visible_quantity = data.visible_quantity;
+    }
+    return order2;
+  }
+  baseValidate(values, configs) {
+    const errors = {};
+    const { maxQty } = configs;
+    const { order_quantity, total } = values;
+    if (!order_quantity) {
+      errors.order_quantity = "quantity is required";
+    } else {
+      const { base_max, base_min } = configs.symbol;
+      const qty = new utils.Decimal(order_quantity);
+      if (qty.lt(base_min)) {
+        errors.order_quantity = `quantity must be greater than ${base_min}`;
+      } else if (qty.gt(maxQty)) {
+        errors.order_quantity = `quantity must be less than ${base_max}`;
+      }
+    }
+    if (!!total) {
+      const { quote_max, quote_min } = configs.symbol;
+      const totalNumber = new utils.Decimal(total);
+      if (totalNumber.lt(quote_min)) {
+        errors.total = `Quantity should be greater than ${quote_min}`;
+      } else if (totalNumber.gt(quote_max)) {
+        errors.total = `Quantity should be less or equal than ${quote_max}`;
+      }
+    }
+    return Promise.resolve(errors);
+  }
+};
+var LimitOrderCreator = class extends BaseOrderCreator {
+  create(values) {
+    return __spreadProps(__spreadValues({}, this.baseOrder(values)), {
+      order_price: values.order_price
+    });
+  }
+  validate(values, config) {
+    return this.baseValidate(values, config).then((errors) => {
+      const { order_price } = values;
+      if (!order_price) {
+        errors.order_price = "price is required";
+      } else {
+        const price = new utils.Decimal(order_price);
+        const { symbol } = config;
+        const { price_range } = symbol;
+        const maxPriceNumber = maxPrice(config.markPrice, price_range);
+        const minPriceNumber = minPrice(config.markPrice, price_range);
+        if (price.lt(minPriceNumber)) {
+          errors.order_price = `price must be greater than ${minPriceNumber}`;
+        } else if (price.gt(maxPriceNumber)) {
+          errors.order_price = `price must be less than ${maxPriceNumber}`;
+        }
+      }
+      return errors;
+    });
+  }
+};
+var MarketOrderCreator = class extends BaseOrderCreator {
+  create(values) {
+    return __spreadValues({}, this.baseOrder(values));
+  }
+  validate(values, configs) {
+    return this.baseValidate(values, configs);
+  }
+};
+var PostOnlyOrderCreator = class extends LimitOrderCreator {
+};
+var FOKOrderCreator = class extends LimitOrderCreator {
+};
+var IOCOrderCreator = class extends LimitOrderCreator {
+};
+var GeneralOrderCreator = class extends BaseOrderCreator {
+  create(data) {
+    return __spreadProps(__spreadValues({}, this.baseOrder(data)), {
+      order_price: data.order_price,
+      order_quantity: data.order_quantity
+    });
+  }
+  validate(values, configs) {
+    return super.baseValidate(values, configs);
+  }
+};
+var OrderFactory = class {
+  static create(type2) {
+    switch (type2) {
+      case types.OrderType.LIMIT:
+        return new LimitOrderCreator();
+      case types.OrderType.MARKET:
+        return new MarketOrderCreator();
+      case types.OrderType.IOC:
+        return new IOCOrderCreator();
+      case types.OrderType.FOK:
+        return new FOKOrderCreator();
+      case types.OrderType.POST_ONLY:
+        return new PostOnlyOrderCreator();
+      default:
+        return new GeneralOrderCreator();
+    }
+  }
+};
+
+// src/orderly/useOrderEntry.ts
+var useOrderEntry = (symbol, initialValue = {}, options) => {
+  const { mutation } = useMutation("/order");
+  const { freeCollateral } = useCollateral();
+  const symbolInfo = useSymbolsInfo();
+  const tokenInfo = useTokenInfo();
+  const baseDP = react.useMemo(
+    () => utils.getPrecisionByNumber(symbolInfo[symbol]("base_tick", 0)),
+    [symbolInfo]
+  );
+  const quoteDP = react.useMemo(() => {
+    return tokenInfo.USDC("decimals", 0);
+  }, [tokenInfo]);
+  const [valuesUpdate, [orderExtraValues]] = rxjsHooks.useEventCallback(
+    (event$, state$) => {
+      return event$.pipe(
+        operators.withLatestFrom(state$),
+        operators.map(([event, state]) => {
+          const { field, value } = event;
+          console.log("orderExtraValues", field, value);
+          return [__spreadProps(__spreadValues({}, state[0]), { [field]: value })];
+        })
+      );
+    },
+    [
+      {
+        order_type: types.OrderType.MARKET,
+        side: types.OrderSide.BUY,
+        reduce_only: false
+      }
+    ]
+  );
+  const ws = useWebSocketClient();
+  const markPrice = rxjsHooks.useObservable(
+    (_, input$) => input$.pipe(
+      operators.switchMap(([symbol2]) => {
+        return ws.observe(`${symbol2}@markprice`).pipe(
+          operators.map((data) => data.price)
+          // takeWhile(() => type === OrderType.MARKET)
+        );
+      })
+    ),
+    0,
+    [symbol]
+  );
+  const formik$1 = formik.useFormik({
+    initialValues: __spreadValues({
+      // order_type: OrderType.MARKET,
+      // side: OrderSide.BUY,
+      order_quantity: "",
+      total: "",
+      order_price: "",
+      visible_quantity: 1
+    }, initialValue),
+    validate: (values) => {
+      const creator = OrderFactory.create(orderExtraValues.order_type);
+      return creator == null ? void 0 : creator.validate(values, {
+        symbol: symbolInfo[symbol](),
+        token: tokenInfo[symbol](),
+        maxQty,
+        markPrice
+      });
+    },
+    onSubmit: (values) => {
+      console.log(values);
+    }
+  });
+  const maxQty = useMaxQty(
+    symbol,
+    orderExtraValues.side,
+    orderExtraValues.reduce_only
+  );
+  const formFieldds = react.useMemo(() => {
+    return ["order_quantity", "order_price", "total"];
+  }, []);
+  const setValue = (field, value) => {
+    if (formFieldds.indexOf(field) < 0) {
+      valuesUpdate({ field, value });
+      return;
+    }
+    const fieldHandler = getCalculateHandler(field);
+    const newValues = ramda.compose(
+      ramda.head,
+      orderEntityFormatHandle(),
+      fieldHandler,
+      baseInputHandle
+    )([
+      __spreadValues(__spreadValues({}, formik$1.values), orderExtraValues),
+      field,
+      value,
+      markPrice,
+      { baseDP, quoteDP }
+    ]);
+    formik$1.setValues(newValues, true);
+  };
+  const onSubmit = (values) => {
+    values = values || formik$1.values;
+    if (typeof values.order_type === "undefined" || values.order_type !== types.OrderType.MARKET && values.order_type !== types.OrderType.LIMIT) {
+      throw new Error("order_type is error");
+    }
+    return Promise.resolve().then(() => {
+      const orderCreator = OrderFactory.create(
+        !!values.order_type_ext ? values.order_type_ext : values.order_type
+      );
+      if (!orderCreator) {
+        throw new Error("orderCreator is null");
+      }
+      if (!symbol) {
+        throw new Error("symbol is null");
+      }
+      const data = orderCreator.create(values);
+      console.log("orderentry data:::", data);
+      formik$1.setSubmitting(true);
+      return mutation(__spreadProps(__spreadValues({}, data), {
+        symbol
+      })).finally(() => {
+        formik$1.setSubmitting(false);
+      });
+    });
+  };
+  react.useEffect(() => {
+    formik$1.resetForm();
+  }, [symbol]);
+  return {
+    maxQty,
+    // formState,
+    values: __spreadValues(__spreadValues({}, formik$1.values), orderExtraValues),
+    errors: formik$1.errors,
+    freeCollateral,
+    markPrice,
+    setValue,
+    onSubmit,
+    isSubmitting: formik$1.isSubmitting,
+    resetForm: formik$1.resetForm,
+    validateForm: formik$1.validateForm,
+    submitCount: formik$1.submitCount,
+    symbolConfig: symbolInfo[symbol]()
+  };
+};
+var useFetures = () => {
+  const { data, isLoading, error } = useQuery(`/public/futures`);
+  const [sortedData, setSortedData] = react.useState(data);
+  const ws = useWebSocketClient();
+  react.useEffect(() => {
+    const sub = ws.observe(`tickers`).subscribe((value) => {
+      console.log("useTickers", value);
+    });
+    return () => {
+      sub.unsubscribe();
+    };
+  }, []);
+  react.useEffect(() => {
+    if (data) {
+      const sortedData2 = data.sort((a, b) => {
+        return 0;
+      });
+      setSortedData(sortedData2);
+    }
+  }, [data]);
+  const sortBy = react.useCallback((key) => {
+  }, [data]);
+  const filterBy = react.useCallback((key) => {
+  }, [data]);
+  return {
+    // ...data,
+    data: sortedData,
+    sortBy,
+    filterBy,
+    isLoading,
+    error
+  };
+};
+var useMarketsStream = () => {
+  const ws = useWebSocketClient();
+  const { data } = useQuery(`/public/futures`);
+  const value = rxjsHooks.useObservable(
+    (_, input$) => ws.observe("tickers").pipe(
+      operators.startWith([]),
+      operators.withLatestFrom(input$.pipe(operators.map((args) => args[0]))),
+      operators.map((args) => {
+        if (args[0].length === 0) {
+          return args[1];
+        }
+        return args[1].map((item) => {
+          const ticker = args[0].find(
+            (t) => t.symbol === item.symbol
+          );
+          if (ticker) {
+            return __spreadProps(__spreadValues({}, item), {
+              ["24h_close"]: ticker.close,
+              ["24h_open"]: ticker.open,
+              ["24h_volumn"]: ticker.volume,
+              change: 0
+            });
+          }
+          return item;
+        });
+      })
+    ),
+    null,
+    [data]
+  );
+  return { data: value };
+};
+var useFundingRate = (symbol) => {
+  if (!symbol) {
+    throw new Error("useFuturesForSymbol requires a symbol");
+  }
+  const [countDown, setCountDown] = react.useState("00:00:00");
+  const { data } = useQuery(`/public/funding_rate/${symbol}`, {
+    fallbackData: {
+      est_funding_rate: 0,
+      next_funing_time: 0
+    }
+  });
+  react.useEffect(() => {
+    if (!data)
+      return;
+    const { next_funding_time } = data;
+    if (!next_funding_time || next_funding_time <= 0) {
+      return;
+    }
+    const timer = setInterval(() => {
+      const diff = new Date(next_funding_time).getTime() - Date.now();
+      const result = utils.timeConvertString(diff);
+      if (result.length === 3) {
+        setCountDown(
+          `${result[0].toString().padStart(2, "0")}:${result[1].toString().padStart(2, "0")}:${result[2].toString().padStart(2, "0")}`
+        );
+      }
+    }, 1e3);
+    return () => {
+      clearInterval(timer);
+    };
+  }, [data]);
+  return __spreadProps(__spreadValues({}, data), {
+    countDown
+  });
+};
+
+// src/apis/index.ts
+var apis_exports = {};
+__export(apis_exports, {
+  useFundingRate: () => useFundingRate2,
+  useFundingRateBySymbol: () => useFundingRateBySymbol,
+  useInfo: () => useInfo,
+  useToken: () => useToken
+});
+
+// src/apis/useInfo.ts
+var useInfo = () => {
+  return useQuery("/public/info", {
+    // refreshInterval: 1000 * 60 * 60 * 24,
+  });
+};
+
+// src/apis/useToken.ts
+var useToken = () => {
+  return useQuery("/public/token");
+};
+
+// src/apis/useFundingRateBySymbol.ts
+var useFundingRateBySymbol = (symbol) => {
+  if (!symbol) {
+    throw new Error("symbol is required");
+  }
+  return useQuery(`/public/funding_rate/${symbol}`);
+};
+
+// src/apis/useFundingRate.ts
+var useFundingRate2 = (symbol) => {
+  return useQuery(`/public/funding_rate`);
+};
+
+Object.defineProperty(exports, 'useSWR', {
+  enumerable: true,
+  get: function () { return useSWR__default.default; }
+});
+Object.defineProperty(exports, 'useConstant', {
+  enumerable: true,
+  get: function () { return useConstant__default.default; }
+});
+Object.defineProperty(exports, 'useEventCallback', {
+  enumerable: true,
+  get: function () { return rxjsHooks.useEventCallback; }
+});
+Object.defineProperty(exports, 'useObservable', {
+  enumerable: true,
+  get: function () { return rxjsHooks.useObservable; }
+});
+exports.OrderStatus = OrderStatus;
+exports.OrderlyContext = OrderlyContext;
+exports.OrderlyProvider = OrderlyProvider;
+exports.apis = apis_exports;
+exports.useAccount = useAccount;
+exports.useCollateral = useCollateral;
+exports.useFetures = useFetures;
+exports.useFundingRate = useFundingRate;
+exports.useMarketsStream = useMarketsStream;
+exports.useMaxQty = useMaxQty;
+exports.useMutation = useMutation;
+exports.useOrderEntry = useOrderEntry;
+exports.useOrderStream = useOrderStream;
+exports.useOrderbook = useOrderbook;
+exports.usePositionStream = usePositionStream;
+exports.usePrivateObserve = usePrivateObserve;
+exports.usePrivateQuery = usePrivateQuery;
+exports.useQuery = useQuery;
+exports.useSymbolsInfo = useSymbolsInfo;
+exports.useTickerStream = useTickerStream;
+exports.useTokenInfo = useTokenInfo;
+exports.useTopicObserve = useTopicObserve;
+exports.useTradingView = useTradingView;
+exports.useWebSocketClient = useWebSocketClient;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map