@orderly.network/hooks 0.0.43 → 0.0.45

package/dist/index.js

@@ -0,0 +1,2296 @@
+'use strict';
+
+var React2 = require('react');
+var useSWR = require('swr');
+var net = require('@orderly.network/net');
+var useSWRMutation = require('swr/mutation');
+var useConstant = require('use-constant');
+var core = require('@orderly.network/core');
+var types = require('@orderly.network/types');
+var useSWRSubscription = require('swr/subscription');
+var utils = require('@orderly.network/utils');
+var ramda = require('ramda');
+var futures = require('@orderly.network/futures');
+var useSWRInfinite = require('swr/infinite');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React2__default = /*#__PURE__*/_interopDefault(React2);
+var useSWR__default = /*#__PURE__*/_interopDefault(useSWR);
+var useSWRMutation__default = /*#__PURE__*/_interopDefault(useSWRMutation);
+var useConstant__default = /*#__PURE__*/_interopDefault(useConstant);
+var useSWRSubscription__default = /*#__PURE__*/_interopDefault(useSWRSubscription);
+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 prop2 in b || (b = {}))
+    if (__hasOwnProp.call(b, prop2))
+      __defNormalProp(a, prop2, b[prop2]);
+  if (__getOwnPropSymbols)
+    for (var prop2 of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop2))
+        __defNormalProp(a, prop2, b[prop2]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop2 in source)
+    if (__hasOwnProp.call(source, prop2) && exclude.indexOf(prop2) < 0)
+      target[prop2] = source[prop2];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop2 of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop2) < 0 && __propIsEnum.call(source, prop2))
+        target[prop2] = source[prop2];
+    }
+  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 = React2.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 } = React2.useContext(OrderlyContext);
+  const _a = options || {}, { formatter } = _a, swrOptions = __objRest(_a, ["formatter"]);
+  if (typeof apiBaseUrl === "undefined") {
+    throw new Error("please add OrderlyProvider to your app");
+  }
+  return useSWR__default.default(
+    // `${apiBaseUrl}${query}`,
+    query,
+    (url, init) => fetcher(url.startsWith("http") ? url : `${apiBaseUrl}${url}`, init, {
+      formatter
+    }),
+    swrOptions
+  );
+};
+var useAccountInstance = () => {
+  const { configStore, keyStore, contractManager, getWalletAdapter } = React2.useContext(OrderlyContext);
+  if (!configStore)
+    throw new Error("configStore is not defined, please use OrderlyProvider");
+  if (!keyStore) {
+    throw new Error(
+      "keyStore is not defined, please use OrderlyProvider and provide keyStore"
+    );
+  }
+  const account5 = useConstant__default.default(() => {
+    let account6 = core.SimpleDI.get("account");
+    if (!account6) {
+      account6 = new core.Account(
+        configStore,
+        keyStore,
+        contractManager,
+        getWalletAdapter
+        // walletAdapter
+      );
+      core.SimpleDI.registerByName("account", account6);
+    }
+    return account6;
+  });
+  return account5;
+};
+
+// src/useMutation.ts
+var fetcher2 = (url, options) => {
+  const init = {
+    method: options.arg.method,
+    headers: __spreadValues({}, options.arg.signature)
+  };
+  if (options.arg.data) {
+    init.body = JSON.stringify(options.arg.data);
+  }
+  if (typeof options.arg.params === "object" && Object.keys(options.arg.params).length) {
+    let search = new URLSearchParams(options.arg.params);
+    url = `${url}?${search.toString()}`;
+  }
+  return net.mutate(url, init);
+};
+var useMutation = (url, method = "POST", options) => {
+  const { apiBaseUrl } = React2.useContext(OrderlyContext);
+  let fullUrl = url;
+  if (!url.startsWith("http")) {
+    fullUrl = `${apiBaseUrl}${url}`;
+  }
+  const account5 = useAccountInstance();
+  const signer = account5.signer;
+  const { trigger, data, error, reset, isMutating } = useSWRMutation__default.default(
+    fullUrl,
+    // method === "POST" ? fetcher : deleteFetcher,
+    fetcher2,
+    options
+  );
+  const mutation = (data2, params) => __async(void 0, null, function* () {
+    let newUrl = url;
+    if (typeof params === "object" && Object.keys(params).length) {
+      let search = new URLSearchParams(params);
+      newUrl = `${url}?${search.toString()}`;
+    }
+    const payload = {
+      method,
+      url: newUrl,
+      data: data2
+    };
+    const signature = yield signer.sign(payload);
+    return trigger({
+      data: data2,
+      params,
+      method,
+      signature: __spreadProps(__spreadValues({}, signature), {
+        "orderly-account-id": account5.accountId
+      })
+    });
+  });
+  return [
+    mutation,
+    {
+      data,
+      error,
+      reset,
+      isMutating
+    }
+  ];
+};
+var signatureMiddleware = (useSWRNext) => {
+  const { apiBaseUrl } = React2.useContext(OrderlyContext);
+  return (key, fetcher4, config) => {
+    try {
+      const extendedFetcher = (args) => __async(void 0, null, function* () {
+        let url = Array.isArray(args) ? args[0] : args;
+        let account5 = core.SimpleDI.get("account");
+        let fullUrl = `${apiBaseUrl}${url}`;
+        const signer = account5.signer;
+        const payload = {
+          method: "GET",
+          url
+        };
+        const signature = yield signer.sign(payload);
+        return fetcher4(fullUrl, {
+          headers: __spreadProps(__spreadValues({}, signature), {
+            "orderly-account-id": account5.accountId
+          })
+        });
+      });
+      return useSWRNext(key, extendedFetcher, config);
+    } catch (e) {
+      console.error("signature error:", e);
+      throw e;
+    }
+  };
+};
+var useAccount = () => {
+  const {
+    configStore,
+    keyStore,
+    onWalletConnect,
+    onWalletDisconnect,
+    onSetChain
+  } = React2.useContext(OrderlyContext);
+  if (!configStore)
+    throw new Error("configStore is not defined, please use OrderlyProvider");
+  if (!keyStore) {
+    throw new Error(
+      "keyStore is not defined, please use OrderlyProvider and provide keyStore"
+    );
+  }
+  const account5 = useAccountInstance();
+  const [state, setState] = React2.useState(account5.stateValue);
+  const statusChangeHandler = (nextState) => {
+    setState(() => nextState);
+  };
+  React2.useEffect(() => {
+    account5.on("change:status", statusChangeHandler);
+    return () => {
+      account5.off("change:status", statusChangeHandler);
+    };
+  }, []);
+  const login = React2.useCallback(
+    (address) => {
+      account5.login(address);
+    },
+    [account5]
+  );
+  const createOrderlyKey = React2.useCallback(
+    (remember) => __async(void 0, null, function* () {
+      return account5.createOrderlyKey(remember ? 365 : 30);
+    }),
+    [account5]
+  );
+  const createAccount = React2.useCallback(() => __async(void 0, null, function* () {
+    return account5.createAccount();
+  }), [account5]);
+  const connect = React2.useCallback(() => __async(void 0, null, function* () {
+    return onWalletConnect == null ? void 0 : onWalletConnect();
+  }), [account5]);
+  const disconnect = () => __async(void 0, null, function* () {
+    return onWalletDisconnect == null ? void 0 : onWalletDisconnect();
+  });
+  const setChain = (chainId) => __async(void 0, null, function* () {
+    return onSetChain == null ? void 0 : onSetChain(chainId);
+  });
+  return {
+    // account: state!,
+    account: account5,
+    state,
+    // info: {},
+    login,
+    createOrderlyKey,
+    createAccount,
+    disconnect,
+    connect,
+    setChain
+    // settlement,
+  };
+};
+var usePrivateQuery = (query, options) => {
+  var _b;
+  const _a = options || {}, { formatter } = _a, swrOptions = __objRest(_a, ["formatter"]);
+  const account5 = useAccount();
+  const middleware = Array.isArray(options == null ? void 0 : options.use) ? (_b = options == null ? void 0 : options.use) != null ? _b : [] : [];
+  return useSWR__default.default(
+    () => account5.state.status >= types.AccountStatusEnum.EnableTrading ? [query, account5.state.accountId] : null,
+    // query,
+    (url, init) => {
+      return fetcher(url, init, { formatter });
+    },
+    __spreadProps(__spreadValues({}, swrOptions), {
+      use: [signatureMiddleware, ...middleware],
+      onError: (err) => {
+        console.log("usePrivateQuery error", err);
+      }
+    })
+  );
+};
+
+// src/useTradingView.ts
+var useTradingView = () => {
+  return {};
+};
+var usePrivateObserve = () => {
+  const [data, setData] = React2.useState();
+  React2.useEffect(() => {
+    return () => {
+    };
+  }, []);
+  return {
+    data
+  };
+};
+var useTopicObserve = (topic) => {
+  const [data, setData] = React2.useState();
+  React2.useEffect(() => {
+    return () => {
+    };
+  }, []);
+  return {
+    data
+  };
+};
+var useAppState = () => {
+  const { errors, ready } = React2.useContext(OrderlyContext);
+  return {
+    errors,
+    ready
+  };
+};
+
+// src/usePreloadData.ts
+var usePreLoadData = (onSuccess) => {
+  useSWR__default.default(
+    "https://fi-api.woo.org/swap_support",
+    (url) => fetch(url).then((res) => res.json()),
+    {
+      revalidateOnFocus: false,
+      //   suspense: true,
+      onSuccess: (data, key, config) => {
+        onSuccess("chains_fetch");
+      }
+    }
+  );
+};
+var useEventEmitter = (channel) => {
+  return useConstant__default.default(() => {
+    let ee = core.SimpleDI.get("EE");
+    if (!ee) {
+      ee = new core.EventEmitter();
+      core.SimpleDI.registerByName("EE", ee);
+    }
+    return ee;
+  });
+};
+
+// src/utils/json.ts
+function parseJSON(value) {
+  try {
+    return value === "undefined" ? void 0 : JSON.parse(value != null ? value : "");
+  } catch (e) {
+    console.log("parsing error on", { value });
+    return void 0;
+  }
+}
+
+// src/useSessionStorage.ts
+function useSessionStorage(key, initialValue) {
+  const readValue = React2.useCallback(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    try {
+      const item = window.sessionStorage.getItem(key);
+      return item ? parseJSON(item) : initialValue;
+    } catch (error) {
+      console.warn(`Error reading sessionStorage key \u201C${key}\u201D:`, error);
+      return initialValue;
+    }
+  }, [initialValue, key]);
+  const [storedValue, setStoredValue] = React2.useState(readValue);
+  const setValue = (value) => {
+    if (typeof window == "undefined") {
+      console.warn(
+        `Tried setting sessionStorage key \u201C${key}\u201D even though environment is not a client`
+      );
+    }
+    try {
+      const newValue = value instanceof Function ? value(storedValue) : value;
+      window.sessionStorage.setItem(key, JSON.stringify(newValue));
+      setStoredValue(newValue);
+    } catch (error) {
+      console.warn(`Error setting sessionStorage key \u201C${key}\u201D:`, error);
+    }
+  };
+  React2.useEffect(() => {
+    setStoredValue(readValue());
+  }, []);
+  React2.useEffect(() => {
+    if (typeof window == "undefined") {
+      return;
+    }
+    window.addEventListener("storage", handleStorageChange);
+    return () => {
+      window.removeEventListener("storage", handleStorageChange);
+    };
+  });
+  const handleStorageChange = React2.useCallback(
+    (event) => {
+      if ((event == null ? void 0 : event.key) && event.key !== key) {
+        return;
+      }
+      setStoredValue(readValue());
+    },
+    [key, readValue]
+  );
+  return [storedValue, setValue];
+}
+function useLocalStorage(key, initialValue) {
+  const readValue = React2.useCallback(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    try {
+      const item = window.localStorage.getItem(key);
+      return item ? parseJSON(item) : initialValue;
+    } catch (error) {
+      console.warn(`Error reading localStorage key \u201C${key}\u201D:`, error);
+      return initialValue;
+    }
+  }, [initialValue, key]);
+  const [storedValue, setStoredValue] = React2.useState(readValue);
+  const setValue = React2.useCallback(
+    (value) => {
+      if (typeof window === "undefined") {
+        console.warn(
+          `Tried setting localStorage key \u201C${key}\u201D even though environment is not a client`
+        );
+      }
+      try {
+        const newValue = value instanceof Function ? value(storedValue) : value;
+        window.localStorage.setItem(key, JSON.stringify(newValue));
+        setStoredValue(() => newValue);
+      } catch (error) {
+        console.warn(`Error setting localStorage key \u201C${key}\u201D:`, error);
+      }
+    },
+    [storedValue]
+  );
+  React2.useEffect(() => {
+    setStoredValue(readValue());
+  }, []);
+  return [storedValue, setValue];
+}
+var useRunOnce = ({ fn, sessionKey }) => {
+  const triggered = React2.useRef(false);
+  React2.useEffect(() => {
+    const hasBeenTriggered = sessionKey ? sessionStorage.getItem(sessionKey) : triggered.current;
+    if (!hasBeenTriggered) {
+      fn();
+      triggered.current = true;
+      if (sessionKey) {
+        sessionStorage.setItem(sessionKey, "true");
+      }
+    }
+  }, [fn, sessionKey]);
+  return null;
+};
+var DataSourceContext = React2.createContext({});
+var DataSourceProvider = (props) => {
+  console.log("render DataSourceProvider");
+  useAccountInstance();
+  useConstant__default.default(() => {
+  });
+  return /* @__PURE__ */ React2__default.default.createElement(DataSourceContext.Provider, { value: {} }, props.children);
+};
+var WS_NAME = "nativeWebsocketClient";
+var useWS = () => {
+  useAccount();
+  const { configStore } = React2.useContext(OrderlyContext);
+  const ws = useConstant__default.default(() => {
+    let websocketClient = core.SimpleDI.get(WS_NAME);
+    const account5 = core.SimpleDI.get(core.Account.instanceName);
+    if (!websocketClient) {
+      websocketClient = new net.WS({
+        // accountId: "OqdphuyCtYWxwzhxyLLjOWNdFP7sQt8RPWzmb5xY",
+        networkId: "testnet",
+        publicUrl: configStore.get("publicWsUrl"),
+        privateUrl: configStore.get("privateWsUrl"),
+        onSigntureRequest: (accountId) => __async(void 0, null, function* () {
+          const signer = account5.signer;
+          const timestamp = (/* @__PURE__ */ new Date()).getTime();
+          const result = yield signer.signText(timestamp.toString());
+          return __spreadProps(__spreadValues({}, result), { timestamp });
+        })
+      });
+      account5.on("change:status", (nextState) => {
+        if (nextState.status === types.AccountStatusEnum.EnableTrading && nextState.accountId) {
+          websocketClient.openPrivate(nextState.accountId);
+        }
+      });
+      core.SimpleDI.registerByName(WS_NAME, websocketClient);
+    }
+    return websocketClient;
+  });
+  return ws;
+};
+var useConfig = () => {
+  const { configStore } = React2.useContext(OrderlyContext);
+  return configStore;
+};
+var useTickerStream = (symbol) => {
+  if (!symbol) {
+    throw new Error("useFuturesForSymbol requires a symbol");
+  }
+  const { data: info } = useQuery(
+    `/v1/public/futures/${symbol}`,
+    {
+      revalidateOnFocus: false
+    }
+  );
+  const ws = useWS();
+  const { data: ticker } = useSWRSubscription__default.default(
+    `${symbol}@ticker`,
+    (key, { next }) => {
+      const unsubscribe = ws.subscribe(
+        // { event: "subscribe", topic: "markprices" },
+        `${symbol}@ticker`,
+        {
+          onMessage: (message) => {
+            next(null, message);
+          }
+          // onUnsubscribe: () => {
+          //   return "markprices";
+          // },
+          // onError: (error: any) => {
+          //   console.log("error", error);
+          // },
+        }
+      );
+      return () => {
+        console.log("unsubscribe!!!!!!!");
+        unsubscribe == null ? void 0 : unsubscribe();
+      };
+    }
+  );
+  const value = React2.useMemo(() => {
+    if (!info)
+      return null;
+    if (!ticker)
+      return info;
+    const config = __spreadValues({}, info);
+    if (ticker.close !== void 0) {
+      config["24h_close"] = ticker.close;
+    }
+    if (ticker.open !== void 0) {
+      config["24h_open"] = ticker.open;
+    }
+    if (ticker.volume !== void 0) {
+      config["24h_volumn"] = ticker.volume;
+    }
+    if (ticker.close !== void 0 && ticker.open !== void 0) {
+      config["change"] = new utils.Decimal(ticker.close).minus(ticker.open).div(ticker.open).toNumber();
+    }
+    return config;
+  }, [info, ticker]);
+  return value;
+};
+var useMarkPrice = (symbol) => {
+  const ws = useWS();
+  return useSWRSubscription__default.default(`${symbol}@markprice`, (key, { next }) => {
+    const unsubscribe = ws.subscribe(`${symbol}@markprice`, {
+      onMessage: (message) => {
+        next(null, message.price);
+      }
+    });
+    return () => {
+      console.log("unsubscribe useMarkPrice !!!!!!!");
+      unsubscribe == null ? void 0 : unsubscribe();
+    };
+  });
+};
+
+// 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];
+        }
+      };
+    }
+  });
+}
+var useSymbolsInfo = () => {
+  const { data = {} } = useQuery(`/v1/public/info`, {
+    focusThrottleInterval: 1e3 * 60 * 60 * 24,
+    dedupingInterval: 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("_");
+        const base_dp = utils.getPrecisionByNumber(item.base_tick);
+        const quote_dp = utils.getPrecisionByNumber(item.quote_tick);
+        obj[item.symbol] = __spreadProps(__spreadValues({}, item), {
+          base_dp,
+          quote_dp,
+          base: arr[1],
+          quote: arr[2],
+          type: arr[0],
+          name: `${arr[1]}-${arr[0]}`
+        });
+      }
+      return obj;
+    }
+  });
+  return createGetter(data);
+};
+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, asks = false) => {
+  if (!Array.isArray(data) || data.length === 0) {
+    return [];
+  }
+  let newData = [...data];
+  const result = [];
+  if (typeof depth !== "undefined") {
+    const prices = /* @__PURE__ */ new Map();
+    for (let i = 0; i < data.length; i++) {
+      const [price, quantity] = data[i];
+      if (isNaN(price) || isNaN(quantity))
+        continue;
+      let priceKey;
+      if (asks) {
+        priceKey = new utils.Decimal(Math.ceil(price / depth)).mul(depth).toNumber();
+      } else {
+        priceKey = new utils.Decimal(Math.floor(price / depth)).mul(depth).toNumber();
+      }
+      if (prices.has(priceKey)) {
+        const item = prices.get(priceKey);
+        const itemPrice = new utils.Decimal(item[1]).add(quantity).toNumber();
+        prices.set(priceKey, [priceKey, itemPrice]);
+      } else {
+        prices.set(priceKey, [priceKey, quantity]);
+      }
+    }
+    newData = Array.from(prices.values());
+  }
+  for (let i = 0; i < newData.length; i++) {
+    const [price, quantity] = newData[i];
+    if (isNaN(price) || isNaN(quantity))
+      continue;
+    const newQuantity = new utils.Decimal(quantity).add(result.length > 0 ? result[result.length - 1][2] : 0).toNumber();
+    result.push([price, quantity, newQuantity]);
+  }
+  return result;
+};
+var reduceOrderbook = (depth, level, data) => {
+  const asks = reduceItems(depth, level, data.asks, true).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;
+  data = data.filter(([price]) => !isNaN(price));
+  while (update.length > 0) {
+    const item = update.shift();
+    if (item) {
+      const [price, quantity] = item;
+      const index = data.findIndex(([p], index2) => p === price);
+      if (index === -1) {
+        if (quantity === 0)
+          continue;
+        data.push(item);
+      } else {
+        if (quantity === 0) {
+          data.splice(index, 1);
+          continue;
+        } else {
+          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 useOrderbookStream = (symbol, initial = { asks: [], bids: [] }, options) => {
+  if (!symbol) {
+    throw new Error("useOrderbookStream requires a symbol");
+  }
+  const [requestData, setRequestData] = React2.useState(null);
+  const [data, setData] = React2.useState(initial);
+  const [isLoading, setIsLoading] = React2.useState(true);
+  const [level, setLevel] = React2.useState(() => {
+    var _a;
+    return (_a = options == null ? void 0 : options.level) != null ? _a : 10;
+  });
+  const config = useSymbolsInfo()[symbol];
+  const [depth, setDepth] = React2.useState();
+  const depths = React2.useMemo(() => {
+    const tick = config("quote_tick");
+    return [tick, tick * 10, tick * 100, tick * 1e3];
+  }, [config("quote_tick")]);
+  React2.useEffect(() => {
+    setDepth(config("quote_tick"));
+  }, [config("quote_tick")]);
+  const ws = useWS();
+  const ticker = useTickerStream(symbol);
+  const eventEmitter = useEventEmitter();
+  React2.useEffect(() => {
+    ws.onceSubscribe(
+      {
+        event: "request",
+        id: `${symbol}@orderbook`,
+        params: {
+          type: "orderbook",
+          symbol
+        }
+      },
+      {
+        onMessage: (message) => {
+          if (!!message) {
+            const reduceOrderbookData = reduceOrderbook(depth, level, message);
+            setRequestData(reduceOrderbookData);
+            setData(reduceOrderbookData);
+          }
+          setIsLoading(false);
+        }
+      }
+    );
+    return () => {
+      setRequestData(null);
+    };
+  }, [symbol, depth]);
+  const { data: markPrice } = useMarkPrice(symbol);
+  React2.useEffect(() => {
+    if (!requestData)
+      return;
+    const subscription = ws.subscribe(
+      {
+        event: "subscribe",
+        topic: `${symbol}@orderbookupdate`
+      },
+      {
+        onMessage: (message) => {
+          setData((data2) => {
+            const mergedData = !message.asks && !message.bids ? data2 : mergeOrderbook(data2, message);
+            const reducedData = reduceOrderbook(depth, level, mergedData);
+            return reducedData;
+          });
+        }
+      }
+    );
+    return () => {
+      subscription == null ? void 0 : subscription();
+    };
+  }, [symbol, requestData]);
+  const onItemClick = React2.useCallback((item) => {
+    eventEmitter.emit("orderbook:item:click", item);
+  }, []);
+  const onDepthChange = React2.useCallback((depth2) => {
+    setDepth(() => depth2);
+  }, []);
+  const prevMiddlePrice = React2.useRef(0);
+  const middlePrice = React2.useMemo(() => {
+    let asksFrist = 0, bidsFirst = 0;
+    if (data.asks.length > 0) {
+      asksFrist = data.asks[data.asks.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]);
+  React2.useEffect(() => {
+    prevMiddlePrice.current = middlePrice;
+  }, [middlePrice]);
+  return [
+    {
+      asks: data.asks.slice(-level),
+      bids: data.bids.slice(0, level),
+      markPrice,
+      middlePrice: [prevMiddlePrice.current, middlePrice]
+    },
+    { onDepthChange, depth, allDepths: depths, isLoading, onItemClick }
+  ];
+};
+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) {
+    values.order_price = price.toDecimalPlaces(config.quoteDP).toString();
+  }
+  price.toDecimalPlaces(Math.min(priceDP, config.quoteDP));
+  if (!values.order_quantity) {
+    return [values, input, value, markPrice, config];
+  }
+  const total = price.mul(values.order_quantity);
+  return [
+    __spreadProps(__spreadValues({}, values), {
+      total: total.todp(2).toString()
+    }),
+    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();
+  }
+  if (values.order_type === types.OrderType.MARKET) {
+    const price = markPrice;
+    values.total = quantity.mul(price).todp(2).toNumber();
+  }
+  if (values.order_type === types.OrderType.LIMIT) {
+    if (values.order_price) {
+      const price = Number(values.order_price);
+      const total = quantity.mul(price);
+      values.total = total.todp(2).toNumber();
+    } else {
+      values.total = "";
+    }
+  }
+  return [
+    __spreadValues({}, values),
+    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(
+    `/v1/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 useMarkPricesStream = () => {
+  const ws = useWS();
+  return useSWRSubscription__default.default("markPrices", (key, { next }) => {
+    const unsubscribe = ws.subscribe(
+      // { event: "subscribe", topic: "markprices" },
+      "markprices",
+      {
+        onMessage: (message) => {
+          const data = /* @__PURE__ */ Object.create(null);
+          for (let index = 0; index < message.length; index++) {
+            const element = message[index];
+            data[element.symbol] = element.price;
+          }
+          next(null, data);
+        },
+        // onUnsubscribe: () => {
+        //   return "markprices";
+        // },
+        onError: (error) => {
+          console.log("error", error);
+        }
+      }
+    );
+    return () => {
+      console.log("unsubscribe!!!!!!!");
+      unsubscribe == null ? void 0 : unsubscribe();
+    };
+  });
+};
+
+// src/utils/parseHolding.ts
+var parseHolding = (holding, markPrices) => {
+  const nonUSDC = [];
+  let USDC_holding = 0;
+  holding.forEach((item) => {
+    var _a;
+    if (item.token === "USDC") {
+      USDC_holding = item.holding;
+    } else {
+      nonUSDC.push({
+        holding: item.holding,
+        markPrice: (_a = markPrices[item.token]) != null ? _a : 0,
+        // markPrice: 0,
+        discount: 0
+      });
+    }
+  });
+  return [USDC_holding, nonUSDC];
+};
+var usePositionStream = (symbol, options) => {
+  var _a;
+  const symbolInfo = useSymbolsInfo();
+  useEventEmitter();
+  const { data: accountInfo } = usePrivateQuery("/v1/client/info");
+  const { data: holding } = usePrivateQuery(
+    "/v1/client/holding",
+    {
+      formatter: (data2) => {
+        return data2.holding;
+      }
+    }
+  );
+  const fundingRates = useFundingRates();
+  const {
+    data,
+    error
+    // mutate: updatePositions,
+  } = usePrivateQuery(`/v1/positions`, __spreadProps(__spreadValues({}, options), {
+    formatter: (data2) => data2,
+    onError: (err) => {
+      console.log("usePositionStream error", err);
+    }
+  }));
+  const { data: markPrices } = useMarkPricesStream();
+  const formatedPositions = React2.useMemo(() => {
+    if (!(data == null ? void 0 : data.rows) || !symbolInfo || !accountInfo)
+      return null;
+    const filteredData = typeof symbol === "undefined" || symbol === "" ? data.rows : data.rows.filter((item) => {
+      return item.symbol === symbol;
+    });
+    let unrealPnL_total = utils.zero, notional_total = utils.zero, unsettlementPnL_total = utils.zero;
+    const formatted = filteredData.map((item) => {
+      var _a2;
+      const price = ramda.propOr(
+        item.mark_price,
+        item.symbol,
+        markPrices
+      );
+      const notional = futures.positions.notional(item.position_qty, price);
+      const unrealPnl = futures.positions.unrealizedPnL({
+        qty: item.position_qty,
+        openPrice: item.average_open_price,
+        markPrice: price
+      });
+      const unsettlementPnL = futures.positions.unsettlementPnL({
+        positionQty: item.position_qty,
+        markPrice: price,
+        costPosition: item.cost_position,
+        sumUnitaryFunding: (_a2 = fundingRates[item.symbol]) == null ? void 0 : _a2.call(
+          fundingRates,
+          "sum_unitary_funding",
+          0
+        ),
+        lastSumUnitaryFunding: item.last_sum_unitary_funding
+      });
+      unrealPnL_total = unrealPnL_total.add(unrealPnl);
+      notional_total = notional_total.add(notional);
+      unsettlementPnL_total = unsettlementPnL_total.add(unsettlementPnL);
+      return __spreadProps(__spreadValues({}, item), {
+        mark_price: price,
+        mm: 0,
+        notional,
+        unsettlement_pnl: unsettlementPnL,
+        unrealized_pnl: unrealPnl
+      });
+    });
+    return [
+      formatted,
+      {
+        unrealPnL: unrealPnL_total.toNumber(),
+        notional: notional_total.toNumber(),
+        unsettledPnL: unsettlementPnL_total.toNumber()
+      }
+    ];
+  }, [data == null ? void 0 : data.rows, symbolInfo, accountInfo, markPrices, symbol, holding]);
+  const [totalCollateral, totalValue, totalUnrealizedROI] = React2.useMemo(() => {
+    if (!holding || !markPrices) {
+      return [utils.zero, utils.zero, 0];
+    }
+    const unsettlemnedPnL = ramda.pathOr(0, [1, "unsettledPnL"])(formatedPositions);
+    const unrealizedPnL = ramda.pathOr(0, [1, "unrealPnL"])(formatedPositions);
+    const [USDC_holding, nonUSDC] = parseHolding(holding, markPrices);
+    const totalCollateral2 = futures.account.totalCollateral({
+      USDCHolding: USDC_holding,
+      nonUSDCHolding: nonUSDC,
+      unsettlementPnL: unsettlemnedPnL
+    });
+    const totalValue2 = futures.account.totalValue({
+      totalUnsettlementPnL: unsettlemnedPnL,
+      USDCHolding: USDC_holding,
+      nonUSDCHolding: nonUSDC
+    });
+    const totalUnrealizedROI2 = futures.account.totalUnrealizedROI({
+      totalUnrealizedPnL: unrealizedPnL,
+      totalValue: totalValue2.toNumber()
+    });
+    return [totalCollateral2, totalValue2, totalUnrealizedROI2];
+  }, [holding, formatedPositions, markPrices]);
+  const positionsRows = React2.useMemo(() => {
+    if (!formatedPositions)
+      return null;
+    if (!symbolInfo || !accountInfo)
+      return formatedPositions[0];
+    const total = totalCollateral.toNumber();
+    return formatedPositions[0].filter((item) => item.position_qty !== 0).map((item) => {
+      const info = symbolInfo == null ? void 0 : symbolInfo[item.symbol];
+      const MMR = futures.positions.MMR({
+        baseMMR: info("base_mmr"),
+        baseIMR: info("base_imr"),
+        IMRFactor: accountInfo.imr_factor[info("base")],
+        positionNotional: item.notional,
+        IMR_factor_power: 4 / 5
+      });
+      return __spreadProps(__spreadValues({}, item), {
+        mm: futures.positions.maintenanceMargin({
+          positionQty: item.position_qty,
+          markPrice: item.mark_price,
+          MMR
+        }),
+        est_liq_price: futures.positions.liqPrice({
+          markPrice: item.mark_price,
+          totalCollateral: total,
+          positionQty: item.position_qty,
+          MMR
+        }),
+        MMR
+      });
+    });
+  }, [formatedPositions, symbolInfo, accountInfo, totalCollateral]);
+  return [
+    {
+      rows: positionsRows,
+      aggregated: (_a = formatedPositions == null ? void 0 : formatedPositions[1]) != null ? _a : {},
+      totalCollateral,
+      totalValue,
+      totalUnrealizedROI
+    },
+    createGetter(data, 1),
+    {
+      // close: onClosePosition,
+      loading: false,
+      // showSymbol,
+      error,
+      loadMore: () => {
+      },
+      refresh: () => {
+      }
+    }
+  ];
+};
+var pathOr_unsettledPnLPathOr = ramda.pathOr(0, [
+  0,
+  "aggregated",
+  "unsettledPnL"
+]);
+var useHoldingStream = () => {
+  const ws = useWS();
+  const { data, isLoading, mutate: mutate2 } = usePrivateQuery(
+    "/v1/client/holding",
+    {
+      formatter: (data2) => {
+        return data2.holding;
+      }
+    }
+  );
+  const usdc = React2.useMemo(() => {
+    const usdc2 = data == null ? void 0 : data.find((item) => item.token === "USDC");
+    return usdc2;
+  }, [data]);
+  useSWRSubscription__default.default("holding", (_, { next }) => {
+    const unsubscribe = ws.privateSubscribe(
+      {
+        id: "balance",
+        event: "subscribe",
+        topic: "balance",
+        ts: Date.now()
+      },
+      {
+        onMessage: (data2) => {
+          var _a;
+          const holding = (_a = data2 == null ? void 0 : data2.balances) != null ? _a : {};
+          if (holding) {
+            mutate2((prevData) => {
+              return prevData == null ? void 0 : prevData.map((item) => {
+                const token = holding[item.token];
+                return __spreadProps(__spreadValues({}, item), {
+                  frozen: token.frozen,
+                  holding: token.holding
+                });
+              });
+            });
+            next(holding);
+          }
+        }
+      }
+    );
+    return () => unsubscribe();
+  });
+  return {
+    data,
+    usdc,
+    isLoading
+  };
+};
+
+// src/orderly/useCollateral.ts
+var positionsPath = ramda.pathOr([], [0, "rows"]);
+ramda.pathOr(0, [0, "totalCollateral"]);
+var useCollateral = (options = { dp: 6 }) => {
+  const { dp } = options;
+  const positions2 = usePositionStream();
+  const { data: orders } = usePrivateQuery(
+    `/v1/orders?status=NEW`
+  );
+  const { data: accountInfo } = usePrivateQuery("/v1/client/info");
+  const symbolInfo = useSymbolsInfo();
+  const { data: markPrices } = useMarkPricesStream();
+  const { usdc } = useHoldingStream();
+  const [totalCollateral, totalValue] = React2.useMemo(() => {
+    return [
+      ramda.pathOr(utils.zero, [0, "totalCollateral"], positions2),
+      ramda.pathOr(utils.zero, [0, "totalValue"], positions2)
+    ];
+  }, [positions2, markPrices]);
+  const totalInitialMarginWithOrders = React2.useMemo(() => {
+    if (!accountInfo || !symbolInfo || !markPrices) {
+      return 0;
+    }
+    return futures.account.totalInitialMarginWithOrders({
+      positions: positionsPath(positions2),
+      orders: orders != null ? orders : [],
+      markPrices,
+      IMR_Factors: accountInfo.imr_factor,
+      maxLeverage: accountInfo.max_leverage,
+      symbolInfo
+    });
+  }, [positions2, orders, markPrices, accountInfo, symbolInfo]);
+  const freeCollateral = React2.useMemo(() => {
+    return futures.account.freeCollateral({
+      totalCollateral,
+      totalInitialMarginWithOrders
+    });
+  }, [totalCollateral, totalInitialMarginWithOrders]);
+  const availableBalance = React2.useMemo(() => {
+    var _a;
+    return futures.account.availableBalance({
+      USDCHolding: (_a = usdc == null ? void 0 : usdc.holding) != null ? _a : 0,
+      unsettlementPnL: pathOr_unsettledPnLPathOr(positions2)
+    });
+  }, [usdc, pathOr_unsettledPnLPathOr(positions2)]);
+  return {
+    totalCollateral: totalCollateral.toDecimalPlaces(dp).toNumber(),
+    freeCollateral: freeCollateral.toDecimalPlaces(dp).toNumber(),
+    totalValue: totalValue.toDecimalPlaces(dp).toNumber(),
+    availableBalance,
+    unsettledPnL: pathOr_unsettledPnLPathOr(positions2)
+  };
+};
+var positionsPath2 = ramda.pathOr([], [0, "rows"]);
+var useMaxQty = (symbol, side, reduceOnly = false) => {
+  const positionsData = usePositionStream();
+  const { data: orders } = usePrivateQuery(
+    `/v1/orders?status=NEW`
+  );
+  const { data: accountInfo } = usePrivateQuery("/v1/client/info");
+  const symbolInfo = useSymbolsInfo();
+  const { totalCollateral } = useCollateral();
+  const { data: markPrices } = useMarkPricesStream();
+  const maxQty = React2.useMemo(() => {
+    if (!symbol)
+      return 0;
+    const positions2 = positionsPath2(positionsData);
+    const positionQty = futures.account.getQtyFromPositions(positions2, symbol);
+    if (reduceOnly) {
+      if (positionQty > 0) {
+        if (side === types.OrderSide.BUY) {
+          return 0;
+        } else {
+          return Math.abs(positionQty);
+        }
+      }
+      if (positionQty < 0) {
+        if (side === types.OrderSide.BUY) {
+          return Math.abs(positionQty);
+        } else {
+          return 0;
+        }
+      }
+      return 0;
+    }
+    if (!markPrices || !markPrices[symbol] || !orders || !accountInfo)
+      return 0;
+    const getSymbolInfo = symbolInfo[symbol];
+    const buyOrdersQty = futures.account.getQtyFromOrdersBySide(
+      orders,
+      symbol,
+      types.OrderSide.BUY
+    );
+    const sellOrdersQty = futures.account.getQtyFromOrdersBySide(
+      orders,
+      symbol,
+      types.OrderSide.SELL
+    );
+    const otherPositions = positions2.filter(
+      (item) => item.symbol !== symbol
+    );
+    const otherOrders = orders.filter(
+      (item) => item.symbol !== symbol
+    );
+    const otherIMs = futures.account.otherIMs({
+      orders: otherOrders,
+      positions: otherPositions,
+      symbolInfo,
+      markPrices,
+      IMR_Factors: accountInfo.imr_factor,
+      maxLeverage: accountInfo.max_leverage
+    });
+    return futures.account.maxQty(side, {
+      markPrice: markPrices[symbol],
+      symbol,
+      baseMaxQty: getSymbolInfo("base_max"),
+      totalCollateral,
+      maxLeverage: accountInfo.max_leverage,
+      takerFeeRate: accountInfo.taker_fee_rate,
+      baseIMR: getSymbolInfo("base_imr"),
+      otherIMs,
+      positionQty,
+      buyOrdersQty,
+      sellOrdersQty,
+      IMR_Factor: accountInfo.imr_factor[getSymbolInfo("base")]
+    });
+  }, [
+    orders,
+    positionsData,
+    markPrices,
+    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 === types.OrderType.LIMIT ? !!data.order_type_ext ? data.order_type_ext : data.order_type : 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 = {
+        type: "required",
+        message: "quantity is required"
+      };
+    } else {
+      const { base_min, quote_dp, base_dp } = configs.symbol;
+      const qty = new utils.Decimal(order_quantity);
+      if (qty.lt(base_min)) {
+        errors.order_quantity = {
+          type: "min",
+          message: `quantity must be greater than ${new utils.Decimal(base_min).todp(
+            base_dp
+          )}`
+        };
+      } else if (qty.gt(maxQty)) {
+        errors.order_quantity = {
+          type: "max",
+          message: `quantity must be less than ${new utils.Decimal(maxQty).todp(
+            base_dp
+          )}`
+        };
+      }
+    }
+    if (!!total) {
+      const { quote_max, quote_min, quote_dp } = configs.symbol;
+      const totalNumber = new utils.Decimal(total);
+      if (totalNumber.lt(quote_min)) {
+        errors.total = {
+          type: "min",
+          message: `Quantity should be greater or equal than ${new utils.Decimal(
+            quote_min
+          ).todp(quote_dp)}`
+        };
+      } else if (totalNumber.gt(quote_max)) {
+        errors.total = {
+          type: "max",
+          message: `Quantity should be less or equal than ${new utils.Decimal(
+            quote_max
+          ).todp(quote_dp)}`
+        };
+      }
+    }
+    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 = {
+          type: "required",
+          message: "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 = {
+            type: "min",
+            message: `price must be greater than ${new utils.Decimal(
+              minPriceNumber
+            ).todp(symbol.quote_dp)}`
+          };
+        } else if (price.gt(maxPriceNumber)) {
+          errors.order_price = {
+            type: "max",
+            message: `price must be less than ${new utils.Decimal(
+              maxPriceNumber
+            ).todp(symbol.quote_dp)}`
+          };
+        }
+      }
+      return errors;
+    });
+  }
+};
+var MarketOrderCreator = class extends BaseOrderCreator {
+  create(values) {
+    const data = this.baseOrder(values);
+    delete data["order_price"];
+    return __spreadValues({}, data);
+  }
+  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(type) {
+    switch (type) {
+      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, side, reduceOnly = false, options) => {
+  const [doCreateOrder] = useMutation("/v1/order");
+  const { freeCollateral } = useCollateral();
+  const symbolInfo = useSymbolsInfo();
+  const baseDP = React2.useMemo(
+    () => utils.getPrecisionByNumber(symbolInfo[symbol]("base_tick", 0)),
+    [symbolInfo]
+  );
+  const quoteDP = React2.useMemo(() => {
+    return utils.getPrecisionByNumber(symbolInfo[symbol]("quote_tick", 0));
+  }, [symbolInfo]);
+  const { data: markPrice } = useMarkPrice(symbol);
+  const maxQty = useMaxQty(
+    symbol,
+    side,
+    // orderExtraValues.reduce_only
+    reduceOnly
+  );
+  const onSubmit = (values) => {
+    if (!values || typeof values.order_type === "undefined" || values.order_type !== types.OrderType.MARKET && values.order_type !== types.OrderType.LIMIT) {
+      throw new Error("order_type is error");
+    }
+    const orderCreator = OrderFactory.create(
+      !!values.order_type_ext ? values.order_type_ext : values.order_type
+    );
+    if (!orderCreator) {
+      return Promise.reject(new Error("orderCreator is null"));
+    }
+    return orderCreator == null ? void 0 : orderCreator.validate(values, {
+      symbol: symbolInfo[symbol](),
+      // token: tokenInfo[symbol](),
+      maxQty,
+      markPrice
+    }).then(() => {
+      if (!orderCreator) {
+        throw new Error("orderCreator is null");
+      }
+      if (!symbol) {
+        throw new Error("symbol is null");
+      }
+      const data = orderCreator.create(values);
+      return doCreateOrder(__spreadProps(__spreadValues({}, data), {
+        symbol
+      }));
+    });
+  };
+  const calculate = React2.useCallback(
+    (values, field, value) => {
+      console.log("calculate", values, field, value, markPrice);
+      const fieldHandler = getCalculateHandler(field);
+      const newValues = ramda.compose(
+        ramda.head,
+        orderEntityFormatHandle(),
+        fieldHandler,
+        baseInputHandle
+      )([values, field, value, markPrice, { baseDP, quoteDP }]);
+      return newValues;
+    },
+    [markPrice]
+  );
+  const validator = (values) => {
+    const creator = OrderFactory.create(values.order_type);
+    return creator == null ? void 0 : creator.validate(values, {
+      symbol: symbolInfo[symbol](),
+      // token: tokenInfo[symbol](),
+      maxQty,
+      markPrice
+    });
+  };
+  return {
+    maxQty,
+    freeCollateral,
+    markPrice,
+    onSubmit,
+    helper: {
+      calculate,
+      validator
+    },
+    symbolConfig: symbolInfo[symbol]()
+  };
+};
+var useFetures = () => {
+  const { data, isLoading, error } = useQuery(
+    `/v1/public/futures`,
+    {
+      revalidateOnFocus: false
+    }
+  );
+  const [sortedData, setSortedData] = React2.useState(data);
+  useWS();
+  React2.useEffect(() => {
+  }, []);
+  React2.useEffect(() => {
+    if (data) {
+      const sortedData2 = data.sort((a, b) => {
+        return 0;
+      });
+      setSortedData(sortedData2);
+    }
+  }, [data]);
+  const sortBy = React2.useCallback((key) => {
+  }, [data]);
+  const filterBy = React2.useCallback((key) => {
+  }, [data]);
+  return {
+    // ...data,
+    data: sortedData,
+    sortBy,
+    filterBy,
+    isLoading,
+    error
+  };
+};
+
+// src/orderly/useAccountInfo.ts
+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`, {
+    revalidateOnFocus: false
+  });
+  const { data: tickers } = useSWRSubscription__default.default("tickers", (_, { next }) => {
+    const unsubscribe = ws.subscribe(
+      // { event: "subscribe", topic: "markprices" },
+      "tickers",
+      {
+        onMessage: (message) => {
+          next(null, message);
+        }
+        // onUnsubscribe: () => {
+        //   return "markprices";
+        // },
+        // onError: (error: any) => {
+        //   console.log("error", error);
+        // },
+      }
+    );
+    return () => {
+      console.log("unsubscribe!!!!!!!");
+      unsubscribe == null ? void 0 : unsubscribe();
+    };
+  });
+  const value = React2.useMemo(() => {
+    if (!futures)
+      return null;
+    if (!tickers)
+      return futures;
+    return futures.map((item) => {
+      const ticker = tickers.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;
+    });
+  }, [futures, tickers]);
+  return { data: value };
+};
+var useLeverage = () => {
+  const { data, mutate: mutate2 } = usePrivateQuery("/v1/client/info");
+  const [update] = useMutation("/v1/client/leverage");
+  const updateLeverage = React2.useCallback((data2) => {
+    return update(data2).then((res) => {
+      return mutate2();
+    });
+  }, []);
+  return [ramda.prop("max_leverage", data), { update: updateLeverage }];
+};
+var useFundingRate = (symbol) => {
+  var _a;
+  if (!symbol) {
+    throw new Error("useFuturesForSymbol requires a symbol");
+  }
+  const [countDown, setCountDown] = React2.useState("00:00:00");
+  const { data } = useQuery(
+    `/v1/public/funding_rate/${symbol}`,
+    {
+      fallbackData: {
+        est_funding_rate: 0,
+        next_funing_time: 0
+      }
+    }
+  );
+  React2.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), {
+    est_funding_rate: (Number((_a = data == null ? void 0 : data.est_funding_rate) != null ? _a : 0) * 100).toFixed(4),
+    countDown
+  });
+};
+var fetcher3 = (url, init) => net.get(url, init);
+var usePrivateInfiniteQuery = (getKey, options) => {
+  var _a;
+  const account5 = useAccount();
+  const middleware = Array.isArray(options == null ? void 0 : options.use) ? (_a = options == null ? void 0 : options.use) != null ? _a : [] : [];
+  const result = useSWRInfinite__default.default(
+    (pageIndex, previousPageData) => account5.state.status >= types.AccountStatusEnum.EnableTrading ? getKey(pageIndex, previousPageData) : null,
+    fetcher3,
+    __spreadProps(__spreadValues({}, options), {
+      use: [signatureMiddleware, ...middleware]
+    })
+  );
+  return result;
+};
+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,
+  symbol,
+  side,
+  size = 100
+} = {}) => {
+  const ee = useEventEmitter();
+  const { data: markPrices = {} } = useMarkPricesStream();
+  const [doCancelOrder] = useMutation("/v1/order", "DELETE");
+  const [doUpdateOrder] = useMutation("/v1/order", "PUT");
+  const ordersResponse = usePrivateInfiniteQuery(
+    (pageIndex, previousPageData) => {
+      const search = new URLSearchParams([
+        ["size", size.toString()],
+        ["page", `${pageIndex + 1}`]
+        // [`status`, status],
+      ]);
+      if (status) {
+        search.set(`status`, status);
+      }
+      if (symbol) {
+        search.set(`symbol`, symbol);
+      }
+      if (side) {
+        search.set(`side`, side);
+      }
+      return `/v1/orders?${search.toString()}`;
+    },
+    {
+      initialSize: 1,
+      onError: (err) => {
+        console.error("fetch failed::::", err);
+      }
+    }
+  );
+  const orders = React2.useMemo(() => {
+    var _a;
+    if (!ordersResponse.data) {
+      return null;
+    }
+    return (_a = ordersResponse.data) == null ? void 0 : _a.flat().map((item) => {
+      var _a2;
+      return __spreadProps(__spreadValues({}, item), {
+        mark_price: (_a2 = markPrices[item.symbol]) != null ? _a2 : 0
+      });
+    });
+  }, [ordersResponse.data, markPrices]);
+  React2.useEffect(() => {
+    const handler = () => ordersResponse.mutate();
+    ee.on("orders:changed", handler);
+    return () => {
+      ee.off("orders:changed", handler);
+    };
+  }, []);
+  const cancelAllOrders = React2.useCallback(() => {
+  }, [ordersResponse.data]);
+  const updateOrder = React2.useCallback((orderId, order2) => {
+    return doUpdateOrder(__spreadProps(__spreadValues({}, order2), { order_id: orderId }));
+  }, []);
+  const cancelOrder = React2.useCallback((orderId, symbol2) => {
+    return doCancelOrder(null, {
+      order_id: orderId,
+      symbol: symbol2
+    }).then((res) => {
+      if (res.success) {
+        return ordersResponse.mutate().then(() => {
+          return res;
+        });
+      } else {
+        throw new Error(res.message);
+      }
+    });
+  }, []);
+  return [
+    orders,
+    {
+      cancelAllOrders,
+      updateOrder,
+      cancelOrder
+    }
+  ];
+};
+var useMarketTradeStream = (symbol, options = {}) => {
+  if (!symbol) {
+    throw new Error("useTradeStream: symbol is required");
+  }
+  const [trades, setTrades] = React2.useState([]);
+  const [isLoading, setIsLoading] = React2.useState(false);
+  React2.useState(() => symbol);
+  const { limit = 50 } = options;
+  const ws = useWS();
+  React2.useEffect(() => {
+    setIsLoading(true);
+    setTrades(() => []);
+    ws.onceSubscribe(
+      {
+        id: `${symbol}@trade`,
+        event: "request",
+        params: {
+          type: "trade",
+          symbol,
+          limit
+        }
+      },
+      {
+        onMessage: (data) => {
+          setIsLoading(false);
+          setTrades(() => data);
+        }
+      }
+    );
+  }, [symbol]);
+  React2.useEffect(() => {
+    const unsubscript = ws.subscribe(
+      {
+        id: `${symbol}@trade`,
+        event: "subscribe",
+        topic: `${symbol}@trade`,
+        ts: Date.now()
+      },
+      {
+        onMessage: (data) => {
+          setTrades((prev) => {
+            const arr = [__spreadProps(__spreadValues({}, data), { ts: Date.now() }), ...prev];
+            if (arr.length > limit) {
+              arr.pop();
+            }
+            return arr;
+          });
+        }
+      }
+    );
+    return () => {
+      unsubscript == null ? void 0 : unsubscript();
+    };
+  }, [symbol]);
+  console.log("trades", trades);
+  return { data: trades, isLoading };
+};
+var useMarginRatio = () => {
+  const [{ rows }] = usePositionStream();
+  const { data: markPrices } = useMarkPricesStream();
+  const { totalCollateral } = useCollateral();
+  const marginRatio = React2.useMemo(() => {
+    if (!rows || !markPrices || !totalCollateral || rows.length === 0) {
+      return 0;
+    }
+    const ratio = futures.account.totalMarginRatio({
+      totalCollateral,
+      markPrices,
+      positions: rows != null ? rows : []
+    });
+    return ratio;
+  }, [rows, markPrices, totalCollateral]);
+  const currentLeverage = React2.useMemo(() => {
+    return futures.account.currentLeverage(marginRatio);
+  }, [marginRatio]);
+  return { marginRatio, currentLeverage };
+};
+var useChains = (networkId, options = {}) => {
+  const _a = options, swrOptions = __objRest(_a, ["filter", "pick"]);
+  const field = options == null ? void 0 : options.pick;
+  const { data } = useSWR__default.default(
+    "https://fi-api.woo.org/swap_support",
+    (url) => fetch(url).then((res) => res.json()),
+    __spreadValues({
+      revalidateOnFocus: false,
+      revalidateOnReconnect: false
+    }, swrOptions)
+  );
+  const chains = React2.useMemo(() => {
+    if (!data || !data.data)
+      return data;
+    let arr = [];
+    Object.keys(data.data).forEach((key) => {
+      const item = data.data[key];
+      arr.push(__spreadProps(__spreadValues({}, item), {
+        name: key
+      }));
+    });
+    if (networkId === "mainnet") {
+      arr = arr.filter((item) => item.network_infos.mainnet);
+    }
+    if (networkId === "testnet") {
+      arr = arr.filter((item) => !item.network_infos.mainnet);
+    }
+    if (typeof (options == null ? void 0 : options.filter) === "function") {
+      arr = arr.filter(options.filter);
+    }
+    if (typeof field !== "undefined") {
+      return arr.map((item) => {
+        return item[field];
+      });
+    }
+    return arr;
+  }, [data, networkId, field, options]);
+  const findByChainId = React2.useCallback(
+    (chainId) => {
+      if (!data || !data.data)
+        return void 0;
+      return data.data[chainId];
+    },
+    [data]
+  );
+  return [chains, { findByChainId }];
+};
+var useChain = (token) => {
+  const { data, isLoading } = useQuery("/v1/public/token");
+  const chains = React2.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 = types.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 useWithdraw = () => {
+  const { account: account5, state } = useAccount();
+  const [isLoading, setIsLoading] = React2.useState(false);
+  const { unsettledPnL, availableBalance } = useCollateral();
+  const withdraw = React2.useCallback(
+    (inputs) => {
+      return account5.assetsManager.withdraw(inputs).then((res) => {
+        console.log("---------- withdraw -------", res);
+        return res;
+      });
+    },
+    [state]
+  );
+  const { usdc } = useHoldingStream();
+  const maxAmount = React2.useMemo(() => {
+    var _a;
+    if (!usdc || !usdc.holding)
+      return 0;
+    if (unsettledPnL >= 0)
+      return (_a = usdc == null ? void 0 : usdc.holding) != null ? _a : 0;
+    return new utils.Decimal(usdc.holding).add(unsettledPnL).toNumber();
+  }, [usdc, unsettledPnL]);
+  return { withdraw, isLoading, maxAmount, availableBalance, unsettledPnL };
+};
+var useDeposit = () => {
+  const [balance, setBalance] = React2.useState("0");
+  const [allowance, setAllowance] = React2.useState("0");
+  const { account: account5, state } = useAccount();
+  const fetchBalance = React2.useCallback(() => __async(void 0, null, function* () {
+    const balance2 = yield account5.assetsManager.getBalance();
+    setBalance(() => balance2);
+  }), [state]);
+  const fetchAllowance = React2.useCallback(() => __async(void 0, null, function* () {
+    const allowance2 = yield account5.assetsManager.getAllowance();
+    console.log("----- refresh allowance -----", allowance2);
+    setAllowance(() => allowance2);
+    return allowance2;
+  }), []);
+  React2.useEffect(() => {
+    if (state.status < types.AccountStatusEnum.EnableTrading)
+      return;
+    fetchBalance();
+    fetchAllowance();
+  }, [state]);
+  const approve = React2.useCallback(
+    (amount) => {
+      return account5.assetsManager.approve(amount).then((result) => {
+        setAllowance((value) => new utils.Decimal(value).add(amount).toString());
+        return result;
+      });
+    },
+    [account5, fetchAllowance]
+  );
+  const deposit = React2.useCallback(
+    (amount) => {
+      return account5.assetsManager.deposit(amount).then((res) => {
+        console.log("----- deposit -----", res);
+        setAllowance((value) => new utils.Decimal(value).sub(amount).toString());
+        setBalance((value) => new utils.Decimal(value).sub(amount).toString());
+        return res;
+      });
+    },
+    [account5, fetchBalance, fetchAllowance]
+  );
+  return {
+    balance,
+    allowance,
+    approve,
+    deposit
+  };
+};
+var useWalletSubscription = (options) => {
+  const ws = useWS();
+  return useSWRSubscription__default.default("wallet", (_, { next }) => {
+    const unsubscribe = ws.privateSubscribe(
+      {
+        id: "wallet",
+        event: "subscribe",
+        topic: "wallet",
+        ts: Date.now()
+      },
+      {
+        onMessage: (data) => {
+          var _a;
+          (_a = options == null ? void 0 : options.onMessage) == null ? void 0 : _a.call(options, data);
+          next(data);
+        }
+      }
+    );
+    return () => unsubscribe();
+  });
+};
+var useBalance = () => {
+  const ws = useWS();
+  const { data } = useSWRSubscription__default.default("balance", (_, { next }) => {
+    const unsubscribe = ws.privateSubscribe("balance", {
+      onMessage: (data2) => {
+        console.log(data2);
+      }
+    });
+    return () => unsubscribe();
+  });
+  return data;
+};
+var usePrivateDataObserver = () => {
+  const ws = useWS();
+  const { mutate: mutate2 } = useSWR.useSWRConfig();
+  const ee = useEventEmitter();
+  const { state } = useAccount();
+  React2.useEffect(() => {
+    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 === types.OrderStatus.NEW) {
+              return [
+                __spreadProps(__spreadValues({}, data), {
+                  // average_executed_price:data.ava
+                  created_time: data.timestamp,
+                  order_id: data.orderId
+                  // reduce_only
+                }),
+                ...orders
+              ];
+            }
+            if (data.status === types.OrderStatus.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]);
+  React2.useEffect(() => {
+    console.log("subscribe: position: %s", state.accountId);
+    if (!state.accountId)
+      return;
+    const key = ["/v1/positions", state.accountId];
+    const unsubscribe = ws.privateSubscribe("position", {
+      onMessage: (data) => {
+        const { positions: nextPostions } = data;
+        mutate2(key, (prevPositions) => {
+          if (!!prevPositions) {
+            return __spreadProps(__spreadValues({}, prevPositions), {
+              rows: prevPositions.rows.map((row) => {
+                const item = nextPostions.find(
+                  (item2) => item2.symbol === row.symbol
+                );
+                if (item) {
+                  return {
+                    symbol: item.symbol,
+                    position_qty: item.positionQty,
+                    cost_position: item.costPosition,
+                    last_sum_unitary_funding: item.lastSumUnitaryFunding,
+                    pending_long_qty: item.pendingLongQty,
+                    pending_short_qty: item.pendingShortQty,
+                    settle_price: item.settlePrice,
+                    average_open_price: item.averageOpenPrice,
+                    unsettled_pnl: item.unsettledPnl,
+                    mark_price: item.markPrice,
+                    est_liq_price: item.estLiqPrice,
+                    timestamp: Date.now(),
+                    imr: item.imr,
+                    mmr: item.mmr,
+                    IMR_withdraw_orders: item.imrwithOrders,
+                    MMR_with_orders: item.mmrwithOrders,
+                    pnl_24_h: item.pnl24H,
+                    fee_24_h: item.fee24H
+                  };
+                }
+                return row;
+              })
+            });
+          }
+        });
+      }
+    });
+    return () => {
+      console.log("unsubscribe: private subscription position");
+      unsubscribe == null ? void 0 : unsubscribe();
+    };
+  }, [state.accountId]);
+};
+var useExecutionReport = () => {
+  const ws = useWS();
+  const { data } = useSWRSubscription__default.default("executionreport", (_, { next }) => {
+    const unsubscribe = ws.privateSubscribe("executionreport", {
+      onMessage: (data2) => {
+        console.log(data2);
+      }
+    });
+    return () => unsubscribe();
+  });
+  return data;
+};
+
+// src/apis/index.ts
+var apis_exports = {};
+__export(apis_exports, {
+  useFundingRateBySymbol: () => useFundingRateBySymbol,
+  useInfo: () => useInfo,
+  useToken: () => useToken
+});
+
+// src/apis/useInfo.ts
+var useInfo = () => {
+  return useQuery("/v1/public/info", {
+    // refreshInterval: 1000 * 60 * 60 * 24,
+  });
+};
+
+// src/apis/useToken.ts
+var useToken = () => {
+  return useQuery("/v1/public/token");
+};
+
+// src/apis/useFundingRateBySymbol.ts
+var useFundingRateBySymbol = (symbol) => {
+  if (!symbol) {
+    throw new Error("symbol is required");
+  }
+  return useQuery(`/public/funding_rate/${symbol}`);
+};
+
+Object.defineProperty(exports, 'SWRConfig', {
+  enumerable: true,
+  get: function () { return useSWR.SWRConfig; }
+});
+Object.defineProperty(exports, 'useSWR', {
+  enumerable: true,
+  get: function () { return useSWR__default.default; }
+});
+Object.defineProperty(exports, 'useConstant', {
+  enumerable: true,
+  get: function () { return useConstant__default.default; }
+});
+exports.DataSourceProvider = DataSourceProvider;
+exports.OrderStatus = OrderStatus;
+exports.OrderlyContext = OrderlyContext;
+exports.OrderlyProvider = OrderlyProvider;
+exports.apis = apis_exports;
+exports.useAccount = useAccount;
+exports.useAccountInfo = useAccountInfo;
+exports.useAccountInstance = useAccountInstance;
+exports.useAppState = useAppState;
+exports.useBalance = useBalance;
+exports.useChain = useChain;
+exports.useChains = useChains;
+exports.useCollateral = useCollateral;
+exports.useConfig = useConfig;
+exports.useDeposit = useDeposit;
+exports.useEventEmitter = useEventEmitter;
+exports.useExecutionReport = useExecutionReport;
+exports.useFetures = useFetures;
+exports.useFundingRate = useFundingRate;
+exports.useHoldingStream = useHoldingStream;
+exports.useLeverage = useLeverage;
+exports.useLocalStorage = useLocalStorage;
+exports.useMarginRatio = useMarginRatio;
+exports.useMarkPrice = useMarkPrice;
+exports.useMarkPricesStream = useMarkPricesStream;
+exports.useMarketTradeStream = useMarketTradeStream;
+exports.useMarketsStream = useMarketsStream;
+exports.useMaxQty = useMaxQty;
+exports.useMutation = useMutation;
+exports.useOrderEntry = useOrderEntry;
+exports.useOrderStream = useOrderStream;
+exports.useOrderbookStream = useOrderbookStream;
+exports.usePositionStream = usePositionStream;
+exports.usePreLoadData = usePreLoadData;
+exports.usePrivateDataObserver = usePrivateDataObserver;
+exports.usePrivateObserve = usePrivateObserve;
+exports.usePrivateQuery = usePrivateQuery;
+exports.useQuery = useQuery;
+exports.useRunOnce = useRunOnce;
+exports.useSessionStorage = useSessionStorage;
+exports.useSymbolsInfo = useSymbolsInfo;
+exports.useTickerStream = useTickerStream;
+exports.useTokenInfo = useTokenInfo;
+exports.useTopicObserve = useTopicObserve;
+exports.useTradingView = useTradingView;
+exports.useWS = useWS;
+exports.useWalletSubscription = useWalletSubscription;
+exports.useWithdraw = useWithdraw;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map